// Copyright (C) 2018 Torbjorn Sjostrand.
// PYTHIA is licenced under the GNU GPL v2 or later, see COPYING for details.
// Please respect the MCnet Guidelines, see GUIDELINES for details.
// Author: Philip Ilten, March 2016.

// This file contains a Python interface to Pythia 8 generated with SWIG.

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


#ifndef SWIGPYTHON
#define SWIGPYTHON
#endif

#define SWIG_DIRECTORS
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE


#ifdef __cplusplus
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigMovePointer {
    T *ptr;
    SwigMovePointer(T *p) : ptr(p) { }
    ~SwigMovePointer() { delete ptr; }
    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  operator T&() const { return *pointer.ptr; }
  T *operator&() { return pointer.ptr; }
};

template <typename T> T SwigValueInit() {
  return T();
}
#endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif

#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif

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

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

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


/*
   Flags/methods for returning states.

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

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

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

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

   Now you can be more explicit:

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

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

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

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

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

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

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

       int food(double)
       int fooi(int);

   and you call

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

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

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

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

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


#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#ifdef __cplusplus
}
#endif

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



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

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

#endif

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

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

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


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

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


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

/* Add PyOS_snprintf for old Pythons */
#if PY_VERSION_HEX < 0x02020000
# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
#  define PyOS_snprintf _snprintf
# else
#  define PyOS_snprintf snprintf
# endif
#endif

/* A crude PyString_FromFormat implementation for old Pythons */
#if PY_VERSION_HEX < 0x02020000

#ifndef SWIG_PYBUFFER_SIZE
# define SWIG_PYBUFFER_SIZE 1024
#endif

static PyObject *
PyString_FromFormat(const char *fmt, ...) {
  va_list ap;
  char buf[SWIG_PYBUFFER_SIZE * 2];
  int res;
  va_start(ap, fmt);
  res = vsnprintf(buf, sizeof(buf), fmt, ap);
  va_end(ap);
  return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
}
#endif

/* Add PyObject_Del for old Pythons */
#if PY_VERSION_HEX < 0x01060000
# define PyObject_Del(op) PyMem_DEL((op))
#endif
#ifndef PyObject_DEL
# define PyObject_DEL PyObject_Del
#endif

/* A crude PyExc_StopIteration exception for old Pythons */
#if PY_VERSION_HEX < 0x02020000
# ifndef PyExc_StopIteration
#  define PyExc_StopIteration PyExc_RuntimeError
# endif
# ifndef PyObject_GenericGetAttr
#  define PyObject_GenericGetAttr 0
# endif
#endif

/* Py_NotImplemented is defined in 2.1 and up. */
#if PY_VERSION_HEX < 0x02010000
# ifndef Py_NotImplemented
#  define Py_NotImplemented PyExc_RuntimeError
# endif
#endif

/* A crude PyString_AsStringAndSize implementation for old Pythons */
#if PY_VERSION_HEX < 0x02010000
# ifndef PyString_AsStringAndSize
#  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
# endif
#endif

/* PySequence_Size for old Pythons */
#if PY_VERSION_HEX < 0x02000000
# ifndef PySequence_Size
#  define PySequence_Size PySequence_Length
# endif
#endif

/* PyBool_FromLong for old Pythons */
#if PY_VERSION_HEX < 0x02030000
static
PyObject *PyBool_FromLong(long ok)
{
  PyObject *result = ok ? Py_True : Py_False;
  Py_INCREF(result);
  return result;
}
#endif

/* Py_ssize_t for old Pythons */
/* This code is as recommended by: */
/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
typedef int Py_ssize_t;
# define PY_SSIZE_T_MAX INT_MAX
# define PY_SSIZE_T_MIN INT_MIN
typedef inquiry lenfunc;
typedef intargfunc ssizeargfunc;
typedef intintargfunc ssizessizeargfunc;
typedef intobjargproc ssizeobjargproc;
typedef intintobjargproc ssizessizeobjargproc;
typedef getreadbufferproc readbufferproc;
typedef getwritebufferproc writebufferproc;
typedef getsegcountproc segcountproc;
typedef getcharbufferproc charbufferproc;
static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
{
  long result = 0;
  PyObject *i = PyNumber_Int(x);
  if (i) {
    result = PyInt_AsLong(i);
    Py_DECREF(i);
  }
  return result;
}
#endif

#if PY_VERSION_HEX < 0x02050000
#define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
#endif

#if PY_VERSION_HEX < 0x02040000
#define Py_VISIT(op)				\
  do { 						\
    if (op) {					\
      int vret = visit((op), arg);		\
      if (vret)					\
        return vret;				\
    }						\
  } while (0)
#endif

#if PY_VERSION_HEX < 0x02030000
typedef struct {
  PyTypeObject type;
  PyNumberMethods as_number;
  PyMappingMethods as_mapping;
  PySequenceMethods as_sequence;
  PyBufferProcs as_buffer;
  PyObject *name, *slots;
} PyHeapTypeObject;
#endif

#if PY_VERSION_HEX < 0x02030000
typedef destructor freefunc;
#endif

#if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
     (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
     (PY_MAJOR_VERSION > 3))
# define SWIGPY_USE_CAPSULE
# define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
#endif

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

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

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


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

  if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
  if (value) {
    char *tmp;
    PyObject *old_str = PyObject_Str(value);
    PyErr_Clear();
    Py_XINCREF(type);

    PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
    SWIG_Python_str_DelForPy3(tmp);
    Py_DECREF(old_str);
    Py_DECREF(value);
  } else {
    PyErr_SetString(PyExc_RuntimeError, mesg);
  }
}

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

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

#ifdef __cplusplus
extern "C" {
#endif

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

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

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


/* -----------------------------------------------------------------------------
 * Wrapper of PyInstanceMethod_New() used in Python 3
 * It is exported to the generated module, used for -fastproxy
 * ----------------------------------------------------------------------------- */
#if PY_VERSION_HEX >= 0x03000000
SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
{
  return PyInstanceMethod_New(func);
}
#else
SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
{
  return NULL;
}
#endif

#ifdef __cplusplus
}
#endif


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

/* Common SWIG API */

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

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

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

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

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

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

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

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


/* Runtime API */

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

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


/* Runtime API implementation */

/* Error manipulation */

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

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

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

/* Set a constant value */

#if defined(SWIGPYTHON_BUILTIN)

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

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {   
#if PY_VERSION_HEX < 0x02030000
  PyDict_SetItemString(d, (char *)name, obj);
#else
  PyDict_SetItemString(d, name, obj);
#endif
  Py_DECREF(obj);
  if (public_interface)
    SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}

#else

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
#if PY_VERSION_HEX < 0x02030000
  PyDict_SetItemString(d, (char *)name, obj);
#else
  PyDict_SetItemString(d, name, obj);
#endif
  Py_DECREF(obj);                            
}

#endif

/* Append a value to the result obj */

SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
  if (!result) {
    result = obj;
  } else if (result == Py_None) {
    Py_DECREF(result);
    result = obj;
  } else {
    if (!PyList_Check(result)) {
      PyObject *o2 = result;
      result = PyList_New(1);
      PyList_SetItem(result, 0, o2);
    }
    PyList_Append(result,obj);
    Py_DECREF(obj);
  }
  return result;
#else
  PyObject*   o2;
  PyObject*   o3;
  if (!result) {
    result = obj;
  } else if (result == Py_None) {
    Py_DECREF(result);
    result = obj;
  } else {
    if (!PyTuple_Check(result)) {
      o2 = result;
      result = PyTuple_New(1);
      PyTuple_SET_ITEM(result, 0, o2);
    }
    o3 = PyTuple_New(1);
    PyTuple_SET_ITEM(o3, 0, obj);
    o2 = result;
    result = PySequence_Concat(o2, o3);
    Py_DECREF(o2);
    Py_DECREF(o3);
  }
  return result;
#endif
}

/* Unpack the argument tuple */

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

/* A functor is a function object with one single object argument */
#if PY_VERSION_HEX >= 0x02020000
#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunctionObjArgs(functor, obj, NULL);
#else
#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunction(functor, "O", obj);
#endif

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

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

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

#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)

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

#ifdef __cplusplus
extern "C" {
#endif

/*  How to access Py_None */
#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#  ifndef SWIG_PYTHON_NO_BUILD_NONE
#    ifndef SWIG_PYTHON_BUILD_NONE
#      define SWIG_PYTHON_BUILD_NONE
#    endif
#  endif
#endif

#ifdef SWIG_PYTHON_BUILD_NONE
#  ifdef Py_None
#   undef Py_None
#   define Py_None SWIG_Py_None()
#  endif
SWIGRUNTIMEINLINE PyObject * 
_SWIG_Py_None(void)
{
  PyObject *none = Py_BuildValue((char*)"");
  Py_DECREF(none);
  return none;
}
SWIGRUNTIME PyObject * 
SWIG_Py_None(void)
{
  static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
  return none;
}
#endif

/* The python void return value */

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

/* SwigPyClientData */

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

SWIGRUNTIMEINLINE int 
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
  SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
  return data ? data->implicitconv : 0;
}

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


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

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

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

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


#ifdef SWIGPYTHON_BUILTIN

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

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

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

#endif

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

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

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

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

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

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

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


SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);

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

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

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

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

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

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

      PyErr_Restore(val, type, tb);

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

SWIGRUNTIME PyObject* 
SwigPyObject_append(PyObject* v, PyObject* next)
{
  SwigPyObject *sobj = (SwigPyObject *) v;
#ifndef METH_O
  PyObject *tmp = 0;
  if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
  next = tmp;
#endif
  if (!SwigPyObject_Check(next)) {
    PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
    return NULL;
  }
  sobj->next = next;
  Py_INCREF(next);
  return SWIG_Py_Void();
}

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

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

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

SWIGINTERN PyObject*
SwigPyObject_own(PyObject *v, PyObject *args)
{
  PyObject *val = 0;
#if (PY_VERSION_HEX < 0x02020000)
  if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
#elif (PY_VERSION_HEX < 0x02050000)
  if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) 
#else
  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) 
#endif
    {
      return NULL;
    } 
  else
    {
      SwigPyObject *sobj = (SwigPyObject *)v;
      PyObject *obj = PyBool_FromLong(sobj->own);
      if (val) {
#ifdef METH_NOARGS
	if (PyObject_IsTrue(val)) {
	  SwigPyObject_acquire(v);
	} else {
	  SwigPyObject_disown(v);
	}
#else
	if (PyObject_IsTrue(val)) {
	  SwigPyObject_acquire(v,args);
	} else {
	  SwigPyObject_disown(v,args);
	}
#endif
      } 
      return obj;
    }
}

#ifdef METH_O
static PyMethodDef
swigobject_methods[] = {
  {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)"acquires ownership of the pointer"},
  {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
  {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_O,       (char *)"appends another 'this' object"},
  {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
  {0, 0, 0, 0}  
};
#else
static PyMethodDef
swigobject_methods[] = {
  {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS,  (char *)"acquires ownership of the pointer"},
  {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
  {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
  {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
  {0, 0, 0, 0}  
};
#endif

#if PY_VERSION_HEX < 0x02020000
SWIGINTERN PyObject *
SwigPyObject_getattr(SwigPyObject *sobj,char *name)
{
  return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
}
#endif

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

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

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

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

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

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

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

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

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

SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);

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

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

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

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

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

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

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

SWIGRUNTIMEINLINE PyObject *
_SWIG_This(void)
{
    return SWIG_Python_str_FromChar("this");
}

static PyObject *swig_this = NULL;

SWIGRUNTIME PyObject *
SWIG_This(void)
{
  if (swig_this == NULL)
    swig_this = _SWIG_This();
  return swig_this;
}

/* #define SWIG_PYTHON_SLOW_GETSET_THIS */

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

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

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

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

  obj = 0;

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

/* Acquire a pointer value */

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

/* Convert a pointer value */

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

  if (!obj)
    return SWIG_ERROR;
  if (obj == Py_None && !implicit_conv) {
    if (ptr)
      *ptr = 0;
    return SWIG_OK;
  }

  res = SWIG_ERROR;

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

/* Convert a function ptr value */

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

/* Convert a packed value value */

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

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

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

SWIGRUNTIME PyObject* 
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
#if (PY_VERSION_HEX >= 0x02020000)
  PyObject *inst = 0;
  PyObject *newraw = data->newraw;
  if (newraw) {
    inst = PyObject_Call(newraw, data->newargs, NULL);
    if (inst) {
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
      PyObject **dictptr = _PyObject_GetDictPtr(inst);
      if (dictptr != NULL) {
	PyObject *dict = *dictptr;
	if (dict == NULL) {
	  dict = PyDict_New();
	  *dictptr = dict;
	  PyDict_SetItem(dict, SWIG_This(), swig_this);
	}
      }
#else
      PyObject *key = SWIG_This();
      PyObject_SetAttr(inst, key, swig_this);
#endif
    }
  } else {
#if PY_VERSION_HEX >= 0x03000000
    inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
    if (inst) {
      PyObject_SetAttr(inst, SWIG_This(), swig_this);
      Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
    }
#else
    PyObject *dict = PyDict_New();
    if (dict) {
      PyDict_SetItem(dict, SWIG_This(), swig_this);
      inst = PyInstance_NewRaw(data->newargs, dict);
      Py_DECREF(dict);
    }
#endif
  }
  return inst;
#else
#if (PY_VERSION_HEX >= 0x02010000)
  PyObject *inst = 0;
  PyObject *dict = PyDict_New();
  if (dict) {
    PyDict_SetItem(dict, SWIG_This(), swig_this);
    inst = PyInstance_NewRaw(data->newargs, dict);
    Py_DECREF(dict);
  }
  return (PyObject *) inst;
#else
  PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
  if (inst == NULL) {
    return NULL;
  }
  inst->in_class = (PyClassObject *)data->newargs;
  Py_INCREF(inst->in_class);
  inst->in_dict = PyDict_New();
  if (inst->in_dict == NULL) {
    Py_DECREF(inst);
    return NULL;
  }
#ifdef Py_TPFLAGS_HAVE_WEAKREFS
  inst->in_weakreflist = NULL;
#endif
#ifdef Py_TPFLAGS_GC
  PyObject_GC_Init(inst);
#endif
  PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
  return (PyObject *) inst;
#endif
#endif
}

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


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

/* Create a new pointer object */

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

  if (!ptr)
    return SWIG_Py_Void();

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

  assert(!(flags & SWIG_BUILTIN_TP_INIT));

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

/* Create a new packed object */

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

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

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

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

#if PY_MAJOR_VERSION < 2
/* PyModule_AddObject function was introduced in Python 2.0.  The following function
   is copied out of Python/modsupport.c in python version 2.3.4 */
SWIGINTERN int
PyModule_AddObject(PyObject *m, char *name, PyObject *o)
{
  PyObject *dict;
  if (!PyModule_Check(m)) {
    PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg");
    return SWIG_ERROR;
  }
  if (!o) {
    PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value");
    return SWIG_ERROR;
  }
  
  dict = PyModule_GetDict(m);
  if (dict == NULL) {
    /* Internal error -- modules must have a dict! */
    PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
		 PyModule_GetName(m));
    return SWIG_ERROR;
  }
  if (PyDict_SetItemString(dict, name, o))
    return SWIG_ERROR;
  Py_DECREF(o);
  return SWIG_OK;
}
#endif

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

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

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

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

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

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

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

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


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

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

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

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

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


#ifdef __cplusplus
}
#endif



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

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



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

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

/*
  Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
  'Swig' namespace. This could be useful for multi-modules projects.
*/
#ifdef SWIG_DIRECTOR_STATIC
/* Force anonymous (static) namespace */
#define Swig
#endif
/* -----------------------------------------------------------------------------
 * director.swg
 *
 * This file contains support for director classes so that Python proxy
 * methods can be called from C++.
 * ----------------------------------------------------------------------------- */

#ifndef SWIG_DIRECTOR_PYTHON_HEADER_
#define SWIG_DIRECTOR_PYTHON_HEADER_

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


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

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



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


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

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

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

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

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

#else

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

#endif /* SWIG_DIRECTOR_NORTTI */

extern "C" {
  struct swig_type_info;
}

namespace Swig {

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

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

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

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

    ~GCItem_var() {
      delete _item;
    }

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

  private:
    GCItem *_item;
  };

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

    virtual ~GCItem_Object() {
    }

    int get_own() const {
      return _own;
    }

  private:
    int _own;
  };

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

    virtual ~GCItem_T() {
      delete _ptr;
    }

  private:
    Type *_ptr;
  };

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

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

  private:
    Type *_ptr;
  };

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

    virtual ~DirectorException() throw() {
    }

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

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

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

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

  /* unknown exception handler  */
  class UnknownExceptionHandler {
#ifdef SWIG_DIRECTOR_UEH
    static void handler() {
      try {
        throw;
      } catch (DirectorException& e) {
        std::cerr << "SWIG Director exception caught:" << std::endl
                  << e.what() << std::endl;
      } catch (std::exception& e) {
        std::cerr << "std::exception caught: "<< e.what() << std::endl;
      } catch (...) {
        std::cerr << "Unknown exception caught." << std::endl;
      }

      std::cerr << std::endl
                << "Python interpreter traceback:" << std::endl;
      PyErr_Print();
      std::cerr << std::endl;

      std::cerr << "This exception was caught by the SWIG unexpected exception handler." << std::endl
                << "Try using %feature(\"director:except\") to avoid reaching this point." << std::endl
                << std::endl
                << "Exception is being re-thrown, program will likely abort/terminate." << std::endl;
      throw;
    }

  public:

    std::unexpected_handler old;
    UnknownExceptionHandler(std::unexpected_handler nh = handler) {
      old = std::set_unexpected(nh);
    }

    ~UnknownExceptionHandler() {
      std::set_unexpected(old);
    }
#endif
  };

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

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

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

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

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

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

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

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


#if defined(SWIG_PYTHON_THREADS)
/*  __THREAD__ is the old macro to activate some thread support */
# if !defined(__THREAD__)
#   define __THREAD__ 1
# endif
#endif

#ifdef __THREAD__
# include "pythread.h"
  class Guard {
    PyThread_type_lock &mutex_;

  public:
    Guard(PyThread_type_lock & mutex) : mutex_(mutex) {
      PyThread_acquire_lock(mutex_, WAIT_LOCK);
    }

    ~Guard() {
      PyThread_release_lock(mutex_);
    }
  };
# define SWIG_GUARD(mutex) Guard _guard(mutex)
#else
# define SWIG_GUARD(mutex)
#endif

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

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

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

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

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

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

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

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

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

  /* ownership management */
  private:
    typedef std::map<void *, GCItem_var> swig_ownership_map;
    mutable swig_ownership_map swig_owner;
#ifdef __THREAD__
    static PyThread_type_lock swig_mutex_own;
#endif

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

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

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

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

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

#ifdef __THREAD__
  PyThread_type_lock Director::swig_mutex_own = PyThread_allocate_lock();
#endif
}

#endif

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

#define SWIGTYPE_p_Pythia8__AlpgenHooks swig_types[0]
#define SWIGTYPE_p_Pythia8__AlpgenPar swig_types[1]
#define SWIGTYPE_p_Pythia8__AlphaEM swig_types[2]
#define SWIGTYPE_p_Pythia8__AlphaStrong swig_types[3]
#define SWIGTYPE_p_Pythia8__Angantyr swig_types[4]
#define SWIGTYPE_p_Pythia8__BeamParticle swig_types[5]
#define SWIGTYPE_p_Pythia8__BeamRemnants swig_types[6]
#define SWIGTYPE_p_Pythia8__BeamShape swig_types[7]
#define SWIGTYPE_p_Pythia8__BoseEinstein swig_types[8]
#define SWIGTYPE_p_Pythia8__BoseEinsteinHadron swig_types[9]
#define SWIGTYPE_p_Pythia8__CJKL swig_types[10]
#define SWIGTYPE_p_Pythia8__CTEQ5L swig_types[11]
#define SWIGTYPE_p_Pythia8__CTEQ6pdf swig_types[12]
#define SWIGTYPE_p_Pythia8__CellJet swig_types[13]
#define SWIGTYPE_p_Pythia8__ClusterJet swig_types[14]
#define SWIGTYPE_p_Pythia8__Clustering swig_types[15]
#define SWIGTYPE_p_Pythia8__ColConfig swig_types[16]
#define SWIGTYPE_p_Pythia8__ColSinglet swig_types[17]
#define SWIGTYPE_p_Pythia8__ColourDipole swig_types[18]
#define SWIGTYPE_p_Pythia8__ColourJunction swig_types[19]
#define SWIGTYPE_p_Pythia8__ColourParticle swig_types[20]
#define SWIGTYPE_p_Pythia8__ColourReconnection swig_types[21]
#define SWIGTYPE_p_Pythia8__ColourTracing swig_types[22]
#define SWIGTYPE_p_Pythia8__CombineMatchingInput swig_types[23]
#define SWIGTYPE_p_Pythia8__CoupSM swig_types[24]
#define SWIGTYPE_p_Pythia8__CoupSUSY swig_types[25]
#define SWIGTYPE_p_Pythia8__Couplings swig_types[26]
#define SWIGTYPE_p_Pythia8__DecayChannel swig_types[27]
#define SWIGTYPE_p_Pythia8__DecayHandler swig_types[28]
#define SWIGTYPE_p_Pythia8__DoubleStrikman swig_types[29]
#define SWIGTYPE_p_Pythia8__DummyForStreams swig_types[30]
#define SWIGTYPE_p_Pythia8__EPAexternal swig_types[31]
#define SWIGTYPE_p_Pythia8__EPPS16 swig_types[32]
#define SWIGTYPE_p_Pythia8__EPS09 swig_types[33]
#define SWIGTYPE_p_Pythia8__Event swig_types[34]
#define SWIGTYPE_p_Pythia8__EventInfo swig_types[35]
#define SWIGTYPE_p_Pythia8__FVec swig_types[36]
#define SWIGTYPE_p_Pythia8__Flag swig_types[37]
#define SWIGTYPE_p_Pythia8__FlavContainer swig_types[38]
#define SWIGTYPE_p_Pythia8__FlavourRope swig_types[39]
#define SWIGTYPE_p_Pythia8__GLISSANDOModel swig_types[40]
#define SWIGTYPE_p_Pythia8__GRV94L swig_types[41]
#define SWIGTYPE_p_Pythia8__GRVpiL swig_types[42]
#define SWIGTYPE_p_Pythia8__GammaKinematics swig_types[43]
#define SWIGTYPE_p_Pythia8__GammaMatrix swig_types[44]
#define SWIGTYPE_p_Pythia8__GammaPoint swig_types[45]
#define SWIGTYPE_p_Pythia8__HEPEUP swig_types[46]
#define SWIGTYPE_p_Pythia8__HEPRUP swig_types[47]
#define SWIGTYPE_p_Pythia8__HIInfo swig_types[48]
#define SWIGTYPE_p_Pythia8__HIUserHooks swig_types[49]
#define SWIGTYPE_p_Pythia8__HJSlowJet swig_types[50]
#define SWIGTYPE_p_Pythia8__HMEGamma2TwoFermions swig_types[51]
#define SWIGTYPE_p_Pythia8__HMEHiggs2TwoFermions swig_types[52]
#define SWIGTYPE_p_Pythia8__HMETau2FivePions swig_types[53]
#define SWIGTYPE_p_Pythia8__HMETau2FourPions swig_types[54]
#define SWIGTYPE_p_Pythia8__HMETau2Meson swig_types[55]
#define SWIGTYPE_p_Pythia8__HMETau2PhaseSpace swig_types[56]
#define SWIGTYPE_p_Pythia8__HMETau2ThreeMesons swig_types[57]
#define SWIGTYPE_p_Pythia8__HMETau2ThreeMesonsGeneric swig_types[58]
#define SWIGTYPE_p_Pythia8__HMETau2ThreeMesonsWithKaons swig_types[59]
#define SWIGTYPE_p_Pythia8__HMETau2ThreePions swig_types[60]
#define SWIGTYPE_p_Pythia8__HMETau2TwoLeptons swig_types[61]
#define SWIGTYPE_p_Pythia8__HMETau2TwoMesonsViaVector swig_types[62]
#define SWIGTYPE_p_Pythia8__HMETau2TwoMesonsViaVectorScalar swig_types[63]
#define SWIGTYPE_p_Pythia8__HMETau2TwoPionsGamma swig_types[64]
#define SWIGTYPE_p_Pythia8__HMETauDecay swig_types[65]
#define SWIGTYPE_p_Pythia8__HMETwoFermions2GammaZ2TwoFermions swig_types[66]
#define SWIGTYPE_p_Pythia8__HMETwoFermions2W2TwoFermions swig_types[67]
#define SWIGTYPE_p_Pythia8__HMEW2TwoFermions swig_types[68]
#define SWIGTYPE_p_Pythia8__HMEX2TwoFermions swig_types[69]
#define SWIGTYPE_p_Pythia8__HMEZ2TwoFermions swig_types[70]
#define SWIGTYPE_p_Pythia8__HVStringFlav swig_types[71]
#define SWIGTYPE_p_Pythia8__HVStringPT swig_types[72]
#define SWIGTYPE_p_Pythia8__HVStringZ swig_types[73]
#define SWIGTYPE_p_Pythia8__HadronLevel swig_types[74]
#define SWIGTYPE_p_Pythia8__HadronScatter swig_types[75]
#define SWIGTYPE_p_Pythia8__HadronScatterPair swig_types[76]
#define SWIGTYPE_p_Pythia8__HardDiffraction swig_types[77]
#define SWIGTYPE_p_Pythia8__HardProcess swig_types[78]
#define SWIGTYPE_p_Pythia8__HeavyIons swig_types[79]
#define SWIGTYPE_p_Pythia8__HelicityMatrixElement swig_types[80]
#define SWIGTYPE_p_Pythia8__HelicityParticle swig_types[81]
#define SWIGTYPE_p_Pythia8__HiddenValleyFragmentation swig_types[82]
#define SWIGTYPE_p_Pythia8__Hist swig_types[83]
#define SWIGTYPE_p_Pythia8__HistPlot swig_types[84]
#define SWIGTYPE_p_Pythia8__History swig_types[85]
#define SWIGTYPE_p_Pythia8__ImpactParameterGenerator swig_types[86]
#define SWIGTYPE_p_Pythia8__InBeam swig_types[87]
#define SWIGTYPE_p_Pythia8__InPair swig_types[88]
#define SWIGTYPE_p_Pythia8__Info swig_types[89]
#define SWIGTYPE_p_Pythia8__Isospin swig_types[90]
#define SWIGTYPE_p_Pythia8__JetMatching swig_types[91]
#define SWIGTYPE_p_Pythia8__JetMatchingAlpgen swig_types[92]
#define SWIGTYPE_p_Pythia8__JetMatchingAlpgenInputAlpgen swig_types[93]
#define SWIGTYPE_p_Pythia8__JetMatchingMadgraph swig_types[94]
#define SWIGTYPE_p_Pythia8__JetMatchingMadgraphInputAlpgen swig_types[95]
#define SWIGTYPE_p_Pythia8__Junction swig_types[96]
#define SWIGTYPE_p_Pythia8__JunctionSplitting swig_types[97]
#define SWIGTYPE_p_Pythia8__LHAGrid1 swig_types[98]
#define SWIGTYPE_p_Pythia8__LHAPDF swig_types[99]
#define SWIGTYPE_p_Pythia8__LHAParticle swig_types[100]
#define SWIGTYPE_p_Pythia8__LHAProcess swig_types[101]
#define SWIGTYPE_p_Pythia8__LHAgenerator swig_types[102]
#define SWIGTYPE_p_Pythia8__LHAinitrwgt swig_types[103]
#define SWIGTYPE_p_Pythia8__LHArwgt swig_types[104]
#define SWIGTYPE_p_Pythia8__LHAscales swig_types[105]
#define SWIGTYPE_p_Pythia8__LHAup swig_types[106]
#define SWIGTYPE_p_Pythia8__LHAupAlpgen swig_types[107]
#define SWIGTYPE_p_Pythia8__LHAupFromPYTHIA8 swig_types[108]
#define SWIGTYPE_p_Pythia8__LHAupHelaconia swig_types[109]
#define SWIGTYPE_p_Pythia8__LHAupLHEF swig_types[110]
#define SWIGTYPE_p_Pythia8__LHAupMadgraph swig_types[111]
#define SWIGTYPE_p_Pythia8__LHAweight swig_types[112]
#define SWIGTYPE_p_Pythia8__LHAweightgroup swig_types[113]
#define SWIGTYPE_p_Pythia8__LHAweights swig_types[114]
#define SWIGTYPE_p_Pythia8__LHAwgt swig_types[115]
#define SWIGTYPE_p_Pythia8__LHEF3FromPythia8 swig_types[116]
#define SWIGTYPE_p_Pythia8__LHblockT_double_t swig_types[117]
#define SWIGTYPE_p_Pythia8__LHblockT_int_t swig_types[118]
#define SWIGTYPE_p_Pythia8__LHblockT_std__string_t swig_types[119]
#define SWIGTYPE_p_Pythia8__LHdecayChannel swig_types[120]
#define SWIGTYPE_p_Pythia8__LHdecayTable swig_types[121]
#define SWIGTYPE_p_Pythia8__LHgenericBlock swig_types[122]
#define SWIGTYPE_p_Pythia8__LHmatrixBlockT_2_t swig_types[123]
#define SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t swig_types[124]
#define SWIGTYPE_p_Pythia8__LHmatrixBlockT_4_t swig_types[125]
#define SWIGTYPE_p_Pythia8__LHmatrixBlockT_5_t swig_types[126]
#define SWIGTYPE_p_Pythia8__LHmatrixBlockT_6_t swig_types[127]
#define SWIGTYPE_p_Pythia8__LHmatrixBlockT_7_t swig_types[128]
#define SWIGTYPE_p_Pythia8__LHmatrixBlockT_8_t swig_types[129]
#define SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t swig_types[130]
#define SWIGTYPE_p_Pythia8__Lepton swig_types[131]
#define SWIGTYPE_p_Pythia8__Lepton2gamma swig_types[132]
#define SWIGTYPE_p_Pythia8__LeptonPoint swig_types[133]
#define SWIGTYPE_p_Pythia8__LundFFAvg swig_types[134]
#define SWIGTYPE_p_Pythia8__LundFFRaw swig_types[135]
#define SWIGTYPE_p_Pythia8__MBReconUserHooks swig_types[136]
#define SWIGTYPE_p_Pythia8__MSTWpdf swig_types[137]
#define SWIGTYPE_p_Pythia8__MVec swig_types[138]
#define SWIGTYPE_p_Pythia8__MadgraphPar swig_types[139]
#define SWIGTYPE_p_Pythia8__Merging swig_types[140]
#define SWIGTYPE_p_Pythia8__MergingHooks swig_types[141]
#define SWIGTYPE_p_Pythia8__MiniStringFragmentation swig_types[142]
#define SWIGTYPE_p_Pythia8__Mode swig_types[143]
#define SWIGTYPE_p_Pythia8__MultiRadial swig_types[144]
#define SWIGTYPE_p_Pythia8__MultipartonInteractions swig_types[145]
#define SWIGTYPE_p_Pythia8__NNPDF swig_types[146]
#define SWIGTYPE_p_Pythia8__NaiveSubCollisionModel swig_types[147]
#define SWIGTYPE_p_Pythia8__NeutrinoPoint swig_types[148]
#define SWIGTYPE_p_Pythia8__Nucleon swig_types[149]
#define SWIGTYPE_p_Pythia8__NucleusModel swig_types[150]
#define SWIGTYPE_p_Pythia8__OverlappingRopeDipole swig_types[151]
#define SWIGTYPE_p_Pythia8__PDF swig_types[152]
#define SWIGTYPE_p_Pythia8__PDF__PDFEnvelope swig_types[153]
#define SWIGTYPE_p_Pythia8__PVec swig_types[154]
#define SWIGTYPE_p_Pythia8__Parm swig_types[155]
#define SWIGTYPE_p_Pythia8__Particle swig_types[156]
#define SWIGTYPE_p_Pythia8__ParticleData swig_types[157]
#define SWIGTYPE_p_Pythia8__ParticleDataEntry swig_types[158]
#define SWIGTYPE_p_Pythia8__ParticleDecays swig_types[159]
#define SWIGTYPE_p_Pythia8__PartonLevel swig_types[160]
#define SWIGTYPE_p_Pythia8__PartonSystem swig_types[161]
#define SWIGTYPE_p_Pythia8__PartonSystems swig_types[162]
#define SWIGTYPE_p_Pythia8__PartonVertex swig_types[163]
#define SWIGTYPE_p_Pythia8__PhaseSpace swig_types[164]
#define SWIGTYPE_p_Pythia8__PhaseSpace2to1tauy swig_types[165]
#define SWIGTYPE_p_Pythia8__PhaseSpace2to2diffractive swig_types[166]
#define SWIGTYPE_p_Pythia8__PhaseSpace2to2elastic swig_types[167]
#define SWIGTYPE_p_Pythia8__PhaseSpace2to2nondiffractive swig_types[168]
#define SWIGTYPE_p_Pythia8__PhaseSpace2to2nondiffractiveGamma swig_types[169]
#define SWIGTYPE_p_Pythia8__PhaseSpace2to2tauyz swig_types[170]
#define SWIGTYPE_p_Pythia8__PhaseSpace2to3diffractive swig_types[171]
#define SWIGTYPE_p_Pythia8__PhaseSpace2to3tauycyl swig_types[172]
#define SWIGTYPE_p_Pythia8__PhaseSpace2to3yyycyl swig_types[173]
#define SWIGTYPE_p_Pythia8__PhaseSpaceLHA swig_types[174]
#define SWIGTYPE_p_Pythia8__PomFix swig_types[175]
#define SWIGTYPE_p_Pythia8__PomH1FitAB swig_types[176]
#define SWIGTYPE_p_Pythia8__PomH1Jets swig_types[177]
#define SWIGTYPE_p_Pythia8__PomHISASD swig_types[178]
#define SWIGTYPE_p_Pythia8__PowhegHooks swig_types[179]
#define SWIGTYPE_p_Pythia8__PowhegProcs swig_types[180]
#define SWIGTYPE_p_Pythia8__ProcessContainer swig_types[181]
#define SWIGTYPE_p_Pythia8__ProcessLevel swig_types[182]
#define SWIGTYPE_p_Pythia8__ProgressLog swig_types[183]
#define SWIGTYPE_p_Pythia8__ProtonPoint swig_types[184]
#define SWIGTYPE_p_Pythia8__Pythia swig_types[185]
#define SWIGTYPE_p_Pythia8__RHadrons swig_types[186]
#define SWIGTYPE_p_Pythia8__Reader swig_types[187]
#define SWIGTYPE_p_Pythia8__ResolvedParton swig_types[188]
#define SWIGTYPE_p_Pythia8__ResonanceChar swig_types[189]
#define SWIGTYPE_p_Pythia8__ResonanceDecays swig_types[190]
#define SWIGTYPE_p_Pythia8__ResonanceExcited swig_types[191]
#define SWIGTYPE_p_Pythia8__ResonanceFour swig_types[192]
#define SWIGTYPE_p_Pythia8__ResonanceGeneric swig_types[193]
#define SWIGTYPE_p_Pythia8__ResonanceGluino swig_types[194]
#define SWIGTYPE_p_Pythia8__ResonanceGmZ swig_types[195]
#define SWIGTYPE_p_Pythia8__ResonanceGraviton swig_types[196]
#define SWIGTYPE_p_Pythia8__ResonanceH swig_types[197]
#define SWIGTYPE_p_Pythia8__ResonanceHchg swig_types[198]
#define SWIGTYPE_p_Pythia8__ResonanceHchgchgLeft swig_types[199]
#define SWIGTYPE_p_Pythia8__ResonanceHchgchgRight swig_types[200]
#define SWIGTYPE_p_Pythia8__ResonanceKKgluon swig_types[201]
#define SWIGTYPE_p_Pythia8__ResonanceLeptoquark swig_types[202]
#define SWIGTYPE_p_Pythia8__ResonanceNeut swig_types[203]
#define SWIGTYPE_p_Pythia8__ResonanceNuRight swig_types[204]
#define SWIGTYPE_p_Pythia8__ResonanceRhorizontal swig_types[205]
#define SWIGTYPE_p_Pythia8__ResonanceS swig_types[206]
#define SWIGTYPE_p_Pythia8__ResonanceSlepton swig_types[207]
#define SWIGTYPE_p_Pythia8__ResonanceSquark swig_types[208]
#define SWIGTYPE_p_Pythia8__ResonanceTop swig_types[209]
#define SWIGTYPE_p_Pythia8__ResonanceW swig_types[210]
#define SWIGTYPE_p_Pythia8__ResonanceWRight swig_types[211]
#define SWIGTYPE_p_Pythia8__ResonanceWidths swig_types[212]
#define SWIGTYPE_p_Pythia8__ResonanceWprime swig_types[213]
#define SWIGTYPE_p_Pythia8__ResonanceZRight swig_types[214]
#define SWIGTYPE_p_Pythia8__ResonanceZp swig_types[215]
#define SWIGTYPE_p_Pythia8__ResonanceZprime swig_types[216]
#define SWIGTYPE_p_Pythia8__Rndm swig_types[217]
#define SWIGTYPE_p_Pythia8__RndmEngine swig_types[218]
#define SWIGTYPE_p_Pythia8__RopeDipole swig_types[219]
#define SWIGTYPE_p_Pythia8__RopeDipoleEnd swig_types[220]
#define SWIGTYPE_p_Pythia8__RopeFragPars swig_types[221]
#define SWIGTYPE_p_Pythia8__Ropewalk swig_types[222]
#define SWIGTYPE_p_Pythia8__RotBstMatrix swig_types[223]
#define SWIGTYPE_p_Pythia8__SLHAinterface swig_types[224]
#define SWIGTYPE_p_Pythia8__SUSYResonanceWidths swig_types[225]
#define SWIGTYPE_p_Pythia8__Settings swig_types[226]
#define SWIGTYPE_p_Pythia8__SetupContainers swig_types[227]
#define SWIGTYPE_p_Pythia8__Sigma0AB2AB swig_types[228]
#define SWIGTYPE_p_Pythia8__Sigma0AB2AX swig_types[229]
#define SWIGTYPE_p_Pythia8__Sigma0AB2AXB swig_types[230]
#define SWIGTYPE_p_Pythia8__Sigma0AB2XB swig_types[231]
#define SWIGTYPE_p_Pythia8__Sigma0AB2XX swig_types[232]
#define SWIGTYPE_p_Pythia8__Sigma0Process swig_types[233]
#define SWIGTYPE_p_Pythia8__Sigma0nonDiffractive swig_types[234]
#define SWIGTYPE_p_Pythia8__Sigma1Process swig_types[235]
#define SWIGTYPE_p_Pythia8__Sigma1ffbar2GravitonStar swig_types[236]
#define SWIGTYPE_p_Pythia8__Sigma1ffbar2H swig_types[237]
#define SWIGTYPE_p_Pythia8__Sigma1ffbar2Hchg swig_types[238]
#define SWIGTYPE_p_Pythia8__Sigma1ffbar2Rhorizontal swig_types[239]
#define SWIGTYPE_p_Pythia8__Sigma1ffbar2W swig_types[240]
#define SWIGTYPE_p_Pythia8__Sigma1ffbar2WRight swig_types[241]
#define SWIGTYPE_p_Pythia8__Sigma1ffbar2Wprime swig_types[242]
#define SWIGTYPE_p_Pythia8__Sigma1ffbar2ZRight swig_types[243]
#define SWIGTYPE_p_Pythia8__Sigma1ffbar2Zp2XX swig_types[244]
#define SWIGTYPE_p_Pythia8__Sigma1ffbar2Zv swig_types[245]
#define SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZ swig_types[246]
#define SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZZprime swig_types[247]
#define SWIGTYPE_p_Pythia8__Sigma1ffbarZprimeWprime swig_types[248]
#define SWIGTYPE_p_Pythia8__Sigma1gg2GravitonStar swig_types[249]
#define SWIGTYPE_p_Pythia8__Sigma1gg2H swig_types[250]
#define SWIGTYPE_p_Pythia8__Sigma1gg2S2XX swig_types[251]
#define SWIGTYPE_p_Pythia8__Sigma1gmgm2H swig_types[252]
#define SWIGTYPE_p_Pythia8__Sigma1lgm2lStar swig_types[253]
#define SWIGTYPE_p_Pythia8__Sigma1ll2Hchgchg swig_types[254]
#define SWIGTYPE_p_Pythia8__Sigma1qg2qStar swig_types[255]
#define SWIGTYPE_p_Pythia8__Sigma1ql2LeptoQuark swig_types[256]
#define SWIGTYPE_p_Pythia8__Sigma1qq2antisquark swig_types[257]
#define SWIGTYPE_p_Pythia8__Sigma1qqbar2KKgluonStar swig_types[258]
#define SWIGTYPE_p_Pythia8__Sigma2Process swig_types[259]
#define SWIGTYPE_p_Pythia8__Sigma2QCffbar2llbar swig_types[260]
#define SWIGTYPE_p_Pythia8__Sigma2QCqq2qq swig_types[261]
#define SWIGTYPE_p_Pythia8__Sigma2QCqqbar2qqbar swig_types[262]
#define SWIGTYPE_p_Pythia8__Sigma2SUSY swig_types[263]
#define SWIGTYPE_p_Pythia8__Sigma2ff2fftW swig_types[264]
#define SWIGTYPE_p_Pythia8__Sigma2ff2fftgmZ swig_types[265]
#define SWIGTYPE_p_Pythia8__Sigma2ffbar2A3H12 swig_types[266]
#define SWIGTYPE_p_Pythia8__Sigma2ffbar2FFbarsgmZ swig_types[267]
#define SWIGTYPE_p_Pythia8__Sigma2ffbar2FfbarsW swig_types[268]
#define SWIGTYPE_p_Pythia8__Sigma2ffbar2HW swig_types[269]
#define SWIGTYPE_p_Pythia8__Sigma2ffbar2HZ swig_types[270]
#define SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgH12 swig_types[271]
#define SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgchgHchgchg swig_types[272]
#define SWIGTYPE_p_Pythia8__Sigma2ffbar2HposHneg swig_types[273]
#define SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticleZ swig_types[274]
#define SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticlegamma swig_types[275]
#define SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDgammagamma swig_types[276]
#define SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDllbar swig_types[277]
#define SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar swig_types[278]
#define SWIGTYPE_p_Pythia8__Sigma2ffbar2WW swig_types[279]
#define SWIGTYPE_p_Pythia8__Sigma2ffbar2Wgm swig_types[280]
#define SWIGTYPE_p_Pythia8__Sigma2ffbar2ZW swig_types[281]
#define SWIGTYPE_p_Pythia8__Sigma2ffbar2ZpH swig_types[282]
#define SWIGTYPE_p_Pythia8__Sigma2ffbar2fGfGbar swig_types[283]
#define SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsW swig_types[284]
#define SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgm swig_types[285]
#define SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgmZ swig_types[286]
#define SWIGTYPE_p_Pythia8__Sigma2ffbar2gammagamma swig_types[287]
#define SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgm swig_types[288]
#define SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgmZ swig_types[289]
#define SWIGTYPE_p_Pythia8__Sigma2ffbarWggm swig_types[290]
#define SWIGTYPE_p_Pythia8__Sigma2ffbargmZWgmZW swig_types[291]
#define SWIGTYPE_p_Pythia8__Sigma2ffbargmZggm swig_types[292]
#define SWIGTYPE_p_Pythia8__Sigma2fgm2Wf swig_types[293]
#define SWIGTYPE_p_Pythia8__Sigma2fgm2gmZf swig_types[294]
#define SWIGTYPE_p_Pythia8__Sigma2gg2GravitonStarg swig_types[295]
#define SWIGTYPE_p_Pythia8__Sigma2gg2Hglt swig_types[296]
#define SWIGTYPE_p_Pythia8__Sigma2gg2LEDUnparticleg swig_types[297]
#define SWIGTYPE_p_Pythia8__Sigma2gg2LEDgammagamma swig_types[298]
#define SWIGTYPE_p_Pythia8__Sigma2gg2LEDgg swig_types[299]
#define SWIGTYPE_p_Pythia8__Sigma2gg2LEDllbar swig_types[300]
#define SWIGTYPE_p_Pythia8__Sigma2gg2LEDqqbar swig_types[301]
#define SWIGTYPE_p_Pythia8__Sigma2gg2LQLQbar swig_types[302]
#define SWIGTYPE_p_Pythia8__Sigma2gg2QQbar swig_types[303]
#define SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3DJ1g swig_types[304]
#define SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3PJ1g swig_types[305]
#define SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11 swig_types[306]
#define SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11g swig_types[307]
#define SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11gm swig_types[308]
#define SWIGTYPE_p_Pythia8__Sigma2gg2QQbarX8g swig_types[309]
#define SWIGTYPE_p_Pythia8__Sigma2gg2Sg2XXj swig_types[310]
#define SWIGTYPE_p_Pythia8__Sigma2gg2gammagamma swig_types[311]
#define SWIGTYPE_p_Pythia8__Sigma2gg2gg swig_types[312]
#define SWIGTYPE_p_Pythia8__Sigma2gg2ggamma swig_types[313]
#define SWIGTYPE_p_Pythia8__Sigma2gg2gluinogluino swig_types[314]
#define SWIGTYPE_p_Pythia8__Sigma2gg2qGqGbar swig_types[315]
#define SWIGTYPE_p_Pythia8__Sigma2gg2qqbar swig_types[316]
#define SWIGTYPE_p_Pythia8__Sigma2gg2squarkantisquark swig_types[317]
#define SWIGTYPE_p_Pythia8__Sigma2ggm2qqbar swig_types[318]
#define SWIGTYPE_p_Pythia8__Sigma2gmgm2ffbar swig_types[319]
#define SWIGTYPE_p_Pythia8__Sigma2lgm2Hchgchgl swig_types[320]
#define SWIGTYPE_p_Pythia8__Sigma2qg2GravitonStarq swig_types[321]
#define SWIGTYPE_p_Pythia8__Sigma2qg2Hchgq swig_types[322]
#define SWIGTYPE_p_Pythia8__Sigma2qg2Hq swig_types[323]
#define SWIGTYPE_p_Pythia8__Sigma2qg2Hqlt swig_types[324]
#define SWIGTYPE_p_Pythia8__Sigma2qg2LEDUnparticleq swig_types[325]
#define SWIGTYPE_p_Pythia8__Sigma2qg2LEDqg swig_types[326]
#define SWIGTYPE_p_Pythia8__Sigma2qg2LeptoQuarkl swig_types[327]
#define SWIGTYPE_p_Pythia8__Sigma2qg2QQbar3PJ1q swig_types[328]
#define SWIGTYPE_p_Pythia8__Sigma2qg2QQbarX8q swig_types[329]
#define SWIGTYPE_p_Pythia8__Sigma2qg2Sq2XXj swig_types[330]
#define SWIGTYPE_p_Pythia8__Sigma2qg2Wq swig_types[331]
#define SWIGTYPE_p_Pythia8__Sigma2qg2Zpq2XXj swig_types[332]
#define SWIGTYPE_p_Pythia8__Sigma2qg2charsquark swig_types[333]
#define SWIGTYPE_p_Pythia8__Sigma2qg2chi0squark swig_types[334]
#define SWIGTYPE_p_Pythia8__Sigma2qg2gmZq swig_types[335]
#define SWIGTYPE_p_Pythia8__Sigma2qg2qg swig_types[336]
#define SWIGTYPE_p_Pythia8__Sigma2qg2qgamma swig_types[337]
#define SWIGTYPE_p_Pythia8__Sigma2qg2squarkgluino swig_types[338]
#define SWIGTYPE_p_Pythia8__Sigma2qgm2qg swig_types[339]
#define SWIGTYPE_p_Pythia8__Sigma2qgm2qgm swig_types[340]
#define SWIGTYPE_p_Pythia8__Sigma2qq2LEDqq swig_types[341]
#define SWIGTYPE_p_Pythia8__Sigma2qq2QqtW swig_types[342]
#define SWIGTYPE_p_Pythia8__Sigma2qq2qStarq swig_types[343]
#define SWIGTYPE_p_Pythia8__Sigma2qq2qq swig_types[344]
#define SWIGTYPE_p_Pythia8__Sigma2qq2squarksquark swig_types[345]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2GravitonStarg swig_types[346]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2Hglt swig_types[347]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDUnparticleg swig_types[348]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDgg swig_types[349]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDqqbarNew swig_types[350]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2LQLQbar swig_types[351]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar swig_types[352]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar3PJ1g swig_types[353]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11 swig_types[354]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbarX8g swig_types[355]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2Wg swig_types[356]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2Zpg2XXj swig_types[357]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2charchar swig_types[358]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2charchi0 swig_types[359]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2chargluino swig_types[360]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0chi0 swig_types[361]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0gluino swig_types[362]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2gg swig_types[363]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2ggamma swig_types[364]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2gluinogluino swig_types[365]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2gmZg swig_types[366]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlStarBar swig_types[367]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlbar swig_types[368]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2qGqGbar swig_types[369]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2qqbarNew swig_types[370]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2sleptonantislepton swig_types[371]
#define SWIGTYPE_p_Pythia8__Sigma2qqbar2squarkantisquark swig_types[372]
#define SWIGTYPE_p_Pythia8__Sigma3Process swig_types[373]
#define SWIGTYPE_p_Pythia8__Sigma3ff2HchgchgfftWW swig_types[374]
#define SWIGTYPE_p_Pythia8__Sigma3ff2HfftWW swig_types[375]
#define SWIGTYPE_p_Pythia8__Sigma3ff2HfftZZ swig_types[376]
#define SWIGTYPE_p_Pythia8__Sigma3gg2HQQbar swig_types[377]
#define SWIGTYPE_p_Pythia8__Sigma3gg2ggg swig_types[378]
#define SWIGTYPE_p_Pythia8__Sigma3gg2qqbarg swig_types[379]
#define SWIGTYPE_p_Pythia8__Sigma3qg2qgg swig_types[380]
#define SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarDiff swig_types[381]
#define SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarSame swig_types[382]
#define SWIGTYPE_p_Pythia8__Sigma3qq2qqgDiff swig_types[383]
#define SWIGTYPE_p_Pythia8__Sigma3qq2qqgSame swig_types[384]
#define SWIGTYPE_p_Pythia8__Sigma3qqbar2HQQbar swig_types[385]
#define SWIGTYPE_p_Pythia8__Sigma3qqbar2ggg swig_types[386]
#define SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargDiff swig_types[387]
#define SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargSame swig_types[388]
#define SWIGTYPE_p_Pythia8__SigmaABMST swig_types[389]
#define SWIGTYPE_p_Pythia8__SigmaLHAProcess swig_types[390]
#define SWIGTYPE_p_Pythia8__SigmaMBR swig_types[391]
#define SWIGTYPE_p_Pythia8__SigmaMultiparton swig_types[392]
#define SWIGTYPE_p_Pythia8__SigmaOniaSetup swig_types[393]
#define SWIGTYPE_p_Pythia8__SigmaPartialWave swig_types[394]
#define SWIGTYPE_p_Pythia8__SigmaProcess swig_types[395]
#define SWIGTYPE_p_Pythia8__SigmaRPP swig_types[396]
#define SWIGTYPE_p_Pythia8__SigmaSaSDL swig_types[397]
#define SWIGTYPE_p_Pythia8__SigmaTotAux swig_types[398]
#define SWIGTYPE_p_Pythia8__SigmaTotOwn swig_types[399]
#define SWIGTYPE_p_Pythia8__SigmaTotal swig_types[400]
#define SWIGTYPE_p_Pythia8__SingleCell swig_types[401]
#define SWIGTYPE_p_Pythia8__SingleCellJet swig_types[402]
#define SWIGTYPE_p_Pythia8__SingleClusterJet swig_types[403]
#define SWIGTYPE_p_Pythia8__SingleSlowJet swig_types[404]
#define SWIGTYPE_p_Pythia8__SlowJet swig_types[405]
#define SWIGTYPE_p_Pythia8__SlowJetHook swig_types[406]
#define SWIGTYPE_p_Pythia8__SpaceDipoleEnd swig_types[407]
#define SWIGTYPE_p_Pythia8__SpaceShower swig_types[408]
#define SWIGTYPE_p_Pythia8__Sphericity swig_types[409]
#define SWIGTYPE_p_Pythia8__StauWidths swig_types[410]
#define SWIGTYPE_p_Pythia8__StringEnd swig_types[411]
#define SWIGTYPE_p_Pythia8__StringFlav swig_types[412]
#define SWIGTYPE_p_Pythia8__StringFragmentation swig_types[413]
#define SWIGTYPE_p_Pythia8__StringLength swig_types[414]
#define SWIGTYPE_p_Pythia8__StringPT swig_types[415]
#define SWIGTYPE_p_Pythia8__StringRegion swig_types[416]
#define SWIGTYPE_p_Pythia8__StringSystem swig_types[417]
#define SWIGTYPE_p_Pythia8__StringVertex swig_types[418]
#define SWIGTYPE_p_Pythia8__StringZ swig_types[419]
#define SWIGTYPE_p_Pythia8__SubCollision swig_types[420]
#define SWIGTYPE_p_Pythia8__SubCollisionModel swig_types[421]
#define SWIGTYPE_p_Pythia8__SubCollisionModel__SigEst swig_types[422]
#define SWIGTYPE_p_Pythia8__SuppressSmallPT swig_types[423]
#define SWIGTYPE_p_Pythia8__SusyLesHouches swig_types[424]
#define SWIGTYPE_p_Pythia8__TauDecays swig_types[425]
#define SWIGTYPE_p_Pythia8__Thrust swig_types[426]
#define SWIGTYPE_p_Pythia8__TimeDipoleEnd swig_types[427]
#define SWIGTYPE_p_Pythia8__TimeShower swig_types[428]
#define SWIGTYPE_p_Pythia8__TopReconUserHooks swig_types[429]
#define SWIGTYPE_p_Pythia8__TrialReconnection swig_types[430]
#define SWIGTYPE_p_Pythia8__UserHooks swig_types[431]
#define SWIGTYPE_p_Pythia8__UserHooksVector swig_types[432]
#define SWIGTYPE_p_Pythia8__Vec4 swig_types[433]
#define SWIGTYPE_p_Pythia8__WVec swig_types[434]
#define SWIGTYPE_p_Pythia8__Wave4 swig_types[435]
#define SWIGTYPE_p_Pythia8__WeakShowerMEs swig_types[436]
#define SWIGTYPE_p_Pythia8__WidthFunction swig_types[437]
#define SWIGTYPE_p_Pythia8__WoodsSaxonModel swig_types[438]
#define SWIGTYPE_p_Pythia8__Word swig_types[439]
#define SWIGTYPE_p_Pythia8__Writer swig_types[440]
#define SWIGTYPE_p_Pythia8__XMLTag swig_types[441]
#define SWIGTYPE_p_Pythia8__amcnlo_unitarised_interface swig_types[442]
#define SWIGTYPE_p_Pythia8__nPDF swig_types[443]
#define SWIGTYPE_p_State swig_types[444]
#define SWIGTYPE_p_a_3__std__complexT_double_t swig_types[445]
#define SWIGTYPE_p_a_4__std__complexT_double_t swig_types[446]
#define SWIGTYPE_p_a_6__std__complexT_double_t swig_types[447]
#define SWIGTYPE_p_a_7__std__complexT_double_t swig_types[448]
#define SWIGTYPE_p_a_8__double swig_types[449]
#define SWIGTYPE_p_allocator_type swig_types[450]
#define SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[451]
#define SWIGTYPE_p_bool swig_types[452]
#define SWIGTYPE_p_char swig_types[453]
#define SWIGTYPE_p_char_type swig_types[454]
#define SWIGTYPE_p_const_reference swig_types[455]
#define SWIGTYPE_p_difference_type swig_types[456]
#define SWIGTYPE_p_double swig_types[457]
#define SWIGTYPE_p_f_enum_std__ios_base__event_r_std__ios_base_int__void swig_types[458]
#define SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t swig_types[459]
#define SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t swig_types[460]
#define SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t swig_types[461]
#define SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[462]
#define SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t swig_types[463]
#define SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[464]
#define SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[465]
#define SWIGTYPE_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t swig_types[466]
#define SWIGTYPE_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t swig_types[467]
#define SWIGTYPE_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[468]
#define SWIGTYPE_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[469]
#define SWIGTYPE_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t swig_types[470]
#define SWIGTYPE_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t swig_types[471]
#define SWIGTYPE_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[472]
#define SWIGTYPE_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[473]
#define SWIGTYPE_p_f_r_std__ios_base__r_std__basic_iosT_char_std__char_traitsT_char_t_t swig_types[474]
#define SWIGTYPE_p_f_r_std__ios_base__r_std__basic_iostreamT_char_std__char_traitsT_char_t_t swig_types[475]
#define SWIGTYPE_p_f_r_std__ios_base__r_std__basic_istreamT_char_std__char_traitsT_char_t_t swig_types[476]
#define SWIGTYPE_p_f_r_std__ios_base__r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[477]
#define SWIGTYPE_p_f_r_std__ios_base__r_std__basic_ostreamT_char_std__char_traitsT_char_t_t swig_types[478]
#define SWIGTYPE_p_f_r_std__ios_base__r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[479]
#define SWIGTYPE_p_f_r_std__ios_base__r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[480]
#define SWIGTYPE_p_f_r_std__ios_base__r_std__ios_base swig_types[481]
#define SWIGTYPE_p_first_type swig_types[482]
#define SWIGTYPE_p_float swig_types[483]
#define SWIGTYPE_p_fmtflags swig_types[484]
#define SWIGTYPE_p_ifstream swig_types[485]
#define SWIGTYPE_p_int swig_types[486]
#define SWIGTYPE_p_int_type swig_types[487]
#define SWIGTYPE_p_iostate swig_types[488]
#define SWIGTYPE_p_key_type swig_types[489]
#define SWIGTYPE_p_long swig_types[490]
#define SWIGTYPE_p_long_double swig_types[491]
#define SWIGTYPE_p_long_long swig_types[492]
#define SWIGTYPE_p_mapped_type swig_types[493]
#define SWIGTYPE_p_off_type swig_types[494]
#define SWIGTYPE_p_openmode swig_types[495]
#define SWIGTYPE_p_p_PyObject swig_types[496]
#define SWIGTYPE_p_p_Pythia8__ColourDipole swig_types[497]
#define SWIGTYPE_p_p_std__basic_iostreamT_char_std__char_traitsT_char_t_t swig_types[498]
#define SWIGTYPE_p_p_std__basic_istreamT_char_std__char_traitsT_char_t_t swig_types[499]
#define SWIGTYPE_p_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[500]
#define SWIGTYPE_p_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[501]
#define SWIGTYPE_p_p_void swig_types[502]
#define SWIGTYPE_p_pos_t swig_types[503]
#define SWIGTYPE_p_pos_type swig_types[504]
#define SWIGTYPE_p_reference swig_types[505]
#define SWIGTYPE_p_second_type swig_types[506]
#define SWIGTYPE_p_seekdir swig_types[507]
#define SWIGTYPE_p_short swig_types[508]
#define SWIGTYPE_p_size_t swig_types[509]
#define SWIGTYPE_p_size_type swig_types[510]
#define SWIGTYPE_p_state_type swig_types[511]
#define SWIGTYPE_p_std__allocatorT_Pythia8__Clustering_t swig_types[512]
#define SWIGTYPE_p_std__allocatorT_Pythia8__HelicityParticle_t swig_types[513]
#define SWIGTYPE_p_std__allocatorT_Pythia8__ProcessContainer_p_t swig_types[514]
#define SWIGTYPE_p_std__allocatorT_Pythia8__ResonanceWidths_p_t swig_types[515]
#define SWIGTYPE_p_std__allocatorT_Pythia8__SigmaProcess_p_t swig_types[516]
#define SWIGTYPE_p_std__allocatorT_Pythia8__Vec4_t swig_types[517]
#define SWIGTYPE_p_std__allocatorT_bool_t swig_types[518]
#define SWIGTYPE_p_std__allocatorT_double_t swig_types[519]
#define SWIGTYPE_p_std__allocatorT_int_t swig_types[520]
#define SWIGTYPE_p_std__allocatorT_std__complexT_double_t_t swig_types[521]
#define SWIGTYPE_p_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t swig_types[522]
#define SWIGTYPE_p_std__allocatorT_std__pairT_int_const_int_t_t swig_types[523]
#define SWIGTYPE_p_std__allocatorT_std__pairT_int_int_t_t swig_types[524]
#define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t swig_types[525]
#define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t swig_types[526]
#define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t swig_types[527]
#define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t swig_types[528]
#define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t swig_types[529]
#define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t swig_types[530]
#define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t swig_types[531]
#define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_std__string_t_t swig_types[532]
#define SWIGTYPE_p_std__allocatorT_std__string_t swig_types[533]
#define SWIGTYPE_p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t swig_types[534]
#define SWIGTYPE_p_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t swig_types[535]
#define SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t swig_types[536]
#define SWIGTYPE_p_std__basic_iostreamT_char_std__char_traitsT_char_t_t swig_types[537]
#define SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t swig_types[538]
#define SWIGTYPE_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[539]
#define SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t swig_types[540]
#define SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[541]
#define SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t swig_types[542]
#define SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[543]
#define SWIGTYPE_p_std__basic_stringbufT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[544]
#define SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[545]
#define SWIGTYPE_p_std__complexT_double_t swig_types[546]
#define SWIGTYPE_p_std__ifstream swig_types[547]
#define SWIGTYPE_p_std__invalid_argument swig_types[548]
#define SWIGTYPE_p_std__ios_base swig_types[549]
#define SWIGTYPE_p_std__lessT_double_t swig_types[550]
#define SWIGTYPE_p_std__lessT_int_t swig_types[551]
#define SWIGTYPE_p_std__lessT_std__string_t swig_types[552]
#define SWIGTYPE_p_std__locale swig_types[553]
#define SWIGTYPE_p_std__mapT_Pythia8__Nucleon_p_std__pairT_int_int_t_std__lessT_Pythia8__Nucleon_p_t_std__allocatorT_std__pairT_Pythia8__Nucleon_pconst_std__pairT_int_int_t_t_t_t swig_types[554]
#define SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t swig_types[555]
#define SWIGTYPE_p_std__mapT_int_double_std__lessT_int_t_std__allocatorT_std__pairT_int_const_double_t_t_t swig_types[556]
#define SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t swig_types[557]
#define SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t swig_types[558]
#define SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t swig_types[559]
#define SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAweight_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweight_t_t_t swig_types[560]
#define SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAweightgroup_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweightgroup_t_t_t swig_types[561]
#define SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAwgt_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAwgt_t_t_t swig_types[562]
#define SWIGTYPE_p_std__mapT_std__string_Pythia8__LHgenericBlock_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHgenericBlock_t_t_t swig_types[563]
#define SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t swig_types[564]
#define SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t swig_types[565]
#define SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t swig_types[566]
#define SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t swig_types[567]
#define SWIGTYPE_p_std__mapT_std__string_Pythia8__WVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__WVec_t_t_t swig_types[568]
#define SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t swig_types[569]
#define SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t swig_types[570]
#define SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t swig_types[571]
#define SWIGTYPE_p_std__multisetT_Pythia8__SubCollision_std__lessT_Pythia8__SubCollision_t_std__allocatorT_Pythia8__SubCollision_t_t swig_types[572]
#define SWIGTYPE_p_std__ofstream swig_types[573]
#define SWIGTYPE_p_std__pairT_Pythia8__RotBstMatrix_Pythia8__RotBstMatrix_t swig_types[574]
#define SWIGTYPE_p_std__pairT_Pythia8__Vec4_Pythia8__Vec4_t swig_types[575]
#define SWIGTYPE_p_std__pairT_double_double_t swig_types[576]
#define SWIGTYPE_p_std__pairT_int_int_t swig_types[577]
#define SWIGTYPE_p_std__pairT_long_long_t swig_types[578]
#define SWIGTYPE_p_std__setT_int_std__lessT_int_t_std__allocatorT_int_t_t swig_types[579]
#define SWIGTYPE_p_std__string swig_types[580]
#define SWIGTYPE_p_std__string__size_type swig_types[581]
#define SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t swig_types[582]
#define SWIGTYPE_p_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t swig_types[583]
#define SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t swig_types[584]
#define SWIGTYPE_p_std__vectorT_Pythia8__InBeam_std__allocatorT_Pythia8__InBeam_t_t swig_types[585]
#define SWIGTYPE_p_std__vectorT_Pythia8__InPair_std__allocatorT_Pythia8__InPair_t_t swig_types[586]
#define SWIGTYPE_p_std__vectorT_Pythia8__LHAParticle_std__allocatorT_Pythia8__LHAParticle_t_t swig_types[587]
#define SWIGTYPE_p_std__vectorT_Pythia8__LHAgenerator_std__allocatorT_Pythia8__LHAgenerator_t_t swig_types[588]
#define SWIGTYPE_p_std__vectorT_Pythia8__LHblockT_int_t_std__allocatorT_Pythia8__LHblockT_int_t_t_t swig_types[589]
#define SWIGTYPE_p_std__vectorT_Pythia8__LHdecayTable_std__allocatorT_Pythia8__LHdecayTable_t_t swig_types[590]
#define SWIGTYPE_p_std__vectorT_Pythia8__Nucleon_std__allocatorT_Pythia8__Nucleon_t_t swig_types[591]
#define SWIGTYPE_p_std__vectorT_Pythia8__PhaseSpace_p_std__allocatorT_Pythia8__PhaseSpace_p_t_t swig_types[592]
#define SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t swig_types[593]
#define SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t swig_types[594]
#define SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t swig_types[595]
#define SWIGTYPE_p_std__vectorT_Pythia8__StringRegion_std__allocatorT_Pythia8__StringRegion_t_t swig_types[596]
#define SWIGTYPE_p_std__vectorT_Pythia8__StringVertex_std__allocatorT_Pythia8__StringVertex_t_t swig_types[597]
#define SWIGTYPE_p_std__vectorT_Pythia8__UserHooks_p_std__allocatorT_Pythia8__UserHooks_p_t_t swig_types[598]
#define SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t swig_types[599]
#define SWIGTYPE_p_std__vectorT_Pythia8__XMLTag_p_std__allocatorT_Pythia8__XMLTag_p_t_t swig_types[600]
#define SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t swig_types[601]
#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[602]
#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[603]
#define SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t swig_types[604]
#define SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t swig_types[605]
#define SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t swig_types[606]
#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[607]
#define SWIGTYPE_p_std__vectorT_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t_std__allocatorT_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t_t_t swig_types[608]
#define SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t swig_types[609]
#define SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t swig_types[610]
#define SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t swig_types[611]
#define SWIGTYPE_p_std__vectorT_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t_std__allocatorT_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t_t_t swig_types[612]
#define SWIGTYPE_p_streamoff swig_types[613]
#define SWIGTYPE_p_streampos swig_types[614]
#define SWIGTYPE_p_stringstream swig_types[615]
#define SWIGTYPE_p_swig__SwigPyIterator swig_types[616]
#define SWIGTYPE_p_traits_type swig_types[617]
#define SWIGTYPE_p_unsigned_int swig_types[618]
#define SWIGTYPE_p_unsigned_long swig_types[619]
#define SWIGTYPE_p_unsigned_long_long swig_types[620]
#define SWIGTYPE_p_unsigned_short swig_types[621]
#define SWIGTYPE_p_value_type swig_types[622]
static swig_type_info *swig_types[624];
static swig_module_info swig_module = {swig_types, 623, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)

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

#if (PY_VERSION_HEX <= 0x02000000)
# if !defined(SWIG_PYTHON_CLASSIC)
#  error "This python version requires swig to be run with the '-classic' option"
# endif
#endif

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

#else
#  define SWIG_init    init_pythia8

#endif
#define SWIG_name    "_pythia8"

#define SWIGVERSION 0x030008 
#define SWIG_VERSION SWIGVERSION


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


#include <stdexcept>


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

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

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

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


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


#include <cstddef>


#include <string>


#include <iostream>

#if PY_VERSION_HEX >= 0x03020000
# define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
#else
# define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
#endif


#include <stdexcept>


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


#include <stddef.h>


namespace swig {
  struct stop_iteration {
  };

  struct SwigPyIterator {
  private:
    SwigPtr_PyObject _seq;

  protected:
    SwigPyIterator(PyObject *seq) : _seq(seq)
    {
    }
      
  public:
    virtual ~SwigPyIterator() {}

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

    // Forward iterator method, required by Python
    virtual SwigPyIterator *incr(size_t n = 1) = 0;
    
    // Backward iterator method, very common in C++, but not required in Python
    virtual SwigPyIterator *decr(size_t /*n*/ = 1)
    {
      throw stop_iteration();
    }

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

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

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

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

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

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

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

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

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


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


#include <float.h>


#include <math.h>


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


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


SWIGINTERNINLINE int
SWIG_AsVal_size_t (PyObject * obj, size_t *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
  if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
  return res;
}


  #define SWIG_From_long   PyLong_FromLong 


SWIGINTERNINLINE PyObject *
SWIG_From_ptrdiff_t  (ptrdiff_t value)
{    
  return SWIG_From_long  (static_cast< long >(value));
}


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


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


SWIGINTERNINLINE int
SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
{
  long v;
  int res = SWIG_AsVal_long (obj, val ? &v : 0);
  if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
  return res;
}


#include <algorithm>


#include <vector>


#include <utility>


#include <map>


#include <algorithm>


#include <deque>


#include <set>


#include <list>


#ifndef SWIG_STD_NOMODERN_STL
# include <ios>
#else
# include <streambuf.h>
#endif


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


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


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


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


SWIGINTERNINLINE PyObject *
SWIG_From_size_t  (size_t value)
{    
  return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
}


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


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


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


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


SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
{
#if PY_VERSION_HEX>=0x03000000
  if (PyUnicode_Check(obj))
#else  
  if (PyString_Check(obj))
#endif
  {
    char *cstr; Py_ssize_t len;
#if PY_VERSION_HEX>=0x03000000
    if (!alloc && cptr) {
        /* We can't allow converting without allocation, since the internal
           representation of string in Python 3 is UCS-2/UCS-4 but we require
           a UTF-8 representation.
           TODO(bhy) More detailed explanation */
        return SWIG_RuntimeError;
    }
    obj = PyUnicode_AsUTF8String(obj);
    PyBytes_AsStringAndSize(obj, &cstr, &len);
    if(alloc) *alloc = SWIG_NEWOBJ;
#else
    PyString_AsStringAndSize(obj, &cstr, &len);
#endif
    if (cptr) {
      if (alloc) {
	/* 
	   In python the user should not be able to modify the inner
	   string representation. To warranty that, if you define
	   SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
	   buffer is always returned.

	   The default behavior is just to return the pointer value,
	   so, be careful.
	*/ 
#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
	if (*alloc != SWIG_OLDOBJ) 
#else
	if (*alloc == SWIG_NEWOBJ) 
#endif
	{
	  *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
	  *alloc = SWIG_NEWOBJ;
	} else {
	  *cptr = cstr;
	  *alloc = SWIG_OLDOBJ;
	}
      } else {
	#if PY_VERSION_HEX>=0x03000000
	assert(0); /* Should never reach here in Python 3 */
	#endif
	*cptr = SWIG_Python_str_AsChar(obj);
      }
    }
    if (psize) *psize = len + 1;
#if PY_VERSION_HEX>=0x03000000
    Py_XDECREF(obj);
#endif
    return SWIG_OK;
  } else {
#if defined(SWIG_PYTHON_2_UNICODE)
#if PY_VERSION_HEX<0x03000000
    if (PyUnicode_Check(obj)) {
      char *cstr; Py_ssize_t len;
      if (!alloc && cptr) {
        return SWIG_RuntimeError;
      }
      obj = PyUnicode_AsUTF8String(obj);
      if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
        if (cptr) {
          if (alloc) *alloc = SWIG_NEWOBJ;
          *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
        }
        if (psize) *psize = len + 1;

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

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


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


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


#include <iostream>


SWIGINTERN int
SWIG_AsVal_short (PyObject * obj, short *val)
{
  long v;
  int res = SWIG_AsVal_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v < SHRT_MIN || v > SHRT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< short >(v);
    }
  }  
  return res;
}


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


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


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


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


/* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */
#ifndef SWIG_isfinite
# if defined(isfinite)
#  define SWIG_isfinite(X) (isfinite(X))
# elif defined(_MSC_VER)
#  define SWIG_isfinite(X) (_finite(X))
# elif defined(__sun) && defined(__SVR4)
#  include <ieeefp.h>
#  define SWIG_isfinite(X) (finite(X))
# endif
#endif


/* Accept infinite as a valid float value unless we are unable to check if a value is finite */
#ifdef SWIG_isfinite
# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX) && SWIG_isfinite(X))
#else
# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX))
#endif


SWIGINTERN int
SWIG_AsVal_float (PyObject * obj, float *val)
{
  double v;
  int res = SWIG_AsVal_double (obj, &v);
  if (SWIG_IsOK(res)) {
    if (SWIG_Float_Overflow_Check(v)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< float >(v);
    }
  }  
  return res;
}

SWIGINTERN std::basic_ostream< char,std::char_traits< char > > &std_basic_ostream_Sl_char_Sg__operator_Sl__Sl___SWIG_17(std::basic_ostream< char > *self,std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &s){
	  *self << s;
	  return *self;
	}




#ifndef SWIG_STD_NOMODERN_STL
#include <streambuf>
#else
#include <streambuf.h>
#endif


#include <sstream>


#include <complex> 


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

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

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

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

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

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

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

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

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

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

}


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

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

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

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


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

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

  /*
    Traits that provides the asval/as/check method
  */
  template <class Type>
  struct traits_asptr {   
    static int asptr(PyObject *obj, Type **val) {
      Type *p;
      int res = SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0);
      if (SWIG_IsOK(res)) {
	if (val) *val = p;
      }
      return res;
    }
  }; 

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

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

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

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

  template <class Type> 
  struct traits_as<Type, pointer_category> {
    static Type as(PyObject *obj, bool throw_error) {
      Type *v = 0;      
      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
      if (SWIG_IsOK(res) && v) {
	if (SWIG_IsNewObj(res)) {
	  Type r(*v);
	  delete v;
	  return r;
	} else {
	  return *v;
	}
      } else {
	// Uninitialized return value, no Type() constructor required.
	static Type *v_def = (Type*) malloc(sizeof(Type));
	if (!PyErr_Occurred()) {
	  SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
	}
	if (throw_error) throw std::invalid_argument("bad type");
	memset(v_def,0,sizeof(Type));
	return *v_def;
      }
    }
  };

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

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

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

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


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


  namespace swig {

















































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

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

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


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





































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

#include <functional>

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

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

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

}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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


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

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

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

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

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

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

    SwigPyIterator *decr(size_t n = 1)
    {
      while (n--) {
	--base::current;
      }
      return this;
    }
  };

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

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

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

  private:
    out_iterator begin;
    out_iterator end;
  };

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

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

}


namespace swig
{
  template <class T>
  struct SwigPySequence_Ref
  {
    SwigPySequence_Ref(PyObject* seq, Py_ssize_t index)
      : _seq(seq), _index(index)
    {
    }
    
    operator T () const
    {
      swig::SwigVar_PyObject item = PySequence_GetItem(_seq, _index);
      try {
	return swig::as<T>(item, true);
      } catch (std::exception& e) {
	char msg[1024];
	sprintf(msg, "in sequence element %d ", (int)_index);
	if (!PyErr_Occurred()) {
	  ::SWIG_Error(SWIG_TypeError,  swig::type_name<T>());
	}
	SWIG_Python_AddErrorMsg(msg);
	SWIG_Python_AddErrorMsg(e.what());
	throw;
      }
    }

    SwigPySequence_Ref& operator=(const T& v)
    {
      PySequence_SetItem(_seq, _index, swig::from<T>(v));
      return *this;
    }

  private:
    PyObject* _seq;
    Py_ssize_t _index;
  };

  template <class T>
  struct SwigPySequence_ArrowProxy
  {
    SwigPySequence_ArrowProxy(const T& x): m_value(x) {}
    const T* operator->() const { return &m_value; }
    operator const T*() const { return &m_value; }
    T m_value;
  };

  template <class T, class Reference >
  struct SwigPySequence_InputIterator
  {
    typedef SwigPySequence_InputIterator<T, Reference > self;

    typedef std::random_access_iterator_tag iterator_category;
    typedef Reference reference;
    typedef T value_type;
    typedef T* pointer;
    typedef Py_ssize_t difference_type;

    SwigPySequence_InputIterator()
    {
    }

    SwigPySequence_InputIterator(PyObject* seq, Py_ssize_t index)
      : _seq(seq), _index(index)
    {
    }

    reference operator*() const
    {
      return reference(_seq, _index);
    }

    SwigPySequence_ArrowProxy<T>
    operator->() const {
      return SwigPySequence_ArrowProxy<T>(operator*());
    }

    bool operator==(const self& ri) const
    {
      return (_index == ri._index) && (_seq == ri._seq);
    }

    bool operator!=(const self& ri) const
    {
      return !(operator==(ri));
    }

    self& operator ++ ()
    {
      ++_index;
      return *this;
    }

    self& operator -- ()
    {
      --_index;
      return *this;
    }

    self& operator += (difference_type n)
    {
      _index += n;
      return *this;
    }

    self operator +(difference_type n) const
    {
      return self(_seq, _index + n);
    }

    self& operator -= (difference_type n)
    {
      _index -= n;
      return *this;
    }

    self operator -(difference_type n) const
    {
      return self(_seq, _index - n);
    }

    difference_type operator - (const self& ri) const
    {
      return _index - ri._index;
    }

    bool operator < (const self& ri) const
    {
      return _index < ri._index;
    }

    reference
    operator[](difference_type n) const
    {
      return reference(_seq, _index + n);
    }

  private:
    PyObject* _seq;
    difference_type _index;
  };

  // STL container wrapper around a Python sequence
  template <class T>
  struct SwigPySequence_Cont
  {
    typedef SwigPySequence_Ref<T> reference;
    typedef const SwigPySequence_Ref<T> const_reference;
    typedef T value_type;
    typedef T* pointer;
    typedef Py_ssize_t difference_type;
    typedef size_t size_type;
    typedef const pointer const_pointer;
    typedef SwigPySequence_InputIterator<T, reference> iterator;
    typedef SwigPySequence_InputIterator<T, const_reference> const_iterator;

    SwigPySequence_Cont(PyObject* seq) : _seq(0)
    {
      if (!PySequence_Check(seq)) {
	throw std::invalid_argument("a sequence is expected");
      }
      _seq = seq;
      Py_INCREF(_seq);
    }

    ~SwigPySequence_Cont()
    {
      Py_XDECREF(_seq);
    }

    size_type size() const
    {
      return static_cast<size_type>(PySequence_Size(_seq));
    }

    bool empty() const
    {
      return size() == 0;
    }

    iterator begin()
    {
      return iterator(_seq, 0);
    }

    const_iterator begin() const
    {
      return const_iterator(_seq, 0);
    }

    iterator end()
    {
      return iterator(_seq, size());
    }

    const_iterator end() const
    {
      return const_iterator(_seq, size());
    }

    reference operator[](difference_type n)
    {
      return reference(_seq, n);
    }

    const_reference operator[](difference_type n)  const
    {
      return const_reference(_seq, n);
    }

    bool check(bool set_err = true) const
    {
      Py_ssize_t s = size();
      for (Py_ssize_t i = 0; i < s; ++i) {
	swig::SwigVar_PyObject item = PySequence_GetItem(_seq, i);
	if (!swig::check<value_type>(item)) {
	  if (set_err) {
	    char msg[1024];
	    sprintf(msg, "in sequence element %d", (int)i);
	    SWIG_Error(SWIG_RuntimeError, msg);
	  }
	  return false;
	}
      }
      return true;
    }

  private:
    PyObject* _seq;
  };

}


namespace swig {
  template <class SwigPySeq, class Seq>
  inline void
  assign(const SwigPySeq& swigpyseq, Seq* seq) {
    // seq->assign(swigpyseq.begin(), swigpyseq.end()); // not used as not always implemented
    typedef typename SwigPySeq::value_type value_type;
    typename SwigPySeq::const_iterator it = swigpyseq.begin();
    for (;it != swigpyseq.end(); ++it) {
      seq->insert(seq->end(),(value_type)(*it));
    }
  }

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

    static int asptr(PyObject *obj, sequence **seq) {
      if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) {
	sequence *p;
	if (::SWIG_ConvertPtr(obj,(void**)&p,
			      swig::type_info<sequence>(),0) == SWIG_OK) {
	  if (seq) *seq = p;
	  return SWIG_OLDOBJ;
	}
      } else if (PySequence_Check(obj)) {
	try {
	  SwigPySequence_Cont<value_type> swigpyseq(obj);
	  if (seq) {
	    sequence *pseq = new sequence();
	    assign(swigpyseq, pseq);
	    *seq = pseq;
	    return SWIG_NEWOBJ;
	  } else {
	    return swigpyseq.check() ? SWIG_OK : SWIG_ERROR;
	  }
	} catch (std::exception& e) {
	  if (seq) {
	    if (!PyErr_Occurred()) {
	      PyErr_SetString(PyExc_TypeError, e.what());
	    }
	  }
	  return SWIG_ERROR;
	}
      }
      return SWIG_ERROR;
    }
  };

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

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


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

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

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


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

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

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

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


  namespace swig {
    template <class SwigPySeq, class K, class T, class Compare, class Alloc >
    inline void
    assign(const SwigPySeq& swigpyseq, std::map<K,T,Compare,Alloc > *map) {
      typedef typename std::map<K,T,Compare,Alloc >::value_type value_type;
      typename SwigPySeq::const_iterator it = swigpyseq.begin();
      for (;it != swigpyseq.end(); ++it) {
	map->insert(value_type(it->first, it->second));
      }
    }

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

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


      namespace swig {
	template <>  struct traits<std::map< int, int, std::less< int >, std::allocator< std::pair< int const,int > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::map<" "int" "," "int" "," "std::less< int >" "," "std::allocator< std::pair< int const,int > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_map_Sl_int_Sc_int_Sg__iterator(std::map< int,int > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_map_Sl_int_Sc_int_Sg____nonzero__(std::map< int,int > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_map_Sl_int_Sc_int_Sg____bool__(std::map< int,int > const *self){
      return !(self->empty());
    }
SWIGINTERN std::map< int,int >::size_type std_map_Sl_int_Sc_int_Sg____len__(std::map< int,int > const *self){
      return self->size();
    }
SWIGINTERN std::map< int,int >::mapped_type const &std_map_Sl_int_Sc_int_Sg____getitem__(std::map< int,int > *self,std::map< int,int >::key_type const &key){
      std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::const_iterator i = self->find(key);
      if (i != self->end())
	return i->second;
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN void std_map_Sl_int_Sc_int_Sg____delitem__(std::map< int,int > *self,std::map< int,int >::key_type const &key){
      std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::iterator i = self->find(key);
      if (i != self->end())
	self->erase(i);
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN bool std_map_Sl_int_Sc_int_Sg__has_key(std::map< int,int > const *self,std::map< int,int >::key_type const &key){
      std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::const_iterator i = self->find(key);
      return i != self->end();
    }
SWIGINTERN PyObject *std_map_Sl_int_Sc_int_Sg__keys(std::map< int,int > *self){
      std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* keyList = PyList_New(pysize);
      std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(keyList, j, swig::from(i->first));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return keyList;
    }
SWIGINTERN PyObject *std_map_Sl_int_Sc_int_Sg__values(std::map< int,int > *self){
      std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* valList = PyList_New(pysize);
      std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(valList, j, swig::from(i->second));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return valList;
    }
SWIGINTERN PyObject *std_map_Sl_int_Sc_int_Sg__items(std::map< int,int > *self){
      std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }    
      PyObject* itemList = PyList_New(pysize);
      std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(itemList, j, swig::from(*i));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return itemList;
    }
SWIGINTERN bool std_map_Sl_int_Sc_int_Sg____contains__(std::map< int,int > *self,std::map< int,int >::key_type const &key){
      return self->find(key) != self->end();
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_int_Sc_int_Sg__key_iterator(std::map< int,int > *self,PyObject **PYTHON_SELF){
      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_int_Sc_int_Sg__value_iterator(std::map< int,int > *self,PyObject **PYTHON_SELF){
      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN void std_map_Sl_int_Sc_int_Sg____setitem____SWIG_0(std::map< int,int > *self,std::map< int,int >::key_type const &key){
      self->erase(key);
    }
SWIGINTERN void std_map_Sl_int_Sc_int_Sg____setitem____SWIG_1(std::map< int,int > *self,std::map< int,int >::key_type const &key,std::map< int,int >::mapped_type const &x){
      (*self)[key] = x;
    }
SWIGINTERN PyObject *std_map_Sl_int_Sc_int_Sg__asdict(std::map< int,int > *self){
      return swig::traits_from< std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > > >::asdict(*self);
    }
SWIGINTERN void std_map_Sl_int_Sc_int_Sg__erase__SWIG_1(std::map< int,int > *self,std::map< int,int >::iterator position){ self->erase(position); }
SWIGINTERN void std_map_Sl_int_Sc_int_Sg__erase__SWIG_2(std::map< int,int > *self,std::map< int,int >::iterator first,std::map< int,int >::iterator last){ self->erase(first, last); }

SWIGINTERN int
SWIG_AsPtr_std_string (PyObject * obj, std::string **val) 
{
  char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
  if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
    if (buf) {
      if (val) *val = new std::string(buf, size - 1);
      if (alloc == SWIG_NEWOBJ) delete[] buf;
      return SWIG_NEWOBJ;
    } else {
      if (val) *val = 0;
      return SWIG_OLDOBJ;
    }
  } else {
    static int init = 0;
    static swig_type_info* descriptor = 0;
    if (!init) {
      descriptor = SWIG_TypeQuery("std::string" " *");
      init = 1;
    }
    if (descriptor) {
      std::string *vptr;
      int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
      if (SWIG_IsOK(res) && val) *val = vptr;
      return res;
    }
  }
  return SWIG_ERROR;
}


SWIGINTERN int
SWIG_AsVal_std_string (PyObject * obj, std::string *val)
{
  std::string* v = (std::string *) 0;
  int res = SWIG_AsPtr_std_string (obj, &v);
  if (!SWIG_IsOK(res)) return res;
  if (v) {
    if (val) *val = *v;
    if (SWIG_IsNewObj(res)) {
      delete v;
      res = SWIG_DelNewMask(res);
    }
    return res;
  }
  return SWIG_ERROR;
}


SWIGINTERNINLINE PyObject *
SWIG_From_std_string  (const std::string& s)
{
  return SWIG_FromCharPtrAndSize(s.data(), s.size());
}


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


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

      namespace swig {
	template <>  struct traits<std::map< std::string, std::string, std::less< std::string >, std::allocator< std::pair< std::string const,std::string > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::map<" "std::string" "," "std::string" "," "std::less< std::string >" "," "std::allocator< std::pair< std::string const,std::string > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_std_string_Sg__iterator(std::map< std::string,std::string > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg____nonzero__(std::map< std::string,std::string > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg____bool__(std::map< std::string,std::string > const *self){
      return !(self->empty());
    }
SWIGINTERN std::map< std::string,std::string >::size_type std_map_Sl_std_string_Sc_std_string_Sg____len__(std::map< std::string,std::string > const *self){
      return self->size();
    }
SWIGINTERN std::map< std::string,std::string >::mapped_type const &std_map_Sl_std_string_Sc_std_string_Sg____getitem__(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key){
      std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::const_iterator i = self->find(key);
      if (i != self->end())
	return i->second;
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg____delitem__(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key){
      std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::iterator i = self->find(key);
      if (i != self->end())
	self->erase(i);
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg__has_key(std::map< std::string,std::string > const *self,std::map< std::string,std::string >::key_type const &key){
      std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::const_iterator i = self->find(key);
      return i != self->end();
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_std_string_Sg__keys(std::map< std::string,std::string > *self){
      std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* keyList = PyList_New(pysize);
      std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(keyList, j, swig::from(i->first));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return keyList;
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_std_string_Sg__values(std::map< std::string,std::string > *self){
      std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* valList = PyList_New(pysize);
      std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(valList, j, swig::from(i->second));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return valList;
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_std_string_Sg__items(std::map< std::string,std::string > *self){
      std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }    
      PyObject* itemList = PyList_New(pysize);
      std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(itemList, j, swig::from(*i));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return itemList;
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg____contains__(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key){
      return self->find(key) != self->end();
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_std_string_Sg__key_iterator(std::map< std::string,std::string > *self,PyObject **PYTHON_SELF){
      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_std_string_Sg__value_iterator(std::map< std::string,std::string > *self,PyObject **PYTHON_SELF){
      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg____setitem____SWIG_0(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key){
      self->erase(key);
    }
SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg____setitem____SWIG_1(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key,std::map< std::string,std::string >::mapped_type const &x){
      (*self)[key] = x;
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_std_string_Sg__asdict(std::map< std::string,std::string > *self){
      return swig::traits_from< std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > >::asdict(*self);
    }
SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg__erase__SWIG_1(std::map< std::string,std::string > *self,std::map< std::string,std::string >::iterator position){ self->erase(position); }
SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg__erase__SWIG_2(std::map< std::string,std::string > *self,std::map< std::string,std::string >::iterator first,std::map< std::string,std::string >::iterator last){ self->erase(first, last); }

  #define SWIG_From_double   PyFloat_FromDouble 


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


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

      namespace swig {
	template <>  struct traits<std::map< double, std::pair< int,int >, std::less< double >, std::allocator< std::pair< double const,std::pair< int,int > > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::map<" "double" "," "std::pair< int,int >" "," "std::less< double >" "," "std::allocator< std::pair< double const,std::pair< int,int > > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__iterator(std::map< double,std::pair< int,int > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg____nonzero__(std::map< double,std::pair< int,int > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg____bool__(std::map< double,std::pair< int,int > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::map< double,std::pair< int,int > >::size_type std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg____len__(std::map< double,std::pair< int,int > > const *self){
      return self->size();
    }
SWIGINTERN std::map< double,std::pair< int,int > >::mapped_type const &std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg____getitem__(std::map< double,std::pair< int,int > > *self,std::map< double,std::pair< int,int > >::key_type const &key){
      std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >::const_iterator i = self->find(key);
      if (i != self->end())
	return i->second;
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN void std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg____delitem__(std::map< double,std::pair< int,int > > *self,std::map< double,std::pair< int,int > >::key_type const &key){
      std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >::iterator i = self->find(key);
      if (i != self->end())
	self->erase(i);
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN bool std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__has_key(std::map< double,std::pair< int,int > > const *self,std::map< double,std::pair< int,int > >::key_type const &key){
      std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >::const_iterator i = self->find(key);
      return i != self->end();
    }
SWIGINTERN PyObject *std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__keys(std::map< double,std::pair< int,int > > *self){
      std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* keyList = PyList_New(pysize);
      std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(keyList, j, swig::from(i->first));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return keyList;
    }
SWIGINTERN PyObject *std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__values(std::map< double,std::pair< int,int > > *self){
      std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* valList = PyList_New(pysize);
      std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(valList, j, swig::from(i->second));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return valList;
    }
SWIGINTERN PyObject *std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__items(std::map< double,std::pair< int,int > > *self){
      std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }    
      PyObject* itemList = PyList_New(pysize);
      std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(itemList, j, swig::from(*i));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return itemList;
    }
SWIGINTERN bool std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg____contains__(std::map< double,std::pair< int,int > > *self,std::map< double,std::pair< int,int > >::key_type const &key){
      return self->find(key) != self->end();
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__key_iterator(std::map< double,std::pair< int,int > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__value_iterator(std::map< double,std::pair< int,int > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN void std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg____setitem____SWIG_0(std::map< double,std::pair< int,int > > *self,std::map< double,std::pair< int,int > >::key_type const &key){
      self->erase(key);
    }
SWIGINTERN void std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg____setitem____SWIG_1(std::map< double,std::pair< int,int > > *self,std::map< double,std::pair< int,int > >::key_type const &key,std::map< double,std::pair< int,int > >::mapped_type const &x){
      (*self)[key] = x;
    }
SWIGINTERN PyObject *std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__asdict(std::map< double,std::pair< int,int > > *self){
      return swig::traits_from< std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > > >::asdict(*self);
    }
SWIGINTERN void std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__erase__SWIG_1(std::map< double,std::pair< int,int > > *self,std::map< double,std::pair< int,int > >::iterator position){ self->erase(position); }
SWIGINTERN void std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__erase__SWIG_2(std::map< double,std::pair< int,int > > *self,std::map< double,std::pair< int,int > >::iterator first,std::map< double,std::pair< int,int > >::iterator last){ self->erase(first, last); }

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


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


      namespace swig {
	template <>  struct traits<std::vector<bool, std::allocator< bool > > > {
	  typedef value_category category;
	  static const char* type_name() {
	    return "std::vector<bool, std::allocator< bool > >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_bool_Sg__iterator(std::vector< bool > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_bool_Sg____nonzero__(std::vector< bool > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_bool_Sg____bool__(std::vector< bool > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< bool >::size_type std_vector_Sl_bool_Sg____len__(std::vector< bool > const *self){
      return self->size();
    }
SWIGINTERN std::vector< bool,std::allocator< bool > > *std_vector_Sl_bool_Sg____getslice__(std::vector< bool > *self,std::vector< bool >::difference_type i,std::vector< bool >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_bool_Sg____setslice____SWIG_0(std::vector< bool > *self,std::vector< bool >::difference_type i,std::vector< bool >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector<bool,std::allocator< bool > >());
    }
SWIGINTERN void std_vector_Sl_bool_Sg____setslice____SWIG_1(std::vector< bool > *self,std::vector< bool >::difference_type i,std::vector< bool >::difference_type j,std::vector< bool,std::allocator< bool > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_bool_Sg____delslice__(std::vector< bool > *self,std::vector< bool >::difference_type i,std::vector< bool >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_bool_Sg____delitem____SWIG_0(std::vector< bool > *self,std::vector< bool >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< bool,std::allocator< bool > > *std_vector_Sl_bool_Sg____getitem____SWIG_0(std::vector< bool > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<bool,std::allocator< bool > >::difference_type id = i;
      std::vector<bool,std::allocator< bool > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_bool_Sg____setitem____SWIG_0(std::vector< bool > *self,PySliceObject *slice,std::vector< bool,std::allocator< bool > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<bool,std::allocator< bool > >::difference_type id = i;
      std::vector<bool,std::allocator< bool > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_bool_Sg____setitem____SWIG_1(std::vector< bool > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<bool,std::allocator< bool > >::difference_type id = i;
      std::vector<bool,std::allocator< bool > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_bool_Sg____delitem____SWIG_1(std::vector< bool > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<bool,std::allocator< bool > >::difference_type id = i;
      std::vector<bool,std::allocator< bool > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< bool >::value_type std_vector_Sl_bool_Sg____getitem____SWIG_1(std::vector< bool > *self,std::vector< bool >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_bool_Sg____setitem____SWIG_2(std::vector< bool > *self,std::vector< bool >::difference_type i,std::vector< bool >::value_type x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< bool >::value_type std_vector_Sl_bool_Sg__pop(std::vector< bool > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector<bool,std::allocator< bool > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_bool_Sg__append(std::vector< bool > *self,std::vector< bool >::value_type x){
      self->push_back(x);
    }
SWIGINTERN std::vector< bool >::iterator std_vector_Sl_bool_Sg__erase__SWIG_0(std::vector< bool > *self,std::vector< bool >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< bool >::iterator std_vector_Sl_bool_Sg__erase__SWIG_1(std::vector< bool > *self,std::vector< bool >::iterator first,std::vector< bool >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< bool >::iterator std_vector_Sl_bool_Sg__insert__SWIG_0(std::vector< bool > *self,std::vector< bool >::iterator pos,std::vector< bool >::value_type x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_bool_Sg__insert__SWIG_1(std::vector< bool > *self,std::vector< bool >::iterator pos,std::vector< bool >::size_type n,std::vector< bool >::value_type x){ self->insert(pos, n, x); }

SWIGINTERN int
SWIG_AsVal_std_complex_Sl_double_Sg_  (PyObject *o, std::complex<double>* val)
{
  if (PyComplex_Check(o)) {
    if (val) *val = std::complex<double>(PyComplex_RealAsDouble(o), PyComplex_ImagAsDouble(o));
    return SWIG_OK;
  } else {
    double d;    
    int res = SWIG_AddCast(SWIG_AsVal_double (o, &d));
    if (SWIG_IsOK(res)) {
      if (val) *val = std::complex<double>(d, 0.0);
      return res;
    }
  }
  return SWIG_TypeError;
}


SWIGINTERNINLINE PyObject*
SWIG_From_std_complex_Sl_double_Sg_  (/*@SWIG:/hep/swig/3.0.8/share/swig/3.0.8/typemaps/swigmacros.swg,104,%ifcplusplus@*/

const std::complex<double>&



/*@SWIG@*/ c)
{
  return PyComplex_FromDoubles(std::real(c), std::imag(c));
}


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


      namespace swig {
	template <>  struct traits<std::vector< std::complex< double >, std::allocator< std::complex< double > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::complex< double >" "," "std::allocator< std::complex< double > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_complex_Sl_double_Sg__Sg__iterator(std::vector< std::complex< double > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_std_complex_Sl_double_Sg__Sg____nonzero__(std::vector< std::complex< double > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_std_complex_Sl_double_Sg__Sg____bool__(std::vector< std::complex< double > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< std::complex< double > >::size_type std_vector_Sl_std_complex_Sl_double_Sg__Sg____len__(std::vector< std::complex< double > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< double > > > *std_vector_Sl_std_complex_Sl_double_Sg__Sg____getslice__(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setslice____SWIG_0(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< std::complex< double >,std::allocator< std::complex< double > > >());
    }
SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setslice____SWIG_1(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::difference_type j,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delslice__(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< double > > > *std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::complex< double > > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::complex< double > > *self,PySliceObject *slice,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< std::complex< double > >::value_type const &std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_1(std::vector< std::complex< double > > const *self,std::vector< std::complex< double > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_2(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< std::complex< double > >::value_type std_vector_Sl_std_complex_Sl_double_Sg__Sg__pop(std::vector< std::complex< double > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg__append(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::complex< double > >::iterator std_vector_Sl_std_complex_Sl_double_Sg__Sg__erase__SWIG_0(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::complex< double > >::iterator std_vector_Sl_std_complex_Sl_double_Sg__Sg__erase__SWIG_1(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::iterator first,std::vector< std::complex< double > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::complex< double > >::iterator std_vector_Sl_std_complex_Sl_double_Sg__Sg__insert__SWIG_0(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::iterator pos,std::vector< std::complex< double > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg__insert__SWIG_1(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::iterator pos,std::vector< std::complex< double > >::size_type n,std::vector< std::complex< double > >::value_type const &x){ self->insert(pos, n, x); }

      namespace swig {
	template <>  struct traits<std::vector< double, std::allocator< double > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "double" "," "std::allocator< double >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
      return self->size();
    }
SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
    }
SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< double,std::allocator< double > >::difference_type id = i;
      std::vector< double,std::allocator< double > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< double,std::allocator< double > >::difference_type id = i;
      std::vector< double,std::allocator< double > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< double,std::allocator< double > >::difference_type id = i;
      std::vector< double,std::allocator< double > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< double,std::allocator< double > >::difference_type id = i;
      std::vector< double,std::allocator< double > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_2(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< double,std::allocator< double > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector< double > *self,std::vector< double >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_1(std::vector< double > *self,std::vector< double >::iterator first,std::vector< double >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__insert__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_double_Sg__insert__SWIG_1(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::size_type n,std::vector< double >::value_type const &x){ self->insert(pos, n, x); }

      namespace swig {
	template <>  struct traits<std::vector< int, std::allocator< int > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "int" "," "std::allocator< int >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_int_Sg__iterator(std::vector< int > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector< int > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_int_Sg____bool__(std::vector< int > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< int >::size_type std_vector_Sl_int_Sg____len__(std::vector< int > const *self){
      return self->size();
    }
SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< int,std::allocator< int > >());
    }
SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_1(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< int,std::allocator< int > >::difference_type id = i;
      std::vector< int,std::allocator< int > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< int,std::allocator< int > >::difference_type id = i;
      std::vector< int,std::allocator< int > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< int,std::allocator< int > >::difference_type id = i;
      std::vector< int,std::allocator< int > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< int,std::allocator< int > >::difference_type id = i;
      std::vector< int,std::allocator< int > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< int >::value_type const &std_vector_Sl_int_Sg____getitem____SWIG_1(std::vector< int > const *self,std::vector< int >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_2(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__pop(std::vector< int > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< int,std::allocator< int > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_int_Sg__append(std::vector< int > *self,std::vector< int >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__erase__SWIG_0(std::vector< int > *self,std::vector< int >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__erase__SWIG_1(std::vector< int > *self,std::vector< int >::iterator first,std::vector< int >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__insert__SWIG_0(std::vector< int > *self,std::vector< int >::iterator pos,std::vector< int >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_int_Sg__insert__SWIG_1(std::vector< int > *self,std::vector< int >::iterator pos,std::vector< int >::size_type n,std::vector< int >::value_type const &x){ self->insert(pos, n, x); }

      namespace swig {
	template <>  struct traits<std::vector< std::string, std::allocator< std::string > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::string" "," "std::allocator< std::string >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_string_Sg__iterator(std::vector< std::string > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_std_string_Sg____nonzero__(std::vector< std::string > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_std_string_Sg____bool__(std::vector< std::string > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< std::string >::size_type std_vector_Sl_std_string_Sg____len__(std::vector< std::string > const *self){
      return self->size();
    }
SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getslice__(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setslice____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< std::string,std::allocator< std::string > >());
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setslice____SWIG_1(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j,std::vector< std::string,std::allocator< std::string > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____delslice__(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice,std::vector< std::string,std::allocator< std::string > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< std::string >::value_type const &std_vector_Sl_std_string_Sg____getitem____SWIG_1(std::vector< std::string > const *self,std::vector< std::string >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_2(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< std::string >::value_type std_vector_Sl_std_string_Sg__pop(std::vector< std::string > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::string,std::allocator< std::string > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_std_string_Sg__append(std::vector< std::string > *self,std::vector< std::string >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__erase__SWIG_0(std::vector< std::string > *self,std::vector< std::string >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__erase__SWIG_1(std::vector< std::string > *self,std::vector< std::string >::iterator first,std::vector< std::string >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__insert__SWIG_0(std::vector< std::string > *self,std::vector< std::string >::iterator pos,std::vector< std::string >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_std_string_Sg__insert__SWIG_1(std::vector< std::string > *self,std::vector< std::string >::iterator pos,std::vector< std::string >::size_type n,std::vector< std::string >::value_type const &x){ self->insert(pos, n, x); }

      namespace swig {
	template <>  struct traits<std::vector< std::pair< int,int >, std::allocator< std::pair< int,int > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::pair< int,int >" "," "std::allocator< std::pair< int,int > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg__iterator(std::vector< std::pair< int,int > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____nonzero__(std::vector< std::pair< int,int > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____bool__(std::vector< std::pair< int,int > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< std::pair< int,int > >::size_type std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____len__(std::vector< std::pair< int,int > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____getslice__(std::vector< std::pair< int,int > > *self,std::vector< std::pair< int,int > >::difference_type i,std::vector< std::pair< int,int > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____setslice____SWIG_0(std::vector< std::pair< int,int > > *self,std::vector< std::pair< int,int > >::difference_type i,std::vector< std::pair< int,int > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >());
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____setslice____SWIG_1(std::vector< std::pair< int,int > > *self,std::vector< std::pair< int,int > >::difference_type i,std::vector< std::pair< int,int > >::difference_type j,std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____delslice__(std::vector< std::pair< int,int > > *self,std::vector< std::pair< int,int > >::difference_type i,std::vector< std::pair< int,int > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____delitem____SWIG_0(std::vector< std::pair< int,int > > *self,std::vector< std::pair< int,int > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____getitem____SWIG_0(std::vector< std::pair< int,int > > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >::difference_type id = i;
      std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____setitem____SWIG_0(std::vector< std::pair< int,int > > *self,PySliceObject *slice,std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >::difference_type id = i;
      std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____setitem____SWIG_1(std::vector< std::pair< int,int > > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >::difference_type id = i;
      std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____delitem____SWIG_1(std::vector< std::pair< int,int > > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >::difference_type id = i;
      std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< std::pair< int,int > >::value_type const &std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____getitem____SWIG_1(std::vector< std::pair< int,int > > const *self,std::vector< std::pair< int,int > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____setitem____SWIG_2(std::vector< std::pair< int,int > > *self,std::vector< std::pair< int,int > >::difference_type i,std::vector< std::pair< int,int > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< std::pair< int,int > >::value_type std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg__pop(std::vector< std::pair< int,int > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg__append(std::vector< std::pair< int,int > > *self,std::vector< std::pair< int,int > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::pair< int,int > >::iterator std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg__erase__SWIG_0(std::vector< std::pair< int,int > > *self,std::vector< std::pair< int,int > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::pair< int,int > >::iterator std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg__erase__SWIG_1(std::vector< std::pair< int,int > > *self,std::vector< std::pair< int,int > >::iterator first,std::vector< std::pair< int,int > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::pair< int,int > >::iterator std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg__insert__SWIG_0(std::vector< std::pair< int,int > > *self,std::vector< std::pair< int,int > >::iterator pos,std::vector< std::pair< int,int > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg__insert__SWIG_1(std::vector< std::pair< int,int > > *self,std::vector< std::pair< int,int > >::iterator pos,std::vector< std::pair< int,int > >::size_type n,std::vector< std::pair< int,int > >::value_type const &x){ self->insert(pos, n, x); }

      namespace swig {
	template <>  struct traits<std::vector< std::vector< int,std::allocator< int > >, std::allocator< std::vector< int,std::allocator< int > > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::vector< int,std::allocator< int > >" "," "std::allocator< std::vector< int,std::allocator< int > > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_vector_Sl_int_Sg__Sg__iterator(std::vector< std::vector< int > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_std_vector_Sl_int_Sg__Sg____nonzero__(std::vector< std::vector< int > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_std_vector_Sl_int_Sg__Sg____bool__(std::vector< std::vector< int > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< std::vector< int > >::size_type std_vector_Sl_std_vector_Sl_int_Sg__Sg____len__(std::vector< std::vector< int > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg____getslice__(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::difference_type i,std::vector< std::vector< int > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setslice____SWIG_0(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::difference_type i,std::vector< std::vector< int > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >());
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setslice____SWIG_1(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::difference_type i,std::vector< std::vector< int > >::difference_type j,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delslice__(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::difference_type i,std::vector< std::vector< int > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< int > > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
      std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< int > > *self,PySliceObject *slice,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
      std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< int > > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
      std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< int > > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
      std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< std::vector< int > >::value_type const &std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_1(std::vector< std::vector< int > > const *self,std::vector< std::vector< int > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_2(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::difference_type i,std::vector< std::vector< int > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< std::vector< int > >::value_type std_vector_Sl_std_vector_Sl_int_Sg__Sg__pop(std::vector< std::vector< int > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__append(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::vector< int > >::iterator std_vector_Sl_std_vector_Sl_int_Sg__Sg__erase__SWIG_0(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::vector< int > >::iterator std_vector_Sl_std_vector_Sl_int_Sg__Sg__erase__SWIG_1(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::iterator first,std::vector< std::vector< int > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::vector< int > >::iterator std_vector_Sl_std_vector_Sl_int_Sg__Sg__insert__SWIG_0(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::iterator pos,std::vector< std::vector< int > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__insert__SWIG_1(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::iterator pos,std::vector< std::vector< int > >::size_type n,std::vector< std::vector< int > >::value_type const &x){ self->insert(pos, n, x); }

      namespace swig {
	template <>  struct traits<std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >, std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::vector< std::complex< double >,std::allocator< std::complex< double > > >" "," "std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg__iterator(std::vector< std::vector< std::complex< double > > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____nonzero__(std::vector< std::vector< std::complex< double > > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____bool__(std::vector< std::vector< std::complex< double > > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< std::vector< std::complex< double > > >::size_type std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____len__(std::vector< std::vector< std::complex< double > > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > *std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____getslice__(std::vector< std::vector< std::complex< double > > > *self,std::vector< std::vector< std::complex< double > > >::difference_type i,std::vector< std::vector< std::complex< double > > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____setslice____SWIG_0(std::vector< std::vector< std::complex< double > > > *self,std::vector< std::vector< std::complex< double > > >::difference_type i,std::vector< std::vector< std::complex< double > > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >());
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____setslice____SWIG_1(std::vector< std::vector< std::complex< double > > > *self,std::vector< std::vector< std::complex< double > > >::difference_type i,std::vector< std::vector< std::complex< double > > >::difference_type j,std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____delslice__(std::vector< std::vector< std::complex< double > > > *self,std::vector< std::vector< std::complex< double > > >::difference_type i,std::vector< std::vector< std::complex< double > > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____delitem____SWIG_0(std::vector< std::vector< std::complex< double > > > *self,std::vector< std::vector< std::complex< double > > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > *std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____getitem____SWIG_0(std::vector< std::vector< std::complex< double > > > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >::difference_type id = i;
      std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____setitem____SWIG_0(std::vector< std::vector< std::complex< double > > > *self,PySliceObject *slice,std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >::difference_type id = i;
      std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____setitem____SWIG_1(std::vector< std::vector< std::complex< double > > > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >::difference_type id = i;
      std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____delitem____SWIG_1(std::vector< std::vector< std::complex< double > > > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >::difference_type id = i;
      std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< std::vector< std::complex< double > > >::value_type const &std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____getitem____SWIG_1(std::vector< std::vector< std::complex< double > > > const *self,std::vector< std::vector< std::complex< double > > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____setitem____SWIG_2(std::vector< std::vector< std::complex< double > > > *self,std::vector< std::vector< std::complex< double > > >::difference_type i,std::vector< std::vector< std::complex< double > > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< std::vector< std::complex< double > > >::value_type std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg__pop(std::vector< std::vector< std::complex< double > > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg__append(std::vector< std::vector< std::complex< double > > > *self,std::vector< std::vector< std::complex< double > > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::vector< std::complex< double > > >::iterator std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg__erase__SWIG_0(std::vector< std::vector< std::complex< double > > > *self,std::vector< std::vector< std::complex< double > > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::vector< std::complex< double > > >::iterator std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg__erase__SWIG_1(std::vector< std::vector< std::complex< double > > > *self,std::vector< std::vector< std::complex< double > > >::iterator first,std::vector< std::vector< std::complex< double > > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::vector< std::complex< double > > >::iterator std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg__insert__SWIG_0(std::vector< std::vector< std::complex< double > > > *self,std::vector< std::vector< std::complex< double > > >::iterator pos,std::vector< std::vector< std::complex< double > > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg__insert__SWIG_1(std::vector< std::vector< std::complex< double > > > *self,std::vector< std::vector< std::complex< double > > >::iterator pos,std::vector< std::vector< std::complex< double > > >::size_type n,std::vector< std::vector< std::complex< double > > >::value_type const &x){ self->insert(pos, n, x); }

#include <assert.h>
static int VEC4_ERROR(0), EVENT_ERROR(0), BEAMPARTICLE_ERROR(0),
  COLCONFIG_ERROR(0);


#include "Pythia8/Pythia.h"
using namespace Pythia8;
#include "Pythia8/Analysis.h"
#include "Pythia8/Basics.h"
#include "Pythia8/BeamParticle.h"
#include "Pythia8/BeamRemnants.h"
#include "Pythia8/BeamShape.h"
#include "Pythia8/BoseEinstein.h"
#include "Pythia8/ColourReconnection.h"
#include "Pythia8/ColourTracing.h"
#include "Pythia8/Event.h"
#include "Pythia8/FragmentationFlavZpT.h"
#include "Pythia8/FragmentationSystems.h"
#include "Pythia8/GammaKinematics.h"
#include "Pythia8/HadronLevel.h"
#include "Pythia8/HadronScatter.h"
#include "Pythia8/HardDiffraction.h"
#include "Pythia8/HeavyIons.h"
#include "Pythia8/HelicityBasics.h"
#include "Pythia8/HelicityMatrixElements.h"
#include "Pythia8/HiddenValleyFragmentation.h"
#include "Pythia8/History.h"
#include "Pythia8/HIUserHooks.h"
#include "Pythia8/Info.h"
#include "Pythia8/JunctionSplitting.h"
#include "Pythia8/LesHouches.h"
#include "Pythia8/LHEF3.h"
#include "Pythia8/Merging.h"
#include "Pythia8/MergingHooks.h"
#include "Pythia8/MiniStringFragmentation.h"
#include "Pythia8/MultipartonInteractions.h"
#include "Pythia8/ParticleData.h"
#include "Pythia8/ParticleDecays.h"
#include "Pythia8/PartonDistributions.h"
#include "Pythia8/PartonLevel.h"
#include "Pythia8/PartonSystems.h"
#include "Pythia8/PartonVertex.h"
#include "Pythia8/PhaseSpace.h"
#include "Pythia8Plugins/aMCatNLOHooks.h"
#include "Pythia8Plugins/ColourReconnectionHooks.h"
#include "Pythia8Plugins/CombineMatchingInput.h"
#include "Pythia8Plugins/GeneratorInput.h"
#include "Pythia8Plugins/JetMatching.h"
#include "Pythia8Plugins/LHAHelaconia.h"
#include "Pythia8Plugins/LHAMadgraph.h"
#include "Pythia8Plugins/PowhegHooks.h"
#include "Pythia8Plugins/PowhegProcs.h"
#include "Pythia8Plugins/ProgressLog.h"
#include "Pythia8/ProcessContainer.h"
#include "Pythia8/ProcessLevel.h"
#include "Pythia8/PythiaComplex.h"
#include "Pythia8/Pythia.h"
#include "Pythia8/PythiaStdlib.h"
#include "Pythia8/ResonanceDecays.h"
#include "Pythia8/ResonanceWidthsDM.h"
#include "Pythia8/ResonanceWidths.h"
#include "Pythia8/RHadrons.h"
#include "Pythia8/Ropewalk.h"
#include "Pythia8/Settings.h"
#include "Pythia8/SigmaCompositeness.h"
#include "Pythia8/SigmaDM.h"
#include "Pythia8/SigmaEW.h"
#include "Pythia8/SigmaExtraDim.h"
#include "Pythia8/SigmaGeneric.h"
#include "Pythia8/SigmaHiggs.h"
#include "Pythia8/SigmaLeftRightSym.h"
#include "Pythia8/SigmaLeptoquark.h"
#include "Pythia8/SigmaNewGaugeBosons.h"
#include "Pythia8/SigmaOnia.h"
#include "Pythia8/SigmaProcess.h"
#include "Pythia8/SigmaQCD.h"
#include "Pythia8/SigmaSUSY.h"
#include "Pythia8/SigmaTotal.h"
#include "Pythia8/SLHAinterface.h"
#include "Pythia8/SpaceShower.h"
#include "Pythia8/StandardModel.h"
#include "Pythia8/Streams.h"
#include "Pythia8/StringFragmentation.h"
#include "Pythia8/StringLength.h"
#include "Pythia8/SusyCouplings.h"
#include "Pythia8/SusyLesHouches.h"
#include "Pythia8/SusyResonanceWidths.h"
#include "Pythia8/SusyWidthFunctions.h"
#include "Pythia8/TauDecays.h"
#include "Pythia8/TimeShower.h"
#include "Pythia8/UserHooks.h"
#include "Pythia8/WeakShowerMEs.h"

SWIGINTERN std::string Pythia8_Vec4___str__(Pythia8::Vec4 *self){
    std::ostringstream oss(std::ostringstream::out); oss << *(self);
    return oss.str();}
SWIGINTERN double Pythia8_Vec4___getitem__(Pythia8::Vec4 *self,int i){
    if (i >= 4) {VEC4_ERROR = 1; return 0;} return (*(self))[i];}
SWIGINTERN Pythia8::Vec4 Pythia8_Vec4___rmul__(Pythia8::Vec4 *self,double f){
    Pythia8::Vec4 v = *self; return f*v;}
SWIGINTERN std::string Pythia8_RotBstMatrix___str__(Pythia8::RotBstMatrix *self){
    std::ostringstream oss(std::ostringstream::out); oss << *(self);
    return oss.str();}
SWIGINTERN std::string Pythia8_Hist___str__(Pythia8::Hist *self){
    std::ostringstream oss(std::ostringstream::out); oss << *(self);
    return oss.str();}
SWIGINTERN Pythia8::Hist Pythia8_Hist___radd__(Pythia8::Hist *self,double f){
    Pythia8::Hist h = *self; return f+h;}
SWIGINTERN Pythia8::Hist Pythia8_Hist___rsub__(Pythia8::Hist *self,double f){
    Pythia8::Hist h = *self; return f-h;}
SWIGINTERN Pythia8::Hist Pythia8_Hist___rmul__(Pythia8::Hist *self,double f){
    Pythia8::Hist h = *self; return f*h;}
SWIGINTERN Pythia8::Hist Pythia8_Hist___rdiv__(Pythia8::Hist *self,double f){
    Pythia8::Hist h = *self; return f/h;}
SWIGINTERN std::string Pythia8_XMLTag___str__(Pythia8::XMLTag *self){
    std::ostringstream oss(std::ostringstream::out); self->list(oss);
    return oss.str();}
SWIGINTERN std::string Pythia8_LHAweights___str__(Pythia8::LHAweights *self){
    std::ostringstream oss(std::ostringstream::out); self->list(oss);
    return oss.str();}
SWIGINTERN std::string Pythia8_LHAscales___str__(Pythia8::LHAscales *self){
    std::ostringstream oss(std::ostringstream::out); self->list(oss);
    return oss.str();}
SWIGINTERN std::string Pythia8_LHAgenerator___str__(Pythia8::LHAgenerator *self){
    std::ostringstream oss(std::ostringstream::out); self->list(oss);
    return oss.str();}
SWIGINTERN std::string Pythia8_LHAwgt___str__(Pythia8::LHAwgt *self){
    std::ostringstream oss(std::ostringstream::out); self->list(oss);
    return oss.str();}
SWIGINTERN std::string Pythia8_LHAweight___str__(Pythia8::LHAweight *self){
    std::ostringstream oss(std::ostringstream::out); self->list(oss);
    return oss.str();}
SWIGINTERN std::string Pythia8_LHAweightgroup___str__(Pythia8::LHAweightgroup *self){
    std::ostringstream oss(std::ostringstream::out); self->list(oss);
    return oss.str();}
SWIGINTERN std::string Pythia8_LHArwgt___str__(Pythia8::LHArwgt *self){
    std::ostringstream oss(std::ostringstream::out); self->list(oss);
    return oss.str();}
SWIGINTERN std::string Pythia8_LHAinitrwgt___str__(Pythia8::LHAinitrwgt *self){
    std::ostringstream oss(std::ostringstream::out); self->list(oss);
    return oss.str();}
SWIGINTERN std::string Pythia8_PartonSystems___str__(Pythia8::PartonSystems *self){
    std::streambuf* old = cout.rdbuf();
    std::ostringstream oss(std::ostringstream::out);
    cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
    return oss.str();}

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

SWIGINTERN std::string Pythia8_Info___str__(Pythia8::Info *self){
    std::streambuf* old = cout.rdbuf();
    std::ostringstream oss(std::ostringstream::out);
    cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
    return oss.str();}
SWIGINTERN std::string Pythia8_ParticleData___str__(Pythia8::ParticleData *self){
    std::streambuf* old = cout.rdbuf();
    std::ostringstream oss(std::ostringstream::out);
    cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
    return oss.str();}
SWIGINTERN std::string Pythia8_Event___str__(Pythia8::Event *self){
    std::streambuf* old = cout.rdbuf();
    std::ostringstream oss(std::ostringstream::out);
    cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
    return oss.str();}
SWIGINTERN Pythia8::Particle *Pythia8_Event___getitem__(Pythia8::Event *self,int i){
    if (i >= self->size()) {EVENT_ERROR = 1; return 0;}
    return &(*(self))[i];}
SWIGINTERN std::string Pythia8_ColConfig___str__(Pythia8::ColConfig *self){
    std::streambuf* old = cout.rdbuf();
    std::ostringstream oss(std::ostringstream::out);
    cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
    return oss.str();}
SWIGINTERN Pythia8::ColSinglet *Pythia8_ColConfig___getitem__(Pythia8::ColConfig *self,int i){
    if (i >= self->size()) {COLCONFIG_ERROR = 1; return 0;}
    return &(*(self))[i];}
SWIGINTERN std::string Pythia8_Wave4___str__(Pythia8::Wave4 *self){
    std::ostringstream oss(std::ostringstream::out); oss << *(self);
    return oss.str();}
SWIGINTERN Pythia8::Wave4 Pythia8_Wave4___rmul____SWIG_0(Pythia8::Wave4 *self,std::complex< double > s){
    Pythia8::Wave4 w = *self; return s*w;}
SWIGINTERN Pythia8::Wave4 Pythia8_Wave4___rmul____SWIG_1(Pythia8::Wave4 *self,double s){
    Pythia8::Wave4 w = *self; return s*w;}
SWIGINTERN Pythia8::Wave4 Pythia8_Wave4___mul____SWIG_3(Pythia8::Wave4 *self,Pythia8::GammaMatrix g){
    Pythia8::Wave4 w = *self; return w*g;}
SWIGINTERN std::string Pythia8_GammaMatrix___str__(Pythia8::GammaMatrix *self){
    std::ostringstream oss(std::ostringstream::out); oss << *(self);
    return oss.str();}
SWIGINTERN Pythia8::GammaMatrix Pythia8_GammaMatrix___rmul__(Pythia8::GammaMatrix *self,std::complex< double > s){
    Pythia8::GammaMatrix g = *self; return s*g;}
SWIGINTERN Pythia8::GammaMatrix Pythia8_GammaMatrix___rsub__(Pythia8::GammaMatrix *self,std::complex< double > s){
    Pythia8::GammaMatrix g = *self; return s-g;}
SWIGINTERN Pythia8::GammaMatrix Pythia8_GammaMatrix___radd__(Pythia8::GammaMatrix *self,std::complex< double > s){
    Pythia8::GammaMatrix g = *self; return s+g;}

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


size_t
SWIG_strnlen(const char* s, size_t maxlen)
{
  const char *p;
  for (p = s; maxlen-- && *p; p++)
    ;
  return p - s;
}

SWIGINTERN std::string Pythia8_Sphericity___str__(Pythia8::Sphericity *self){
    std::streambuf* old = cout.rdbuf();
    std::ostringstream oss(std::ostringstream::out);
    cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
    return oss.str();}
SWIGINTERN std::string Pythia8_Thrust___str__(Pythia8::Thrust *self){
    std::streambuf* old = cout.rdbuf();
    std::ostringstream oss(std::ostringstream::out);
    cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
    return oss.str();}
SWIGINTERN std::string Pythia8_ClusterJet___str__(Pythia8::ClusterJet *self){
    std::streambuf* old = cout.rdbuf();
    std::ostringstream oss(std::ostringstream::out);
    cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
    return oss.str();}
SWIGINTERN std::string Pythia8_CellJet___str__(Pythia8::CellJet *self){
    std::streambuf* old = cout.rdbuf();
    std::ostringstream oss(std::ostringstream::out);
    cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
    return oss.str();}
SWIGINTERN std::string Pythia8_SlowJet___str__(Pythia8::SlowJet *self){
    std::streambuf* old = cout.rdbuf();
    std::ostringstream oss(std::ostringstream::out);
    cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
    return oss.str();}
SWIGINTERN std::string Pythia8_BeamParticle___str__(Pythia8::BeamParticle *self){
    std::streambuf* old = cout.rdbuf();
    std::ostringstream oss(std::ostringstream::out);
    cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
    return oss.str();}
SWIGINTERN Pythia8::ResolvedParton *Pythia8_BeamParticle___getitem__(Pythia8::BeamParticle *self,int i){
  if (i >= self->size()) {
    BEAMPARTICLE_ERROR = 1; return 0;} return &(*(self))[i];}
SWIGINTERN std::string Pythia8_HardProcess___str__(Pythia8::HardProcess *self){
    std::streambuf* old = cout.rdbuf();
    std::ostringstream oss(std::ostringstream::out);
    cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
    return oss.str();}
SWIGINTERN std::string Pythia8_SpaceShower___str__(Pythia8::SpaceShower *self){
    std::streambuf* old = cout.rdbuf();
    std::ostringstream oss(std::ostringstream::out);
    cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
    return oss.str();}
SWIGINTERN std::string Pythia8_TimeShower___str__(Pythia8::TimeShower *self){
    std::streambuf* old = cout.rdbuf();
    std::ostringstream oss(std::ostringstream::out);
    cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
    return oss.str();}
SWIGINTERN std::string Pythia8_ColourDipole___str__(Pythia8::ColourDipole *self){
    std::streambuf* old = cout.rdbuf();
    std::ostringstream oss(std::ostringstream::out);
    cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
    return oss.str();}
SWIGINTERN std::string Pythia8_ColourJunction___str__(Pythia8::ColourJunction *self){
    std::streambuf* old = cout.rdbuf();
    std::ostringstream oss(std::ostringstream::out);
    cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
    return oss.str();}
SWIGINTERN std::string Pythia8_Clustering___str__(Pythia8::Clustering *self){
    std::streambuf* old = cout.rdbuf();
    std::ostringstream oss(std::ostringstream::out);
    cout.rdbuf(oss.rdbuf()); self->list(); cout.rdbuf(old);
    return oss.str();}

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


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

      namespace swig {
	template <>  struct traits<std::map< std::string, Pythia8::Flag, std::less< std::string >, std::allocator< std::pair< std::string const,Pythia8::Flag > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::map<" "std::string" "," "Pythia8::Flag" "," "std::less< std::string >" "," "std::allocator< std::pair< std::string const,Pythia8::Flag > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__iterator(std::map< std::string,Pythia8::Flag > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Flag_Sg____nonzero__(std::map< std::string,Pythia8::Flag > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Flag_Sg____bool__(std::map< std::string,Pythia8::Flag > const *self){
      return !(self->empty());
    }
SWIGINTERN std::map< std::string,Pythia8::Flag >::size_type std_map_Sl_std_string_Sc_Pythia8_Flag_Sg____len__(std::map< std::string,Pythia8::Flag > const *self){
      return self->size();
    }
SWIGINTERN std::map< std::string,Pythia8::Flag >::mapped_type const &std_map_Sl_std_string_Sc_Pythia8_Flag_Sg____getitem__(std::map< std::string,Pythia8::Flag > *self,std::map< std::string,Pythia8::Flag >::key_type const &key){
      std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >::const_iterator i = self->find(key);
      if (i != self->end())
	return i->second;
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Flag_Sg____delitem__(std::map< std::string,Pythia8::Flag > *self,std::map< std::string,Pythia8::Flag >::key_type const &key){
      std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >::iterator i = self->find(key);
      if (i != self->end())
	self->erase(i);
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__has_key(std::map< std::string,Pythia8::Flag > const *self,std::map< std::string,Pythia8::Flag >::key_type const &key){
      std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >::const_iterator i = self->find(key);
      return i != self->end();
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__keys(std::map< std::string,Pythia8::Flag > *self){
      std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* keyList = PyList_New(pysize);
      std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(keyList, j, swig::from(i->first));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return keyList;
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__values(std::map< std::string,Pythia8::Flag > *self){
      std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* valList = PyList_New(pysize);
      std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(valList, j, swig::from(i->second));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return valList;
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__items(std::map< std::string,Pythia8::Flag > *self){
      std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }    
      PyObject* itemList = PyList_New(pysize);
      std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(itemList, j, swig::from(*i));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return itemList;
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Flag_Sg____contains__(std::map< std::string,Pythia8::Flag > *self,std::map< std::string,Pythia8::Flag >::key_type const &key){
      return self->find(key) != self->end();
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__key_iterator(std::map< std::string,Pythia8::Flag > *self,PyObject **PYTHON_SELF){
      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__value_iterator(std::map< std::string,Pythia8::Flag > *self,PyObject **PYTHON_SELF){
      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Flag_Sg____setitem____SWIG_0(std::map< std::string,Pythia8::Flag > *self,std::map< std::string,Pythia8::Flag >::key_type const &key){
      self->erase(key);
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Flag_Sg____setitem____SWIG_1(std::map< std::string,Pythia8::Flag > *self,std::map< std::string,Pythia8::Flag >::key_type const &key,std::map< std::string,Pythia8::Flag >::mapped_type const &x){
      (*self)[key] = x;
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__asdict(std::map< std::string,Pythia8::Flag > *self){
      return swig::traits_from< std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > > >::asdict(*self);
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__erase__SWIG_1(std::map< std::string,Pythia8::Flag > *self,std::map< std::string,Pythia8::Flag >::iterator position){ self->erase(position); }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__erase__SWIG_2(std::map< std::string,Pythia8::Flag > *self,std::map< std::string,Pythia8::Flag >::iterator first,std::map< std::string,Pythia8::Flag >::iterator last){ self->erase(first, last); }

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


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

      namespace swig {
	template <>  struct traits<std::map< std::string, Pythia8::Mode, std::less< std::string >, std::allocator< std::pair< std::string const,Pythia8::Mode > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::map<" "std::string" "," "Pythia8::Mode" "," "std::less< std::string >" "," "std::allocator< std::pair< std::string const,Pythia8::Mode > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__iterator(std::map< std::string,Pythia8::Mode > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Mode_Sg____nonzero__(std::map< std::string,Pythia8::Mode > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Mode_Sg____bool__(std::map< std::string,Pythia8::Mode > const *self){
      return !(self->empty());
    }
SWIGINTERN std::map< std::string,Pythia8::Mode >::size_type std_map_Sl_std_string_Sc_Pythia8_Mode_Sg____len__(std::map< std::string,Pythia8::Mode > const *self){
      return self->size();
    }
SWIGINTERN std::map< std::string,Pythia8::Mode >::mapped_type const &std_map_Sl_std_string_Sc_Pythia8_Mode_Sg____getitem__(std::map< std::string,Pythia8::Mode > *self,std::map< std::string,Pythia8::Mode >::key_type const &key){
      std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >::const_iterator i = self->find(key);
      if (i != self->end())
	return i->second;
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Mode_Sg____delitem__(std::map< std::string,Pythia8::Mode > *self,std::map< std::string,Pythia8::Mode >::key_type const &key){
      std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >::iterator i = self->find(key);
      if (i != self->end())
	self->erase(i);
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__has_key(std::map< std::string,Pythia8::Mode > const *self,std::map< std::string,Pythia8::Mode >::key_type const &key){
      std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >::const_iterator i = self->find(key);
      return i != self->end();
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__keys(std::map< std::string,Pythia8::Mode > *self){
      std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* keyList = PyList_New(pysize);
      std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(keyList, j, swig::from(i->first));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return keyList;
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__values(std::map< std::string,Pythia8::Mode > *self){
      std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* valList = PyList_New(pysize);
      std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(valList, j, swig::from(i->second));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return valList;
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__items(std::map< std::string,Pythia8::Mode > *self){
      std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }    
      PyObject* itemList = PyList_New(pysize);
      std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(itemList, j, swig::from(*i));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return itemList;
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Mode_Sg____contains__(std::map< std::string,Pythia8::Mode > *self,std::map< std::string,Pythia8::Mode >::key_type const &key){
      return self->find(key) != self->end();
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__key_iterator(std::map< std::string,Pythia8::Mode > *self,PyObject **PYTHON_SELF){
      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__value_iterator(std::map< std::string,Pythia8::Mode > *self,PyObject **PYTHON_SELF){
      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Mode_Sg____setitem____SWIG_0(std::map< std::string,Pythia8::Mode > *self,std::map< std::string,Pythia8::Mode >::key_type const &key){
      self->erase(key);
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Mode_Sg____setitem____SWIG_1(std::map< std::string,Pythia8::Mode > *self,std::map< std::string,Pythia8::Mode >::key_type const &key,std::map< std::string,Pythia8::Mode >::mapped_type const &x){
      (*self)[key] = x;
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__asdict(std::map< std::string,Pythia8::Mode > *self){
      return swig::traits_from< std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > > >::asdict(*self);
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__erase__SWIG_1(std::map< std::string,Pythia8::Mode > *self,std::map< std::string,Pythia8::Mode >::iterator position){ self->erase(position); }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__erase__SWIG_2(std::map< std::string,Pythia8::Mode > *self,std::map< std::string,Pythia8::Mode >::iterator first,std::map< std::string,Pythia8::Mode >::iterator last){ self->erase(first, last); }

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


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

      namespace swig {
	template <>  struct traits<std::map< std::string, Pythia8::Parm, std::less< std::string >, std::allocator< std::pair< std::string const,Pythia8::Parm > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::map<" "std::string" "," "Pythia8::Parm" "," "std::less< std::string >" "," "std::allocator< std::pair< std::string const,Pythia8::Parm > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__iterator(std::map< std::string,Pythia8::Parm > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Parm_Sg____nonzero__(std::map< std::string,Pythia8::Parm > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Parm_Sg____bool__(std::map< std::string,Pythia8::Parm > const *self){
      return !(self->empty());
    }
SWIGINTERN std::map< std::string,Pythia8::Parm >::size_type std_map_Sl_std_string_Sc_Pythia8_Parm_Sg____len__(std::map< std::string,Pythia8::Parm > const *self){
      return self->size();
    }
SWIGINTERN std::map< std::string,Pythia8::Parm >::mapped_type const &std_map_Sl_std_string_Sc_Pythia8_Parm_Sg____getitem__(std::map< std::string,Pythia8::Parm > *self,std::map< std::string,Pythia8::Parm >::key_type const &key){
      std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >::const_iterator i = self->find(key);
      if (i != self->end())
	return i->second;
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Parm_Sg____delitem__(std::map< std::string,Pythia8::Parm > *self,std::map< std::string,Pythia8::Parm >::key_type const &key){
      std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >::iterator i = self->find(key);
      if (i != self->end())
	self->erase(i);
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__has_key(std::map< std::string,Pythia8::Parm > const *self,std::map< std::string,Pythia8::Parm >::key_type const &key){
      std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >::const_iterator i = self->find(key);
      return i != self->end();
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__keys(std::map< std::string,Pythia8::Parm > *self){
      std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* keyList = PyList_New(pysize);
      std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(keyList, j, swig::from(i->first));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return keyList;
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__values(std::map< std::string,Pythia8::Parm > *self){
      std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* valList = PyList_New(pysize);
      std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(valList, j, swig::from(i->second));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return valList;
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__items(std::map< std::string,Pythia8::Parm > *self){
      std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }    
      PyObject* itemList = PyList_New(pysize);
      std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(itemList, j, swig::from(*i));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return itemList;
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Parm_Sg____contains__(std::map< std::string,Pythia8::Parm > *self,std::map< std::string,Pythia8::Parm >::key_type const &key){
      return self->find(key) != self->end();
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__key_iterator(std::map< std::string,Pythia8::Parm > *self,PyObject **PYTHON_SELF){
      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__value_iterator(std::map< std::string,Pythia8::Parm > *self,PyObject **PYTHON_SELF){
      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Parm_Sg____setitem____SWIG_0(std::map< std::string,Pythia8::Parm > *self,std::map< std::string,Pythia8::Parm >::key_type const &key){
      self->erase(key);
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Parm_Sg____setitem____SWIG_1(std::map< std::string,Pythia8::Parm > *self,std::map< std::string,Pythia8::Parm >::key_type const &key,std::map< std::string,Pythia8::Parm >::mapped_type const &x){
      (*self)[key] = x;
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__asdict(std::map< std::string,Pythia8::Parm > *self){
      return swig::traits_from< std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > > >::asdict(*self);
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__erase__SWIG_1(std::map< std::string,Pythia8::Parm > *self,std::map< std::string,Pythia8::Parm >::iterator position){ self->erase(position); }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__erase__SWIG_2(std::map< std::string,Pythia8::Parm > *self,std::map< std::string,Pythia8::Parm >::iterator first,std::map< std::string,Pythia8::Parm >::iterator last){ self->erase(first, last); }

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


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

      namespace swig {
	template <>  struct traits<std::map< std::string, Pythia8::Word, std::less< std::string >, std::allocator< std::pair< std::string const,Pythia8::Word > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::map<" "std::string" "," "Pythia8::Word" "," "std::less< std::string >" "," "std::allocator< std::pair< std::string const,Pythia8::Word > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_Word_Sg__iterator(std::map< std::string,Pythia8::Word > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Word_Sg____nonzero__(std::map< std::string,Pythia8::Word > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Word_Sg____bool__(std::map< std::string,Pythia8::Word > const *self){
      return !(self->empty());
    }
SWIGINTERN std::map< std::string,Pythia8::Word >::size_type std_map_Sl_std_string_Sc_Pythia8_Word_Sg____len__(std::map< std::string,Pythia8::Word > const *self){
      return self->size();
    }
SWIGINTERN std::map< std::string,Pythia8::Word >::mapped_type const &std_map_Sl_std_string_Sc_Pythia8_Word_Sg____getitem__(std::map< std::string,Pythia8::Word > *self,std::map< std::string,Pythia8::Word >::key_type const &key){
      std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >::const_iterator i = self->find(key);
      if (i != self->end())
	return i->second;
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Word_Sg____delitem__(std::map< std::string,Pythia8::Word > *self,std::map< std::string,Pythia8::Word >::key_type const &key){
      std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >::iterator i = self->find(key);
      if (i != self->end())
	self->erase(i);
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Word_Sg__has_key(std::map< std::string,Pythia8::Word > const *self,std::map< std::string,Pythia8::Word >::key_type const &key){
      std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >::const_iterator i = self->find(key);
      return i != self->end();
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Word_Sg__keys(std::map< std::string,Pythia8::Word > *self){
      std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* keyList = PyList_New(pysize);
      std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(keyList, j, swig::from(i->first));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return keyList;
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Word_Sg__values(std::map< std::string,Pythia8::Word > *self){
      std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* valList = PyList_New(pysize);
      std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(valList, j, swig::from(i->second));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return valList;
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Word_Sg__items(std::map< std::string,Pythia8::Word > *self){
      std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }    
      PyObject* itemList = PyList_New(pysize);
      std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(itemList, j, swig::from(*i));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return itemList;
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_Word_Sg____contains__(std::map< std::string,Pythia8::Word > *self,std::map< std::string,Pythia8::Word >::key_type const &key){
      return self->find(key) != self->end();
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_Word_Sg__key_iterator(std::map< std::string,Pythia8::Word > *self,PyObject **PYTHON_SELF){
      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_Word_Sg__value_iterator(std::map< std::string,Pythia8::Word > *self,PyObject **PYTHON_SELF){
      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Word_Sg____setitem____SWIG_0(std::map< std::string,Pythia8::Word > *self,std::map< std::string,Pythia8::Word >::key_type const &key){
      self->erase(key);
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Word_Sg____setitem____SWIG_1(std::map< std::string,Pythia8::Word > *self,std::map< std::string,Pythia8::Word >::key_type const &key,std::map< std::string,Pythia8::Word >::mapped_type const &x){
      (*self)[key] = x;
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_Word_Sg__asdict(std::map< std::string,Pythia8::Word > *self){
      return swig::traits_from< std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > > >::asdict(*self);
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Word_Sg__erase__SWIG_1(std::map< std::string,Pythia8::Word > *self,std::map< std::string,Pythia8::Word >::iterator position){ self->erase(position); }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_Word_Sg__erase__SWIG_2(std::map< std::string,Pythia8::Word > *self,std::map< std::string,Pythia8::Word >::iterator first,std::map< std::string,Pythia8::Word >::iterator last){ self->erase(first, last); }

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


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

      namespace swig {
	template <>  struct traits<std::map< std::string, Pythia8::FVec, std::less< std::string >, std::allocator< std::pair< std::string const,Pythia8::FVec > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::map<" "std::string" "," "Pythia8::FVec" "," "std::less< std::string >" "," "std::allocator< std::pair< std::string const,Pythia8::FVec > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__iterator(std::map< std::string,Pythia8::FVec > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_FVec_Sg____nonzero__(std::map< std::string,Pythia8::FVec > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_FVec_Sg____bool__(std::map< std::string,Pythia8::FVec > const *self){
      return !(self->empty());
    }
SWIGINTERN std::map< std::string,Pythia8::FVec >::size_type std_map_Sl_std_string_Sc_Pythia8_FVec_Sg____len__(std::map< std::string,Pythia8::FVec > const *self){
      return self->size();
    }
SWIGINTERN std::map< std::string,Pythia8::FVec >::mapped_type const &std_map_Sl_std_string_Sc_Pythia8_FVec_Sg____getitem__(std::map< std::string,Pythia8::FVec > *self,std::map< std::string,Pythia8::FVec >::key_type const &key){
      std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >::const_iterator i = self->find(key);
      if (i != self->end())
	return i->second;
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_FVec_Sg____delitem__(std::map< std::string,Pythia8::FVec > *self,std::map< std::string,Pythia8::FVec >::key_type const &key){
      std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >::iterator i = self->find(key);
      if (i != self->end())
	self->erase(i);
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__has_key(std::map< std::string,Pythia8::FVec > const *self,std::map< std::string,Pythia8::FVec >::key_type const &key){
      std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >::const_iterator i = self->find(key);
      return i != self->end();
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__keys(std::map< std::string,Pythia8::FVec > *self){
      std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* keyList = PyList_New(pysize);
      std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(keyList, j, swig::from(i->first));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return keyList;
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__values(std::map< std::string,Pythia8::FVec > *self){
      std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* valList = PyList_New(pysize);
      std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(valList, j, swig::from(i->second));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return valList;
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__items(std::map< std::string,Pythia8::FVec > *self){
      std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }    
      PyObject* itemList = PyList_New(pysize);
      std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(itemList, j, swig::from(*i));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return itemList;
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_FVec_Sg____contains__(std::map< std::string,Pythia8::FVec > *self,std::map< std::string,Pythia8::FVec >::key_type const &key){
      return self->find(key) != self->end();
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__key_iterator(std::map< std::string,Pythia8::FVec > *self,PyObject **PYTHON_SELF){
      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__value_iterator(std::map< std::string,Pythia8::FVec > *self,PyObject **PYTHON_SELF){
      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_FVec_Sg____setitem____SWIG_0(std::map< std::string,Pythia8::FVec > *self,std::map< std::string,Pythia8::FVec >::key_type const &key){
      self->erase(key);
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_FVec_Sg____setitem____SWIG_1(std::map< std::string,Pythia8::FVec > *self,std::map< std::string,Pythia8::FVec >::key_type const &key,std::map< std::string,Pythia8::FVec >::mapped_type const &x){
      (*self)[key] = x;
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__asdict(std::map< std::string,Pythia8::FVec > *self){
      return swig::traits_from< std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > > >::asdict(*self);
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__erase__SWIG_1(std::map< std::string,Pythia8::FVec > *self,std::map< std::string,Pythia8::FVec >::iterator position){ self->erase(position); }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__erase__SWIG_2(std::map< std::string,Pythia8::FVec > *self,std::map< std::string,Pythia8::FVec >::iterator first,std::map< std::string,Pythia8::FVec >::iterator last){ self->erase(first, last); }

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


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

      namespace swig {
	template <>  struct traits<std::map< std::string, Pythia8::MVec, std::less< std::string >, std::allocator< std::pair< std::string const,Pythia8::MVec > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::map<" "std::string" "," "Pythia8::MVec" "," "std::less< std::string >" "," "std::allocator< std::pair< std::string const,Pythia8::MVec > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__iterator(std::map< std::string,Pythia8::MVec > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_MVec_Sg____nonzero__(std::map< std::string,Pythia8::MVec > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_MVec_Sg____bool__(std::map< std::string,Pythia8::MVec > const *self){
      return !(self->empty());
    }
SWIGINTERN std::map< std::string,Pythia8::MVec >::size_type std_map_Sl_std_string_Sc_Pythia8_MVec_Sg____len__(std::map< std::string,Pythia8::MVec > const *self){
      return self->size();
    }
SWIGINTERN std::map< std::string,Pythia8::MVec >::mapped_type const &std_map_Sl_std_string_Sc_Pythia8_MVec_Sg____getitem__(std::map< std::string,Pythia8::MVec > *self,std::map< std::string,Pythia8::MVec >::key_type const &key){
      std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >::const_iterator i = self->find(key);
      if (i != self->end())
	return i->second;
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_MVec_Sg____delitem__(std::map< std::string,Pythia8::MVec > *self,std::map< std::string,Pythia8::MVec >::key_type const &key){
      std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >::iterator i = self->find(key);
      if (i != self->end())
	self->erase(i);
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__has_key(std::map< std::string,Pythia8::MVec > const *self,std::map< std::string,Pythia8::MVec >::key_type const &key){
      std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >::const_iterator i = self->find(key);
      return i != self->end();
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__keys(std::map< std::string,Pythia8::MVec > *self){
      std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* keyList = PyList_New(pysize);
      std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(keyList, j, swig::from(i->first));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return keyList;
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__values(std::map< std::string,Pythia8::MVec > *self){
      std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* valList = PyList_New(pysize);
      std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(valList, j, swig::from(i->second));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return valList;
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__items(std::map< std::string,Pythia8::MVec > *self){
      std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }    
      PyObject* itemList = PyList_New(pysize);
      std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(itemList, j, swig::from(*i));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return itemList;
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_MVec_Sg____contains__(std::map< std::string,Pythia8::MVec > *self,std::map< std::string,Pythia8::MVec >::key_type const &key){
      return self->find(key) != self->end();
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__key_iterator(std::map< std::string,Pythia8::MVec > *self,PyObject **PYTHON_SELF){
      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__value_iterator(std::map< std::string,Pythia8::MVec > *self,PyObject **PYTHON_SELF){
      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_MVec_Sg____setitem____SWIG_0(std::map< std::string,Pythia8::MVec > *self,std::map< std::string,Pythia8::MVec >::key_type const &key){
      self->erase(key);
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_MVec_Sg____setitem____SWIG_1(std::map< std::string,Pythia8::MVec > *self,std::map< std::string,Pythia8::MVec >::key_type const &key,std::map< std::string,Pythia8::MVec >::mapped_type const &x){
      (*self)[key] = x;
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__asdict(std::map< std::string,Pythia8::MVec > *self){
      return swig::traits_from< std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > > >::asdict(*self);
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__erase__SWIG_1(std::map< std::string,Pythia8::MVec > *self,std::map< std::string,Pythia8::MVec >::iterator position){ self->erase(position); }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__erase__SWIG_2(std::map< std::string,Pythia8::MVec > *self,std::map< std::string,Pythia8::MVec >::iterator first,std::map< std::string,Pythia8::MVec >::iterator last){ self->erase(first, last); }

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


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

      namespace swig {
	template <>  struct traits<std::map< std::string, Pythia8::PVec, std::less< std::string >, std::allocator< std::pair< std::string const,Pythia8::PVec > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::map<" "std::string" "," "Pythia8::PVec" "," "std::less< std::string >" "," "std::allocator< std::pair< std::string const,Pythia8::PVec > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__iterator(std::map< std::string,Pythia8::PVec > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_PVec_Sg____nonzero__(std::map< std::string,Pythia8::PVec > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_PVec_Sg____bool__(std::map< std::string,Pythia8::PVec > const *self){
      return !(self->empty());
    }
SWIGINTERN std::map< std::string,Pythia8::PVec >::size_type std_map_Sl_std_string_Sc_Pythia8_PVec_Sg____len__(std::map< std::string,Pythia8::PVec > const *self){
      return self->size();
    }
SWIGINTERN std::map< std::string,Pythia8::PVec >::mapped_type const &std_map_Sl_std_string_Sc_Pythia8_PVec_Sg____getitem__(std::map< std::string,Pythia8::PVec > *self,std::map< std::string,Pythia8::PVec >::key_type const &key){
      std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >::const_iterator i = self->find(key);
      if (i != self->end())
	return i->second;
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_PVec_Sg____delitem__(std::map< std::string,Pythia8::PVec > *self,std::map< std::string,Pythia8::PVec >::key_type const &key){
      std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >::iterator i = self->find(key);
      if (i != self->end())
	self->erase(i);
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__has_key(std::map< std::string,Pythia8::PVec > const *self,std::map< std::string,Pythia8::PVec >::key_type const &key){
      std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >::const_iterator i = self->find(key);
      return i != self->end();
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__keys(std::map< std::string,Pythia8::PVec > *self){
      std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* keyList = PyList_New(pysize);
      std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(keyList, j, swig::from(i->first));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return keyList;
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__values(std::map< std::string,Pythia8::PVec > *self){
      std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* valList = PyList_New(pysize);
      std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(valList, j, swig::from(i->second));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return valList;
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__items(std::map< std::string,Pythia8::PVec > *self){
      std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }    
      PyObject* itemList = PyList_New(pysize);
      std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(itemList, j, swig::from(*i));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return itemList;
    }
SWIGINTERN bool std_map_Sl_std_string_Sc_Pythia8_PVec_Sg____contains__(std::map< std::string,Pythia8::PVec > *self,std::map< std::string,Pythia8::PVec >::key_type const &key){
      return self->find(key) != self->end();
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__key_iterator(std::map< std::string,Pythia8::PVec > *self,PyObject **PYTHON_SELF){
      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__value_iterator(std::map< std::string,Pythia8::PVec > *self,PyObject **PYTHON_SELF){
      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_PVec_Sg____setitem____SWIG_0(std::map< std::string,Pythia8::PVec > *self,std::map< std::string,Pythia8::PVec >::key_type const &key){
      self->erase(key);
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_PVec_Sg____setitem____SWIG_1(std::map< std::string,Pythia8::PVec > *self,std::map< std::string,Pythia8::PVec >::key_type const &key,std::map< std::string,Pythia8::PVec >::mapped_type const &x){
      (*self)[key] = x;
    }
SWIGINTERN PyObject *std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__asdict(std::map< std::string,Pythia8::PVec > *self){
      return swig::traits_from< std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > > >::asdict(*self);
    }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__erase__SWIG_1(std::map< std::string,Pythia8::PVec > *self,std::map< std::string,Pythia8::PVec >::iterator position){ self->erase(position); }
SWIGINTERN void std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__erase__SWIG_2(std::map< std::string,Pythia8::PVec > *self,std::map< std::string,Pythia8::PVec >::iterator first,std::map< std::string,Pythia8::PVec >::iterator last){ self->erase(first, last); }

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


      namespace swig {
	template <>  struct traits<std::vector< Pythia8::Clustering, std::allocator< Pythia8::Clustering > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "Pythia8::Clustering" "," "std::allocator< Pythia8::Clustering >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Pythia8_Clustering_Sg__iterator(std::vector< Pythia8::Clustering > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_Pythia8_Clustering_Sg____nonzero__(std::vector< Pythia8::Clustering > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_Pythia8_Clustering_Sg____bool__(std::vector< Pythia8::Clustering > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< Pythia8::Clustering >::size_type std_vector_Sl_Pythia8_Clustering_Sg____len__(std::vector< Pythia8::Clustering > const *self){
      return self->size();
    }
SWIGINTERN std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > *std_vector_Sl_Pythia8_Clustering_Sg____getslice__(std::vector< Pythia8::Clustering > *self,std::vector< Pythia8::Clustering >::difference_type i,std::vector< Pythia8::Clustering >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_Pythia8_Clustering_Sg____setslice____SWIG_0(std::vector< Pythia8::Clustering > *self,std::vector< Pythia8::Clustering >::difference_type i,std::vector< Pythia8::Clustering >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >());
    }
SWIGINTERN void std_vector_Sl_Pythia8_Clustering_Sg____setslice____SWIG_1(std::vector< Pythia8::Clustering > *self,std::vector< Pythia8::Clustering >::difference_type i,std::vector< Pythia8::Clustering >::difference_type j,std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_Pythia8_Clustering_Sg____delslice__(std::vector< Pythia8::Clustering > *self,std::vector< Pythia8::Clustering >::difference_type i,std::vector< Pythia8::Clustering >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_Pythia8_Clustering_Sg____delitem____SWIG_0(std::vector< Pythia8::Clustering > *self,std::vector< Pythia8::Clustering >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > *std_vector_Sl_Pythia8_Clustering_Sg____getitem____SWIG_0(std::vector< Pythia8::Clustering > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >::difference_type id = i;
      std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_Pythia8_Clustering_Sg____setitem____SWIG_0(std::vector< Pythia8::Clustering > *self,PySliceObject *slice,std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >::difference_type id = i;
      std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_Pythia8_Clustering_Sg____setitem____SWIG_1(std::vector< Pythia8::Clustering > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >::difference_type id = i;
      std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_Pythia8_Clustering_Sg____delitem____SWIG_1(std::vector< Pythia8::Clustering > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >::difference_type id = i;
      std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< Pythia8::Clustering >::value_type const &std_vector_Sl_Pythia8_Clustering_Sg____getitem____SWIG_1(std::vector< Pythia8::Clustering > const *self,std::vector< Pythia8::Clustering >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_Pythia8_Clustering_Sg____setitem____SWIG_2(std::vector< Pythia8::Clustering > *self,std::vector< Pythia8::Clustering >::difference_type i,std::vector< Pythia8::Clustering >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< Pythia8::Clustering >::value_type std_vector_Sl_Pythia8_Clustering_Sg__pop(std::vector< Pythia8::Clustering > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_Pythia8_Clustering_Sg__append(std::vector< Pythia8::Clustering > *self,std::vector< Pythia8::Clustering >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< Pythia8::Clustering >::iterator std_vector_Sl_Pythia8_Clustering_Sg__erase__SWIG_0(std::vector< Pythia8::Clustering > *self,std::vector< Pythia8::Clustering >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< Pythia8::Clustering >::iterator std_vector_Sl_Pythia8_Clustering_Sg__erase__SWIG_1(std::vector< Pythia8::Clustering > *self,std::vector< Pythia8::Clustering >::iterator first,std::vector< Pythia8::Clustering >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< Pythia8::Clustering >::iterator std_vector_Sl_Pythia8_Clustering_Sg__insert__SWIG_0(std::vector< Pythia8::Clustering > *self,std::vector< Pythia8::Clustering >::iterator pos,std::vector< Pythia8::Clustering >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_Pythia8_Clustering_Sg__insert__SWIG_1(std::vector< Pythia8::Clustering > *self,std::vector< Pythia8::Clustering >::iterator pos,std::vector< Pythia8::Clustering >::size_type n,std::vector< Pythia8::Clustering >::value_type const &x){ self->insert(pos, n, x); }

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


      namespace swig {
	template <>  struct traits<std::vector< Pythia8::HelicityParticle, std::allocator< Pythia8::HelicityParticle > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "Pythia8::HelicityParticle" "," "std::allocator< Pythia8::HelicityParticle >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Pythia8_HelicityParticle_Sg__iterator(std::vector< Pythia8::HelicityParticle > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_Pythia8_HelicityParticle_Sg____nonzero__(std::vector< Pythia8::HelicityParticle > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_Pythia8_HelicityParticle_Sg____bool__(std::vector< Pythia8::HelicityParticle > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< Pythia8::HelicityParticle >::size_type std_vector_Sl_Pythia8_HelicityParticle_Sg____len__(std::vector< Pythia8::HelicityParticle > const *self){
      return self->size();
    }
SWIGINTERN std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *std_vector_Sl_Pythia8_HelicityParticle_Sg____getslice__(std::vector< Pythia8::HelicityParticle > *self,std::vector< Pythia8::HelicityParticle >::difference_type i,std::vector< Pythia8::HelicityParticle >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_Pythia8_HelicityParticle_Sg____setslice____SWIG_0(std::vector< Pythia8::HelicityParticle > *self,std::vector< Pythia8::HelicityParticle >::difference_type i,std::vector< Pythia8::HelicityParticle >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >());
    }
SWIGINTERN void std_vector_Sl_Pythia8_HelicityParticle_Sg____setslice____SWIG_1(std::vector< Pythia8::HelicityParticle > *self,std::vector< Pythia8::HelicityParticle >::difference_type i,std::vector< Pythia8::HelicityParticle >::difference_type j,std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_Pythia8_HelicityParticle_Sg____delslice__(std::vector< Pythia8::HelicityParticle > *self,std::vector< Pythia8::HelicityParticle >::difference_type i,std::vector< Pythia8::HelicityParticle >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_Pythia8_HelicityParticle_Sg____delitem____SWIG_0(std::vector< Pythia8::HelicityParticle > *self,std::vector< Pythia8::HelicityParticle >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *std_vector_Sl_Pythia8_HelicityParticle_Sg____getitem____SWIG_0(std::vector< Pythia8::HelicityParticle > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >::difference_type id = i;
      std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_Pythia8_HelicityParticle_Sg____setitem____SWIG_0(std::vector< Pythia8::HelicityParticle > *self,PySliceObject *slice,std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >::difference_type id = i;
      std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_Pythia8_HelicityParticle_Sg____setitem____SWIG_1(std::vector< Pythia8::HelicityParticle > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >::difference_type id = i;
      std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_Pythia8_HelicityParticle_Sg____delitem____SWIG_1(std::vector< Pythia8::HelicityParticle > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >::difference_type id = i;
      std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< Pythia8::HelicityParticle >::value_type const &std_vector_Sl_Pythia8_HelicityParticle_Sg____getitem____SWIG_1(std::vector< Pythia8::HelicityParticle > const *self,std::vector< Pythia8::HelicityParticle >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_Pythia8_HelicityParticle_Sg____setitem____SWIG_2(std::vector< Pythia8::HelicityParticle > *self,std::vector< Pythia8::HelicityParticle >::difference_type i,std::vector< Pythia8::HelicityParticle >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< Pythia8::HelicityParticle >::value_type std_vector_Sl_Pythia8_HelicityParticle_Sg__pop(std::vector< Pythia8::HelicityParticle > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_Pythia8_HelicityParticle_Sg__append(std::vector< Pythia8::HelicityParticle > *self,std::vector< Pythia8::HelicityParticle >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< Pythia8::HelicityParticle >::iterator std_vector_Sl_Pythia8_HelicityParticle_Sg__erase__SWIG_0(std::vector< Pythia8::HelicityParticle > *self,std::vector< Pythia8::HelicityParticle >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< Pythia8::HelicityParticle >::iterator std_vector_Sl_Pythia8_HelicityParticle_Sg__erase__SWIG_1(std::vector< Pythia8::HelicityParticle > *self,std::vector< Pythia8::HelicityParticle >::iterator first,std::vector< Pythia8::HelicityParticle >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< Pythia8::HelicityParticle >::iterator std_vector_Sl_Pythia8_HelicityParticle_Sg__insert__SWIG_0(std::vector< Pythia8::HelicityParticle > *self,std::vector< Pythia8::HelicityParticle >::iterator pos,std::vector< Pythia8::HelicityParticle >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_Pythia8_HelicityParticle_Sg__insert__SWIG_1(std::vector< Pythia8::HelicityParticle > *self,std::vector< Pythia8::HelicityParticle >::iterator pos,std::vector< Pythia8::HelicityParticle >::size_type n,std::vector< Pythia8::HelicityParticle >::value_type const &x){ self->insert(pos, n, x); }

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


      namespace swig {
	template <>  struct traits<std::vector< Pythia8::ProcessContainer*, std::allocator< Pythia8::ProcessContainer * > > > {
	  typedef value_category category;
	  static const char* type_name() {
	    return "std::vector<" "Pythia8::ProcessContainer" " *," "std::allocator< Pythia8::ProcessContainer * >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg__iterator(std::vector< Pythia8::ProcessContainer * > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____nonzero__(std::vector< Pythia8::ProcessContainer * > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____bool__(std::vector< Pythia8::ProcessContainer * > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< Pythia8::ProcessContainer * >::size_type std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____len__(std::vector< Pythia8::ProcessContainer * > const *self){
      return self->size();
    }
SWIGINTERN std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > *std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____getslice__(std::vector< Pythia8::ProcessContainer * > *self,std::vector< Pythia8::ProcessContainer * >::difference_type i,std::vector< Pythia8::ProcessContainer * >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____setslice____SWIG_0(std::vector< Pythia8::ProcessContainer * > *self,std::vector< Pythia8::ProcessContainer * >::difference_type i,std::vector< Pythia8::ProcessContainer * >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >());
    }
SWIGINTERN void std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____setslice____SWIG_1(std::vector< Pythia8::ProcessContainer * > *self,std::vector< Pythia8::ProcessContainer * >::difference_type i,std::vector< Pythia8::ProcessContainer * >::difference_type j,std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____delslice__(std::vector< Pythia8::ProcessContainer * > *self,std::vector< Pythia8::ProcessContainer * >::difference_type i,std::vector< Pythia8::ProcessContainer * >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____delitem____SWIG_0(std::vector< Pythia8::ProcessContainer * > *self,std::vector< Pythia8::ProcessContainer * >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > *std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____getitem____SWIG_0(std::vector< Pythia8::ProcessContainer * > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >::difference_type id = i;
      std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____setitem____SWIG_0(std::vector< Pythia8::ProcessContainer * > *self,PySliceObject *slice,std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >::difference_type id = i;
      std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____setitem____SWIG_1(std::vector< Pythia8::ProcessContainer * > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >::difference_type id = i;
      std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____delitem____SWIG_1(std::vector< Pythia8::ProcessContainer * > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >::difference_type id = i;
      std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< Pythia8::ProcessContainer * >::value_type std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____getitem____SWIG_1(std::vector< Pythia8::ProcessContainer * > *self,std::vector< Pythia8::ProcessContainer * >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____setitem____SWIG_2(std::vector< Pythia8::ProcessContainer * > *self,std::vector< Pythia8::ProcessContainer * >::difference_type i,std::vector< Pythia8::ProcessContainer * >::value_type x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< Pythia8::ProcessContainer * >::value_type std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg__pop(std::vector< Pythia8::ProcessContainer * > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg__append(std::vector< Pythia8::ProcessContainer * > *self,std::vector< Pythia8::ProcessContainer * >::value_type x){
      self->push_back(x);
    }
SWIGINTERN std::vector< Pythia8::ProcessContainer * >::iterator std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg__erase__SWIG_0(std::vector< Pythia8::ProcessContainer * > *self,std::vector< Pythia8::ProcessContainer * >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< Pythia8::ProcessContainer * >::iterator std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg__erase__SWIG_1(std::vector< Pythia8::ProcessContainer * > *self,std::vector< Pythia8::ProcessContainer * >::iterator first,std::vector< Pythia8::ProcessContainer * >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< Pythia8::ProcessContainer * >::iterator std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg__insert__SWIG_0(std::vector< Pythia8::ProcessContainer * > *self,std::vector< Pythia8::ProcessContainer * >::iterator pos,std::vector< Pythia8::ProcessContainer * >::value_type x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg__insert__SWIG_1(std::vector< Pythia8::ProcessContainer * > *self,std::vector< Pythia8::ProcessContainer * >::iterator pos,std::vector< Pythia8::ProcessContainer * >::size_type n,std::vector< Pythia8::ProcessContainer * >::value_type x){ self->insert(pos, n, x); }

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


      namespace swig {
	template <>  struct traits<std::vector< Pythia8::ResonanceWidths*, std::allocator< Pythia8::ResonanceWidths * > > > {
	  typedef value_category category;
	  static const char* type_name() {
	    return "std::vector<" "Pythia8::ResonanceWidths" " *," "std::allocator< Pythia8::ResonanceWidths * >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg__iterator(std::vector< Pythia8::ResonanceWidths * > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____nonzero__(std::vector< Pythia8::ResonanceWidths * > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____bool__(std::vector< Pythia8::ResonanceWidths * > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< Pythia8::ResonanceWidths * >::size_type std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____len__(std::vector< Pythia8::ResonanceWidths * > const *self){
      return self->size();
    }
SWIGINTERN std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > *std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____getslice__(std::vector< Pythia8::ResonanceWidths * > *self,std::vector< Pythia8::ResonanceWidths * >::difference_type i,std::vector< Pythia8::ResonanceWidths * >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____setslice____SWIG_0(std::vector< Pythia8::ResonanceWidths * > *self,std::vector< Pythia8::ResonanceWidths * >::difference_type i,std::vector< Pythia8::ResonanceWidths * >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >());
    }
SWIGINTERN void std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____setslice____SWIG_1(std::vector< Pythia8::ResonanceWidths * > *self,std::vector< Pythia8::ResonanceWidths * >::difference_type i,std::vector< Pythia8::ResonanceWidths * >::difference_type j,std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____delslice__(std::vector< Pythia8::ResonanceWidths * > *self,std::vector< Pythia8::ResonanceWidths * >::difference_type i,std::vector< Pythia8::ResonanceWidths * >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____delitem____SWIG_0(std::vector< Pythia8::ResonanceWidths * > *self,std::vector< Pythia8::ResonanceWidths * >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > *std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____getitem____SWIG_0(std::vector< Pythia8::ResonanceWidths * > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >::difference_type id = i;
      std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____setitem____SWIG_0(std::vector< Pythia8::ResonanceWidths * > *self,PySliceObject *slice,std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >::difference_type id = i;
      std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____setitem____SWIG_1(std::vector< Pythia8::ResonanceWidths * > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >::difference_type id = i;
      std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____delitem____SWIG_1(std::vector< Pythia8::ResonanceWidths * > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >::difference_type id = i;
      std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< Pythia8::ResonanceWidths * >::value_type std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____getitem____SWIG_1(std::vector< Pythia8::ResonanceWidths * > *self,std::vector< Pythia8::ResonanceWidths * >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____setitem____SWIG_2(std::vector< Pythia8::ResonanceWidths * > *self,std::vector< Pythia8::ResonanceWidths * >::difference_type i,std::vector< Pythia8::ResonanceWidths * >::value_type x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< Pythia8::ResonanceWidths * >::value_type std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg__pop(std::vector< Pythia8::ResonanceWidths * > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg__append(std::vector< Pythia8::ResonanceWidths * > *self,std::vector< Pythia8::ResonanceWidths * >::value_type x){
      self->push_back(x);
    }
SWIGINTERN std::vector< Pythia8::ResonanceWidths * >::iterator std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg__erase__SWIG_0(std::vector< Pythia8::ResonanceWidths * > *self,std::vector< Pythia8::ResonanceWidths * >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< Pythia8::ResonanceWidths * >::iterator std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg__erase__SWIG_1(std::vector< Pythia8::ResonanceWidths * > *self,std::vector< Pythia8::ResonanceWidths * >::iterator first,std::vector< Pythia8::ResonanceWidths * >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< Pythia8::ResonanceWidths * >::iterator std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg__insert__SWIG_0(std::vector< Pythia8::ResonanceWidths * > *self,std::vector< Pythia8::ResonanceWidths * >::iterator pos,std::vector< Pythia8::ResonanceWidths * >::value_type x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg__insert__SWIG_1(std::vector< Pythia8::ResonanceWidths * > *self,std::vector< Pythia8::ResonanceWidths * >::iterator pos,std::vector< Pythia8::ResonanceWidths * >::size_type n,std::vector< Pythia8::ResonanceWidths * >::value_type x){ self->insert(pos, n, x); }

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


      namespace swig {
	template <>  struct traits<std::vector< Pythia8::SigmaProcess*, std::allocator< Pythia8::SigmaProcess * > > > {
	  typedef value_category category;
	  static const char* type_name() {
	    return "std::vector<" "Pythia8::SigmaProcess" " *," "std::allocator< Pythia8::SigmaProcess * >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg__iterator(std::vector< Pythia8::SigmaProcess * > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____nonzero__(std::vector< Pythia8::SigmaProcess * > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____bool__(std::vector< Pythia8::SigmaProcess * > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< Pythia8::SigmaProcess * >::size_type std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____len__(std::vector< Pythia8::SigmaProcess * > const *self){
      return self->size();
    }
SWIGINTERN std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > *std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____getslice__(std::vector< Pythia8::SigmaProcess * > *self,std::vector< Pythia8::SigmaProcess * >::difference_type i,std::vector< Pythia8::SigmaProcess * >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____setslice____SWIG_0(std::vector< Pythia8::SigmaProcess * > *self,std::vector< Pythia8::SigmaProcess * >::difference_type i,std::vector< Pythia8::SigmaProcess * >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >());
    }
SWIGINTERN void std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____setslice____SWIG_1(std::vector< Pythia8::SigmaProcess * > *self,std::vector< Pythia8::SigmaProcess * >::difference_type i,std::vector< Pythia8::SigmaProcess * >::difference_type j,std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____delslice__(std::vector< Pythia8::SigmaProcess * > *self,std::vector< Pythia8::SigmaProcess * >::difference_type i,std::vector< Pythia8::SigmaProcess * >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____delitem____SWIG_0(std::vector< Pythia8::SigmaProcess * > *self,std::vector< Pythia8::SigmaProcess * >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > *std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____getitem____SWIG_0(std::vector< Pythia8::SigmaProcess * > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >::difference_type id = i;
      std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____setitem____SWIG_0(std::vector< Pythia8::SigmaProcess * > *self,PySliceObject *slice,std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >::difference_type id = i;
      std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____setitem____SWIG_1(std::vector< Pythia8::SigmaProcess * > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >::difference_type id = i;
      std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____delitem____SWIG_1(std::vector< Pythia8::SigmaProcess * > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >::difference_type id = i;
      std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< Pythia8::SigmaProcess * >::value_type std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____getitem____SWIG_1(std::vector< Pythia8::SigmaProcess * > *self,std::vector< Pythia8::SigmaProcess * >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____setitem____SWIG_2(std::vector< Pythia8::SigmaProcess * > *self,std::vector< Pythia8::SigmaProcess * >::difference_type i,std::vector< Pythia8::SigmaProcess * >::value_type x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< Pythia8::SigmaProcess * >::value_type std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg__pop(std::vector< Pythia8::SigmaProcess * > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg__append(std::vector< Pythia8::SigmaProcess * > *self,std::vector< Pythia8::SigmaProcess * >::value_type x){
      self->push_back(x);
    }
SWIGINTERN std::vector< Pythia8::SigmaProcess * >::iterator std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg__erase__SWIG_0(std::vector< Pythia8::SigmaProcess * > *self,std::vector< Pythia8::SigmaProcess * >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< Pythia8::SigmaProcess * >::iterator std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg__erase__SWIG_1(std::vector< Pythia8::SigmaProcess * > *self,std::vector< Pythia8::SigmaProcess * >::iterator first,std::vector< Pythia8::SigmaProcess * >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< Pythia8::SigmaProcess * >::iterator std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg__insert__SWIG_0(std::vector< Pythia8::SigmaProcess * > *self,std::vector< Pythia8::SigmaProcess * >::iterator pos,std::vector< Pythia8::SigmaProcess * >::value_type x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg__insert__SWIG_1(std::vector< Pythia8::SigmaProcess * > *self,std::vector< Pythia8::SigmaProcess * >::iterator pos,std::vector< Pythia8::SigmaProcess * >::size_type n,std::vector< Pythia8::SigmaProcess * >::value_type x){ self->insert(pos, n, x); }

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


      namespace swig {
	template <>  struct traits<std::vector< Pythia8::Vec4, std::allocator< Pythia8::Vec4 > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "Pythia8::Vec4" "," "std::allocator< Pythia8::Vec4 >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Pythia8_Vec4_Sg__iterator(std::vector< Pythia8::Vec4 > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_Pythia8_Vec4_Sg____nonzero__(std::vector< Pythia8::Vec4 > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_Pythia8_Vec4_Sg____bool__(std::vector< Pythia8::Vec4 > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< Pythia8::Vec4 >::size_type std_vector_Sl_Pythia8_Vec4_Sg____len__(std::vector< Pythia8::Vec4 > const *self){
      return self->size();
    }
SWIGINTERN std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > *std_vector_Sl_Pythia8_Vec4_Sg____getslice__(std::vector< Pythia8::Vec4 > *self,std::vector< Pythia8::Vec4 >::difference_type i,std::vector< Pythia8::Vec4 >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_Pythia8_Vec4_Sg____setslice____SWIG_0(std::vector< Pythia8::Vec4 > *self,std::vector< Pythia8::Vec4 >::difference_type i,std::vector< Pythia8::Vec4 >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >());
    }
SWIGINTERN void std_vector_Sl_Pythia8_Vec4_Sg____setslice____SWIG_1(std::vector< Pythia8::Vec4 > *self,std::vector< Pythia8::Vec4 >::difference_type i,std::vector< Pythia8::Vec4 >::difference_type j,std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_Pythia8_Vec4_Sg____delslice__(std::vector< Pythia8::Vec4 > *self,std::vector< Pythia8::Vec4 >::difference_type i,std::vector< Pythia8::Vec4 >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_Pythia8_Vec4_Sg____delitem____SWIG_0(std::vector< Pythia8::Vec4 > *self,std::vector< Pythia8::Vec4 >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > *std_vector_Sl_Pythia8_Vec4_Sg____getitem____SWIG_0(std::vector< Pythia8::Vec4 > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >::difference_type id = i;
      std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_Pythia8_Vec4_Sg____setitem____SWIG_0(std::vector< Pythia8::Vec4 > *self,PySliceObject *slice,std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >::difference_type id = i;
      std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_Pythia8_Vec4_Sg____setitem____SWIG_1(std::vector< Pythia8::Vec4 > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >::difference_type id = i;
      std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_Pythia8_Vec4_Sg____delitem____SWIG_1(std::vector< Pythia8::Vec4 > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >::difference_type id = i;
      std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< Pythia8::Vec4 >::value_type const &std_vector_Sl_Pythia8_Vec4_Sg____getitem____SWIG_1(std::vector< Pythia8::Vec4 > const *self,std::vector< Pythia8::Vec4 >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_Pythia8_Vec4_Sg____setitem____SWIG_2(std::vector< Pythia8::Vec4 > *self,std::vector< Pythia8::Vec4 >::difference_type i,std::vector< Pythia8::Vec4 >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< Pythia8::Vec4 >::value_type std_vector_Sl_Pythia8_Vec4_Sg__pop(std::vector< Pythia8::Vec4 > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_Pythia8_Vec4_Sg__append(std::vector< Pythia8::Vec4 > *self,std::vector< Pythia8::Vec4 >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< Pythia8::Vec4 >::iterator std_vector_Sl_Pythia8_Vec4_Sg__erase__SWIG_0(std::vector< Pythia8::Vec4 > *self,std::vector< Pythia8::Vec4 >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< Pythia8::Vec4 >::iterator std_vector_Sl_Pythia8_Vec4_Sg__erase__SWIG_1(std::vector< Pythia8::Vec4 > *self,std::vector< Pythia8::Vec4 >::iterator first,std::vector< Pythia8::Vec4 >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< Pythia8::Vec4 >::iterator std_vector_Sl_Pythia8_Vec4_Sg__insert__SWIG_0(std::vector< Pythia8::Vec4 > *self,std::vector< Pythia8::Vec4 >::iterator pos,std::vector< Pythia8::Vec4 >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_Pythia8_Vec4_Sg__insert__SWIG_1(std::vector< Pythia8::Vec4 > *self,std::vector< Pythia8::Vec4 >::iterator pos,std::vector< Pythia8::Vec4 >::size_type n,std::vector< Pythia8::Vec4 >::value_type const &x){ self->insert(pos, n, x); }


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

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

#ifndef SWIG_pythia8_WRAP_H_
#define SWIG_pythia8_WRAP_H_

#include <map>
#include <string>


class SwigDirector_RndmEngine : public Pythia8::RndmEngine, public Swig::Director {

public:
    SwigDirector_RndmEngine(PyObject *self);
    virtual ~SwigDirector_RndmEngine();
    virtual double flat();

/* Internal director utilities */
public:
    bool swig_get_inner(const char *swig_protected_method_name) const {
      std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
      return (iv != swig_inner.end() ? iv->second : false);
    }
    void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
      swig_inner[swig_protected_method_name] = swig_val;
    }
private:
    mutable std::map<std::string, bool> swig_inner;

#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
/* VTable implementation */
    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
      PyObject *method = vtable[method_index];
      if (!method) {
        swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
        method = PyObject_GetAttr(swig_get_self(), name);
        if (!method) {
          std::string msg = "Method in class RndmEngine doesn't exist, undefined ";
          msg += method_name;
          Swig::DirectorMethodException::raise(msg.c_str());
        }
        vtable[method_index] = method;
      }
      return method;
    }
private:
    mutable swig::SwigVar_PyObject vtable[1];
#endif

};


class SwigDirector_BeamShape : public Pythia8::BeamShape, public Swig::Director {

public:
    SwigDirector_BeamShape(PyObject *self);
    virtual ~SwigDirector_BeamShape();
    virtual void init(Pythia8::Settings &settings, Pythia8::Rndm *rndmPtrIn);
    virtual void pick();
    using Pythia8::BeamShape::deltaPxA;
    using Pythia8::BeamShape::deltaPyA;
    using Pythia8::BeamShape::deltaPzA;
    using Pythia8::BeamShape::deltaPxB;
    using Pythia8::BeamShape::deltaPyB;
    using Pythia8::BeamShape::deltaPzB;
    using Pythia8::BeamShape::vertexX;
    using Pythia8::BeamShape::vertexY;
    using Pythia8::BeamShape::vertexZ;
    using Pythia8::BeamShape::vertexT;
    using Pythia8::BeamShape::allowMomentumSpread;
    using Pythia8::BeamShape::allowVertexSpread;
    using Pythia8::BeamShape::sigmaPxA;
    using Pythia8::BeamShape::sigmaPyA;
    using Pythia8::BeamShape::sigmaPzA;
    using Pythia8::BeamShape::maxDevA;
    using Pythia8::BeamShape::sigmaPxB;
    using Pythia8::BeamShape::sigmaPyB;
    using Pythia8::BeamShape::sigmaPzB;
    using Pythia8::BeamShape::maxDevB;
    using Pythia8::BeamShape::sigmaVertexX;
    using Pythia8::BeamShape::sigmaVertexY;
    using Pythia8::BeamShape::sigmaVertexZ;
    using Pythia8::BeamShape::maxDevVertex;
    using Pythia8::BeamShape::sigmaTime;
    using Pythia8::BeamShape::maxDevTime;
    using Pythia8::BeamShape::offsetX;
    using Pythia8::BeamShape::offsetY;
    using Pythia8::BeamShape::offsetZ;
    using Pythia8::BeamShape::offsetT;
    using Pythia8::BeamShape::rndmPtr;

/* Internal director utilities */
public:
    bool swig_get_inner(const char *swig_protected_method_name) const {
      std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
      return (iv != swig_inner.end() ? iv->second : false);
    }
    void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
      swig_inner[swig_protected_method_name] = swig_val;
    }
private:
    mutable std::map<std::string, bool> swig_inner;

#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
/* VTable implementation */
    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
      PyObject *method = vtable[method_index];
      if (!method) {
        swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
        method = PyObject_GetAttr(swig_get_self(), name);
        if (!method) {
          std::string msg = "Method in class BeamShape doesn't exist, undefined ";
          msg += method_name;
          Swig::DirectorMethodException::raise(msg.c_str());
        }
        vtable[method_index] = method;
      }
      return method;
    }
private:
    mutable swig::SwigVar_PyObject vtable[2];
#endif

};


class SwigDirector_PDF : public Pythia8::PDF, public Swig::Director {

public:
    SwigDirector_PDF(PyObject *self, int idBeamIn = 2212);
    virtual ~SwigDirector_PDF();
    virtual bool isSetup();
    virtual void newValenceContent(int idVal1In, int idVal2In);
    virtual void setExtrapolate(bool arg0);
    virtual double xf(int id, double x, double Q2);
    virtual double xfVal(int id, double x, double Q2);
    virtual double xfSea(int id, double x, double Q2);
    virtual bool insideBounds(double arg0, double arg1);
    virtual double alphaS(double arg0);
    virtual double mQuarkPDF(int arg0);
    virtual int nMembers();
    virtual void calcPDFEnvelope(int arg0, double arg1, double arg2, int arg3);
    virtual void calcPDFEnvelope(std::pair< int,int > arg0, std::pair< double,double > arg1, double arg2, int arg3);
    virtual Pythia8::PDF::PDFEnvelope getPDFEnvelope();
    virtual double gammaPDFxDependence(int arg0, double arg1);
    virtual double gammaPDFRefScale(int arg0);
    virtual int sampleGammaValFlavor(double arg0);
    virtual double xfIntegratedTotal(double arg0);
    virtual double xGamma();
    virtual void xPom(double arg0 = -1.0);
    virtual double xfFlux(int arg0, double arg1, double arg2);
    virtual double xfApprox(int arg0, double arg1, double arg2);
    virtual double xfGamma(int arg0, double arg1, double arg2);
    virtual double getQ2min();
    virtual double getXmin();
    virtual double getXhadr();
    virtual double getGammaFluxNorm();
    virtual double sampleXgamma(double arg0);
    virtual double sampleQ2gamma(double arg0);
    virtual double xfMax(int id, double x, double Q2);
    virtual double xfSame(int id, double x, double Q2);
    virtual void setVMDscale(double arg0 = 1.);
    virtual void xfUpdate(int id, double x, double Q2);
    using Pythia8::PDF::idBeam;
    using Pythia8::PDF::idBeamAbs;
    using Pythia8::PDF::idSav;
    using Pythia8::PDF::idVal1;
    using Pythia8::PDF::idVal2;
    using Pythia8::PDF::xSav;
    using Pythia8::PDF::Q2Sav;
    using Pythia8::PDF::xu;
    using Pythia8::PDF::xd;
    using Pythia8::PDF::xs;
    using Pythia8::PDF::xubar;
    using Pythia8::PDF::xdbar;
    using Pythia8::PDF::xsbar;
    using Pythia8::PDF::xc;
    using Pythia8::PDF::xb;
    using Pythia8::PDF::xg;
    using Pythia8::PDF::xlepton;
    using Pythia8::PDF::xgamma;
    using Pythia8::PDF::xuVal;
    using Pythia8::PDF::xuSea;
    using Pythia8::PDF::xdVal;
    using Pythia8::PDF::xdSea;
    using Pythia8::PDF::isSet;
    using Pythia8::PDF::isInit;
    using Pythia8::PDF::xsVal;
    using Pythia8::PDF::xcVal;
    using Pythia8::PDF::xbVal;
    using Pythia8::PDF::xsSea;
    using Pythia8::PDF::xcSea;
    using Pythia8::PDF::xbSea;
    using Pythia8::PDF::hasGammaInLepton;
    using Pythia8::PDF::setValenceContent;
    using Pythia8::PDF::printErr;

/* Internal director utilities */
public:
    bool swig_get_inner(const char *swig_protected_method_name) const {
      std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
      return (iv != swig_inner.end() ? iv->second : false);
    }
    void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
      swig_inner[swig_protected_method_name] = swig_val;
    }
private:
    mutable std::map<std::string, bool> swig_inner;

#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
/* VTable implementation */
    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
      PyObject *method = vtable[method_index];
      if (!method) {
        swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
        method = PyObject_GetAttr(swig_get_self(), name);
        if (!method) {
          std::string msg = "Method in class PDF doesn't exist, undefined ";
          msg += method_name;
          Swig::DirectorMethodException::raise(msg.c_str());
        }
        vtable[method_index] = method;
      }
      return method;
    }
private:
    mutable swig::SwigVar_PyObject vtable[34];
#endif

};


class SwigDirector_ResonanceWidths : public Pythia8::ResonanceWidths, public Swig::Director {

public:
    SwigDirector_ResonanceWidths(PyObject *self);
    virtual ~SwigDirector_ResonanceWidths();
    virtual bool init(Pythia8::Info *infoPtrIn, Pythia8::Settings *settingsPtrIn, Pythia8::ParticleData *particleDataPtrIn, Pythia8::Couplings *couplingsPtrIn);
    virtual void initConstants();
    virtual void initConstantsSwigPublic() {
      Pythia8::ResonanceWidths::initConstants();
    }
    virtual bool initBSM();
    virtual bool initBSMSwigPublic() {
      return Pythia8::ResonanceWidths::initBSM();
    }
    virtual bool allowCalc();
    virtual bool allowCalcSwigPublic() {
      return Pythia8::ResonanceWidths::allowCalc();
    }
    virtual void calcPreFac(bool arg0 = false);
    virtual void calcPreFacSwigPublic(bool arg0 = false) {
      Pythia8::ResonanceWidths::calcPreFac(arg0);
    }
    virtual void calcWidth(bool arg0 = false);
    virtual void calcWidthSwigPublic(bool arg0 = false) {
      Pythia8::ResonanceWidths::calcWidth(arg0);
    }
    using Pythia8::ResonanceWidths::NPOINT;
    using Pythia8::ResonanceWidths::MASSMIN;
    using Pythia8::ResonanceWidths::MASSMARGIN;
    using Pythia8::ResonanceWidths::idRes;
    using Pythia8::ResonanceWidths::hasAntiRes;
    using Pythia8::ResonanceWidths::doForceWidth;
    using Pythia8::ResonanceWidths::isGeneric;
    using Pythia8::ResonanceWidths::allowCalcWidth;
    using Pythia8::ResonanceWidths::minWidth;
    using Pythia8::ResonanceWidths::minThreshold;
    using Pythia8::ResonanceWidths::mRes;
    using Pythia8::ResonanceWidths::GammaRes;
    using Pythia8::ResonanceWidths::m2Res;
    using Pythia8::ResonanceWidths::GamMRat;
    using Pythia8::ResonanceWidths::openPos;
    using Pythia8::ResonanceWidths::openNeg;
    using Pythia8::ResonanceWidths::forceFactor;
    using Pythia8::ResonanceWidths::iChannel;
    using Pythia8::ResonanceWidths::onMode;
    using Pythia8::ResonanceWidths::meMode;
    using Pythia8::ResonanceWidths::mult;
    using Pythia8::ResonanceWidths::id1;
    using Pythia8::ResonanceWidths::id2;
    using Pythia8::ResonanceWidths::id3;
    using Pythia8::ResonanceWidths::id1Abs;
    using Pythia8::ResonanceWidths::id2Abs;
    using Pythia8::ResonanceWidths::id3Abs;
    using Pythia8::ResonanceWidths::idInFlav;
    using Pythia8::ResonanceWidths::widNow;
    using Pythia8::ResonanceWidths::mHat;
    using Pythia8::ResonanceWidths::mf1;
    using Pythia8::ResonanceWidths::mf2;
    using Pythia8::ResonanceWidths::mf3;
    using Pythia8::ResonanceWidths::mr1;
    using Pythia8::ResonanceWidths::mr2;
    using Pythia8::ResonanceWidths::mr3;
    using Pythia8::ResonanceWidths::ps;
    using Pythia8::ResonanceWidths::kinFac;
    using Pythia8::ResonanceWidths::alpEM;
    using Pythia8::ResonanceWidths::alpS;
    using Pythia8::ResonanceWidths::colQ;
    using Pythia8::ResonanceWidths::preFac;
    using Pythia8::ResonanceWidths::particlePtr;
    using Pythia8::ResonanceWidths::infoPtr;
    using Pythia8::ResonanceWidths::settingsPtr;
    using Pythia8::ResonanceWidths::particleDataPtr;
    using Pythia8::ResonanceWidths::couplingsPtr;
    using Pythia8::ResonanceWidths::numInt1BW;
    using Pythia8::ResonanceWidths::numInt2BW;

/* Internal director utilities */
public:
    bool swig_get_inner(const char *swig_protected_method_name) const {
      std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
      return (iv != swig_inner.end() ? iv->second : false);
    }
    void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
      swig_inner[swig_protected_method_name] = swig_val;
    }
private:
    mutable std::map<std::string, bool> swig_inner;

#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
/* VTable implementation */
    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
      PyObject *method = vtable[method_index];
      if (!method) {
        swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
        method = PyObject_GetAttr(swig_get_self(), name);
        if (!method) {
          std::string msg = "Method in class ResonanceWidths doesn't exist, undefined ";
          msg += method_name;
          Swig::DirectorMethodException::raise(msg.c_str());
        }
        vtable[method_index] = method;
      }
      return method;
    }
private:
    mutable swig::SwigVar_PyObject vtable[8];
#endif

};


class SwigDirector_LHAup : public Pythia8::LHAup, public Swig::Director {

public:
    SwigDirector_LHAup(PyObject *self, int strategyIn = 3);
    virtual ~SwigDirector_LHAup();
    virtual void newEventFile(char const *arg0);
    virtual bool fileFound();
    virtual bool useExternal();
    virtual bool setInit();
    virtual bool setEvent(int idProcIn = 0);
    virtual bool skipEvent(int nSkip);
    virtual bool openLHEF(std::string fileNameIn);
    virtual bool closeLHEF(bool updateInit = false);
    using Pythia8::LHAup::CONVERTMB2PB;
    using Pythia8::LHAup::infoPtr;
    using Pythia8::LHAup::setBeamA;
    using Pythia8::LHAup::setBeamB;
    using Pythia8::LHAup::setStrategy;
    using Pythia8::LHAup::addProcess;
    using Pythia8::LHAup::setXSec;
    using Pythia8::LHAup::setXErr;
    using Pythia8::LHAup::setXMax;
    using Pythia8::LHAup::setProcess;
    using Pythia8::LHAup::addParticle;
    using Pythia8::LHAup::setIdX;
    using Pythia8::LHAup::setPdf;
    using Pythia8::LHAup::setInitLHEF;
    using Pythia8::LHAup::setNewEventLHEF;
    using Pythia8::LHAup::setOldEventLHEF;
    using Pythia8::LHAup::openFile;
    using Pythia8::LHAup::closeFile;
    using Pythia8::LHAup::setInfoHeader;
    using Pythia8::LHAup::nupSave;
    using Pythia8::LHAup::idprupSave;
    using Pythia8::LHAup::xwgtupSave;
    using Pythia8::LHAup::scalupSave;
    using Pythia8::LHAup::aqedupSave;
    using Pythia8::LHAup::aqcdupSave;
    using Pythia8::LHAup::xSecSumSave;
    using Pythia8::LHAup::xErrSumSave;
    using Pythia8::LHAup::particlesSave;
    using Pythia8::LHAup::getPDFSave;
    using Pythia8::LHAup::getScale;
    using Pythia8::LHAup::id1InSave;
    using Pythia8::LHAup::id2InSave;
    using Pythia8::LHAup::id1pdfInSave;
    using Pythia8::LHAup::id2pdfInSave;
    using Pythia8::LHAup::x1InSave;
    using Pythia8::LHAup::x2InSave;
    using Pythia8::LHAup::x1pdfInSave;
    using Pythia8::LHAup::x2pdfInSave;
    using Pythia8::LHAup::scalePDFInSave;
    using Pythia8::LHAup::pdf1InSave;
    using Pythia8::LHAup::pdf2InSave;
    using Pythia8::LHAup::fileName;
    using Pythia8::LHAup::dateNow;
    using Pythia8::LHAup::timeNow;

/* Internal director utilities */
public:
    bool swig_get_inner(const char *swig_protected_method_name) const {
      std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
      return (iv != swig_inner.end() ? iv->second : false);
    }
    void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
      swig_inner[swig_protected_method_name] = swig_val;
    }
private:
    mutable std::map<std::string, bool> swig_inner;

#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
/* VTable implementation */
    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
      PyObject *method = vtable[method_index];
      if (!method) {
        swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
        method = PyObject_GetAttr(swig_get_self(), name);
        if (!method) {
          std::string msg = "Method in class LHAup doesn't exist, undefined ";
          msg += method_name;
          Swig::DirectorMethodException::raise(msg.c_str());
        }
        vtable[method_index] = method;
      }
      return method;
    }
private:
    mutable swig::SwigVar_PyObject vtable[10];
#endif

};


class SwigDirector_MergingHooks : public Pythia8::MergingHooks, public Swig::Director {

public:
    SwigDirector_MergingHooks(PyObject *self);
    virtual ~SwigDirector_MergingHooks();
    virtual double tmsDefinition(Pythia8::Event const &event);
    virtual double dampenIfFailCuts(Pythia8::Event const &inEvent);
    virtual bool canCutOnRecState();
    virtual bool doCutOnRecState(Pythia8::Event const &event);
    virtual bool canVetoTrialEmission();
    virtual bool doVetoTrialEmission(Pythia8::Event const &arg0, Pythia8::Event const &arg1);
    virtual double hardProcessME(Pythia8::Event const &inEvent);
    virtual void init();
    virtual int getNumberOfClusteringSteps(Pythia8::Event const &event, bool resetNjetMax = false);
    virtual double tmsNow(Pythia8::Event const &event);
    virtual bool canVetoEmission();
    virtual bool doVetoEmission(Pythia8::Event const &arg0);
    virtual bool useShowerPlugin();
    virtual bool canVetoStep();
    virtual bool doVetoStep(Pythia8::Event const &process, Pythia8::Event const &event, bool doResonance = false);
    virtual bool setShowerStartingScales(bool isTrial, bool doMergeFirstEmm, double &pTscaleIn, Pythia8::Event const &event, double &pTmaxFSRIn, bool &limitPTmaxFSRin, double &pTmaxISRIn, bool &limitPTmaxISRin, double &pTmaxMPIIn, bool &limitPTmaxMPIin);

/* Internal director utilities */
public:
    bool swig_get_inner(const char *swig_protected_method_name) const {
      std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
      return (iv != swig_inner.end() ? iv->second : false);
    }
    void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
      swig_inner[swig_protected_method_name] = swig_val;
    }
private:
    mutable std::map<std::string, bool> swig_inner;

#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
/* VTable implementation */
    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
      PyObject *method = vtable[method_index];
      if (!method) {
        swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
        method = PyObject_GetAttr(swig_get_self(), name);
        if (!method) {
          std::string msg = "Method in class MergingHooks doesn't exist, undefined ";
          msg += method_name;
          Swig::DirectorMethodException::raise(msg.c_str());
        }
        vtable[method_index] = method;
      }
      return method;
    }
private:
    mutable swig::SwigVar_PyObject vtable[18];
#endif

};


class SwigDirector_SigmaProcess : public Pythia8::SigmaProcess, public Swig::Director {

public:
    SwigDirector_SigmaProcess(PyObject *self);
    virtual ~SwigDirector_SigmaProcess();
    virtual void initProc();
    virtual bool initFlux();
    virtual void set1Kin(double arg0, double arg1, double arg2);
    virtual void set2Kin(double arg0, double arg1, double arg2, double arg3, double arg4, double arg5, double arg6, double arg7);
    virtual void set2KinMPI(double arg0, double arg1, double arg2, double arg3, double arg4, double arg5, double arg6, bool arg7, double arg8, double arg9);
    virtual void set3Kin(double arg0, double arg1, double arg2, Pythia8::Vec4 arg3, Pythia8::Vec4 arg4, Pythia8::Vec4 arg5, double arg6, double arg7, double arg8, double arg9, double arg10, double arg11);
    virtual void sigmaKin();
    virtual double sigmaHat();
    virtual double sigmaHatWrap(int id1in = 0, int id2in = 0);
    virtual double sigmaPDF(bool initPS = false, bool samexGamma = false, bool useNewXvalues = false, double x1New = 0., double x2New = 0.);
    virtual void setIdColAcol();
    virtual bool final2KinMPI(int arg0 = 0, int arg1 = 0, Pythia8::Vec4 arg2 = 0., Pythia8::Vec4 arg3 = 0., double arg4 = 0., double arg5 = 0.);
    virtual double weightDecayFlav(Pythia8::Event &arg0);
    virtual double weightDecay(Pythia8::Event &arg0, int arg1, int arg2);
    virtual void setScale();
    virtual std::string name() const;
    virtual int code() const;
    virtual int nFinal() const;
    virtual std::string inFlux() const;
    virtual bool convert2mb() const;
    virtual bool convertM2() const;
    virtual bool isLHA() const;
    virtual bool isNonDiff() const;
    virtual bool isResolved() const;
    virtual bool isDiffA() const;
    virtual bool isDiffB() const;
    virtual bool isDiffC() const;
    virtual bool isSUSY() const;
    virtual bool allowNegativeSigma() const;
    virtual int id3Mass() const;
    virtual int id4Mass() const;
    virtual int id5Mass() const;
    virtual int resonanceA() const;
    virtual int resonanceB() const;
    virtual bool isSChannel() const;
    virtual int idSChannel() const;
    virtual bool isQCD3body() const;
    virtual int idTchan1() const;
    virtual int idTchan2() const;
    virtual double tChanFracPow1() const;
    virtual double tChanFracPow2() const;
    virtual bool useMirrorWeight() const;
    virtual int gmZmode() const;
    virtual bool setupForME();
    virtual bool setupForMESwigPublic() {
      return Pythia8::SigmaProcess::setupForME();
    }
    using Pythia8::SigmaProcess::CONVERT2MB;
    using Pythia8::SigmaProcess::MASSMARGIN;
    using Pythia8::SigmaProcess::COMPRELERR;
    using Pythia8::SigmaProcess::NCOMPSTEP;
    using Pythia8::SigmaProcess::infoPtr;
    using Pythia8::SigmaProcess::settingsPtr;
    using Pythia8::SigmaProcess::particleDataPtr;
    using Pythia8::SigmaProcess::rndmPtr;
    using Pythia8::SigmaProcess::beamAPtr;
    using Pythia8::SigmaProcess::beamBPtr;
    using Pythia8::SigmaProcess::couplingsPtr;
    using Pythia8::SigmaProcess::sigmaTotPtr;
    using Pythia8::SigmaProcess::slhaPtr;
    using Pythia8::SigmaProcess::lhaUpPtr;
    using Pythia8::SigmaProcess::nQuarkIn;
    using Pythia8::SigmaProcess::renormScale1;
    using Pythia8::SigmaProcess::renormScale2;
    using Pythia8::SigmaProcess::renormScale3;
    using Pythia8::SigmaProcess::renormScale3VV;
    using Pythia8::SigmaProcess::factorScale1;
    using Pythia8::SigmaProcess::factorScale2;
    using Pythia8::SigmaProcess::factorScale3;
    using Pythia8::SigmaProcess::factorScale3VV;
    using Pythia8::SigmaProcess::Kfactor;
    using Pythia8::SigmaProcess::mcME;
    using Pythia8::SigmaProcess::mbME;
    using Pythia8::SigmaProcess::mmuME;
    using Pythia8::SigmaProcess::mtauME;
    using Pythia8::SigmaProcess::renormMultFac;
    using Pythia8::SigmaProcess::renormFixScale;
    using Pythia8::SigmaProcess::factorMultFac;
    using Pythia8::SigmaProcess::factorFixScale;
    using Pythia8::SigmaProcess::higgsH1parity;
    using Pythia8::SigmaProcess::higgsH2parity;
    using Pythia8::SigmaProcess::higgsA3parity;
    using Pythia8::SigmaProcess::higgsH1eta;
    using Pythia8::SigmaProcess::higgsH2eta;
    using Pythia8::SigmaProcess::higgsA3eta;
    using Pythia8::SigmaProcess::higgsH1phi;
    using Pythia8::SigmaProcess::higgsH2phi;
    using Pythia8::SigmaProcess::higgsA3phi;
    using Pythia8::SigmaProcess::idA;
    using Pythia8::SigmaProcess::idB;
    using Pythia8::SigmaProcess::mA;
    using Pythia8::SigmaProcess::mB;
    using Pythia8::SigmaProcess::isLeptonA;
    using Pythia8::SigmaProcess::isLeptonB;
    using Pythia8::SigmaProcess::hasLeptonBeams;
    using Pythia8::SigmaProcess::lepton2gammaA;
    using Pythia8::SigmaProcess::lepton2gammaB;
    using Pythia8::SigmaProcess::inBeamA;
    using Pythia8::SigmaProcess::inBeamB;
    using Pythia8::SigmaProcess::addBeamA;
    using Pythia8::SigmaProcess::addBeamB;
    using Pythia8::SigmaProcess::sizeBeamA;
    using Pythia8::SigmaProcess::sizeBeamB;
    using Pythia8::SigmaProcess::inPair;
    using Pythia8::SigmaProcess::addPair;
    using Pythia8::SigmaProcess::sizePair;
    using Pythia8::SigmaProcess::mH;
    using Pythia8::SigmaProcess::sH;
    using Pythia8::SigmaProcess::sH2;
    using Pythia8::SigmaProcess::Q2RenSave;
    using Pythia8::SigmaProcess::alpEM;
    using Pythia8::SigmaProcess::alpS;
    using Pythia8::SigmaProcess::Q2FacSave;
    using Pythia8::SigmaProcess::x1Save;
    using Pythia8::SigmaProcess::x2Save;
    using Pythia8::SigmaProcess::pdf1Save;
    using Pythia8::SigmaProcess::pdf2Save;
    using Pythia8::SigmaProcess::sigmaSumSave;
    using Pythia8::SigmaProcess::id1;
    using Pythia8::SigmaProcess::id2;
    using Pythia8::SigmaProcess::id3;
    using Pythia8::SigmaProcess::id4;
    using Pythia8::SigmaProcess::id5;
    using Pythia8::SigmaProcess::idSave;
    using Pythia8::SigmaProcess::colSave;
    using Pythia8::SigmaProcess::acolSave;
    using Pythia8::SigmaProcess::mSave;
    using Pythia8::SigmaProcess::cosTheta;
    using Pythia8::SigmaProcess::sinTheta;
    using Pythia8::SigmaProcess::phi;
    using Pythia8::SigmaProcess::sHMass;
    using Pythia8::SigmaProcess::sHBeta;
    using Pythia8::SigmaProcess::pT2Mass;
    using Pythia8::SigmaProcess::pTFin;
    using Pythia8::SigmaProcess::parton;
    using Pythia8::SigmaProcess::partonT;
    using Pythia8::SigmaProcess::mSaveT;
    using Pythia8::SigmaProcess::pTFinT;
    using Pythia8::SigmaProcess::cosThetaT;
    using Pythia8::SigmaProcess::sinThetaT;
    using Pythia8::SigmaProcess::phiT;
    using Pythia8::SigmaProcess::setupForMEin;
    using Pythia8::SigmaProcess::mME;
    using Pythia8::SigmaProcess::pME;
    using Pythia8::SigmaProcess::swapTU;
    using Pythia8::SigmaProcess::setId;
    using Pythia8::SigmaProcess::setColAcol;
    using Pythia8::SigmaProcess::swapColAcol;
    using Pythia8::SigmaProcess::swapCol1234;
    using Pythia8::SigmaProcess::swapCol12;
    using Pythia8::SigmaProcess::swapCol34;
    using Pythia8::SigmaProcess::weightTopDecay;
    using Pythia8::SigmaProcess::weightHiggsDecay;

/* Internal director utilities */
public:
    bool swig_get_inner(const char *swig_protected_method_name) const {
      std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
      return (iv != swig_inner.end() ? iv->second : false);
    }
    void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
      swig_inner[swig_protected_method_name] = swig_val;
    }
private:
    mutable std::map<std::string, bool> swig_inner;

#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
/* VTable implementation */
    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
      PyObject *method = vtable[method_index];
      if (!method) {
        swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
        method = PyObject_GetAttr(swig_get_self(), name);
        if (!method) {
          std::string msg = "Method in class SigmaProcess doesn't exist, undefined ";
          msg += method_name;
          Swig::DirectorMethodException::raise(msg.c_str());
        }
        vtable[method_index] = method;
      }
      return method;
    }
private:
    mutable swig::SwigVar_PyObject vtable[57];
#endif

};


class SwigDirector_UserHooks : public Pythia8::UserHooks, public Swig::Director {

public:
    SwigDirector_UserHooks(PyObject *self);
    virtual ~SwigDirector_UserHooks();
    virtual bool initAfterBeams();
    virtual bool canModifySigma();
    virtual double multiplySigmaBy(Pythia8::SigmaProcess const *sigmaProcessPtr, Pythia8::PhaseSpace const *phaseSpacePtr, bool inEvent);
    virtual bool canBiasSelection();
    virtual double biasSelectionBy(Pythia8::SigmaProcess const *sigmaProcessPtr, Pythia8::PhaseSpace const *phaseSpacePtr, bool inEvent);
    virtual double biasedSelectionWeight();
    virtual bool canVetoProcessLevel();
    virtual bool doVetoProcessLevel(Pythia8::Event &arg0);
    virtual bool canVetoResonanceDecays();
    virtual bool doVetoResonanceDecays(Pythia8::Event &arg0);
    virtual bool canVetoPT();
    virtual double scaleVetoPT();
    virtual bool doVetoPT(int arg0, Pythia8::Event const &arg1);
    virtual bool canVetoStep();
    virtual int numberVetoStep();
    virtual bool doVetoStep(int arg0, int arg1, int arg2, Pythia8::Event const &arg3);
    virtual bool canVetoMPIStep();
    virtual int numberVetoMPIStep();
    virtual bool doVetoMPIStep(int arg0, Pythia8::Event const &arg1);
    virtual bool canVetoPartonLevelEarly();
    virtual bool doVetoPartonLevelEarly(Pythia8::Event const &arg0);
    virtual bool retryPartonLevel();
    virtual bool canVetoPartonLevel();
    virtual bool doVetoPartonLevel(Pythia8::Event const &arg0);
    virtual bool canSetResonanceScale();
    virtual double scaleResonance(int arg0, Pythia8::Event const &arg1);
    virtual bool canVetoISREmission();
    virtual bool doVetoISREmission(int arg0, Pythia8::Event const &arg1, int arg2);
    virtual bool canVetoFSREmission();
    virtual bool doVetoFSREmission(int arg0, Pythia8::Event const &arg1, int arg2, bool arg3 = false);
    virtual bool canVetoMPIEmission();
    virtual bool doVetoMPIEmission(int arg0, Pythia8::Event const &arg1);
    virtual bool canReconnectResonanceSystems();
    virtual bool doReconnectResonanceSystems(int arg0, Pythia8::Event &arg1);
    virtual bool canEnhanceEmission();
    virtual double enhanceFactor(std::string arg0);
    virtual double vetoProbability(std::string arg0);
    virtual bool canEnhanceTrial();
    virtual bool canChangeFragPar();
    virtual bool doChangeFragPar(Pythia8::StringFlav *arg0, Pythia8::StringZ *arg1, Pythia8::StringPT *arg2, int arg3, double arg4, std::vector< int,std::allocator< int > > arg5);
    virtual bool doVetoFragmentation(Pythia8::Particle arg0);
    virtual bool canSetImpactParameter() const;
    virtual double doSetImpactParameter();
    using Pythia8::UserHooks::infoPtr;
    using Pythia8::UserHooks::settingsPtr;
    using Pythia8::UserHooks::particleDataPtr;
    using Pythia8::UserHooks::rndmPtr;
    using Pythia8::UserHooks::beamAPtr;
    using Pythia8::UserHooks::beamBPtr;
    using Pythia8::UserHooks::beamPomAPtr;
    using Pythia8::UserHooks::beamPomBPtr;
    using Pythia8::UserHooks::coupSMPtr;
    using Pythia8::UserHooks::partonSystemsPtr;
    using Pythia8::UserHooks::sigmaTotPtr;
    using Pythia8::UserHooks::omitResonanceDecays;
    using Pythia8::UserHooks::subEvent;
    using Pythia8::UserHooks::workEvent;
    using Pythia8::UserHooks::selBias;
    using Pythia8::UserHooks::enhancedEventWeight;
    using Pythia8::UserHooks::pTEnhanced;
    using Pythia8::UserHooks::wtEnhanced;

/* Internal director utilities */
public:
    bool swig_get_inner(const char *swig_protected_method_name) const {
      std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
      return (iv != swig_inner.end() ? iv->second : false);
    }
    void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
      swig_inner[swig_protected_method_name] = swig_val;
    }
private:
    mutable std::map<std::string, bool> swig_inner;

#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
/* VTable implementation */
    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
      PyObject *method = vtable[method_index];
      if (!method) {
        swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
        method = PyObject_GetAttr(swig_get_self(), name);
        if (!method) {
          std::string msg = "Method in class UserHooks doesn't exist, undefined ";
          msg += method_name;
          Swig::DirectorMethodException::raise(msg.c_str());
        }
        vtable[method_index] = method;
      }
      return method;
    }
private:
    mutable swig::SwigVar_PyObject vtable[44];
#endif

};


class SwigDirector_PhaseSpace : public Pythia8::PhaseSpace, public Swig::Director {

public:
    SwigDirector_PhaseSpace(PyObject *self);
    virtual ~SwigDirector_PhaseSpace();
    virtual bool setupSampling();
    virtual bool trialKin(bool inEvent = true, bool repeatSame = false);
    virtual bool finalKin();
    virtual double sigmaSumSigned() const;
    virtual bool isResolved() const;
    virtual void rescaleSigma(double arg0);
    virtual void rescaleMomenta(double arg0);
    virtual double weightGammaPDFApprox();
    virtual void setGammaKinPtr(Pythia8::GammaKinematics *arg0);
    using Pythia8::PhaseSpace::NMAXTRY;
    using Pythia8::PhaseSpace::NTRY3BODY;
    using Pythia8::PhaseSpace::SAFETYMARGIN;
    using Pythia8::PhaseSpace::TINY;
    using Pythia8::PhaseSpace::EVENFRAC;
    using Pythia8::PhaseSpace::SAMESIGMA;
    using Pythia8::PhaseSpace::MRESMINABS;
    using Pythia8::PhaseSpace::WIDTHMARGIN;
    using Pythia8::PhaseSpace::SAMEMASS;
    using Pythia8::PhaseSpace::MASSMARGIN;
    using Pythia8::PhaseSpace::EXTRABWWTMAX;
    using Pythia8::PhaseSpace::THRESHOLDSIZE;
    using Pythia8::PhaseSpace::THRESHOLDSTEP;
    using Pythia8::PhaseSpace::YRANGEMARGIN;
    using Pythia8::PhaseSpace::LEPTONXMIN;
    using Pythia8::PhaseSpace::LEPTONXMAX;
    using Pythia8::PhaseSpace::LEPTONXLOGMIN;
    using Pythia8::PhaseSpace::LEPTONXLOGMAX;
    using Pythia8::PhaseSpace::LEPTONTAUMIN;
    using Pythia8::PhaseSpace::SHATMINZ;
    using Pythia8::PhaseSpace::PT2RATMINZ;
    using Pythia8::PhaseSpace::WTCORRECTION;
    using Pythia8::PhaseSpace::sigmaProcessPtr;
    using Pythia8::PhaseSpace::infoPtr;
    using Pythia8::PhaseSpace::settingsPtr;
    using Pythia8::PhaseSpace::particleDataPtr;
    using Pythia8::PhaseSpace::rndmPtr;
    using Pythia8::PhaseSpace::beamAPtr;
    using Pythia8::PhaseSpace::beamBPtr;
    using Pythia8::PhaseSpace::couplingsPtr;
    using Pythia8::PhaseSpace::sigmaTotPtr;
    using Pythia8::PhaseSpace::userHooksPtr;
    using Pythia8::PhaseSpace::lhaUpPtr;
    using Pythia8::PhaseSpace::useBreitWigners;
    using Pythia8::PhaseSpace::doEnergySpread;
    using Pythia8::PhaseSpace::showSearch;
    using Pythia8::PhaseSpace::showViolation;
    using Pythia8::PhaseSpace::increaseMaximum;
    using Pythia8::PhaseSpace::hasQ2Min;
    using Pythia8::PhaseSpace::gmZmodeGlobal;
    using Pythia8::PhaseSpace::mHatGlobalMin;
    using Pythia8::PhaseSpace::mHatGlobalMax;
    using Pythia8::PhaseSpace::pTHatGlobalMin;
    using Pythia8::PhaseSpace::pTHatGlobalMax;
    using Pythia8::PhaseSpace::Q2GlobalMin;
    using Pythia8::PhaseSpace::pTHatMinDiverge;
    using Pythia8::PhaseSpace::minWidthBreitWigners;
    using Pythia8::PhaseSpace::idA;
    using Pythia8::PhaseSpace::idB;
    using Pythia8::PhaseSpace::mA;
    using Pythia8::PhaseSpace::mB;
    using Pythia8::PhaseSpace::eCM;
    using Pythia8::PhaseSpace::s;
    using Pythia8::PhaseSpace::hasLeptonBeamA;
    using Pythia8::PhaseSpace::hasLeptonBeamB;
    using Pythia8::PhaseSpace::hasOneLeptonBeam;
    using Pythia8::PhaseSpace::hasTwoLeptonBeams;
    using Pythia8::PhaseSpace::hasPointGammaA;
    using Pythia8::PhaseSpace::hasPointGammaB;
    using Pythia8::PhaseSpace::hasOnePointParticle;
    using Pythia8::PhaseSpace::hasTwoPointParticles;
    using Pythia8::PhaseSpace::newSigmaMx;
    using Pythia8::PhaseSpace::canModifySigma;
    using Pythia8::PhaseSpace::canBiasSelection;
    using Pythia8::PhaseSpace::canBias2Sel;
    using Pythia8::PhaseSpace::gmZmode;
    using Pythia8::PhaseSpace::bias2SelPow;
    using Pythia8::PhaseSpace::bias2SelRef;
    using Pythia8::PhaseSpace::wtBW;
    using Pythia8::PhaseSpace::sigmaNw;
    using Pythia8::PhaseSpace::sigmaMx;
    using Pythia8::PhaseSpace::sigmaPos;
    using Pythia8::PhaseSpace::sigmaNeg;
    using Pythia8::PhaseSpace::biasWt;
    using Pythia8::PhaseSpace::mHatMin;
    using Pythia8::PhaseSpace::mHatMax;
    using Pythia8::PhaseSpace::sHatMin;
    using Pythia8::PhaseSpace::sHatMax;
    using Pythia8::PhaseSpace::pTHatMin;
    using Pythia8::PhaseSpace::pTHatMax;
    using Pythia8::PhaseSpace::pT2HatMin;
    using Pythia8::PhaseSpace::pT2HatMax;
    using Pythia8::PhaseSpace::x1H;
    using Pythia8::PhaseSpace::x2H;
    using Pythia8::PhaseSpace::m3;
    using Pythia8::PhaseSpace::m4;
    using Pythia8::PhaseSpace::m5;
    using Pythia8::PhaseSpace::s3;
    using Pythia8::PhaseSpace::s4;
    using Pythia8::PhaseSpace::s5;
    using Pythia8::PhaseSpace::mHat;
    using Pythia8::PhaseSpace::sH;
    using Pythia8::PhaseSpace::tH;
    using Pythia8::PhaseSpace::uH;
    using Pythia8::PhaseSpace::pAbs;
    using Pythia8::PhaseSpace::p2Abs;
    using Pythia8::PhaseSpace::pTH;
    using Pythia8::PhaseSpace::theta;
    using Pythia8::PhaseSpace::phi;
    using Pythia8::PhaseSpace::betaZ;
    using Pythia8::PhaseSpace::pH;
    using Pythia8::PhaseSpace::mH;
    using Pythia8::PhaseSpace::decayKinematicsStep;
    using Pythia8::PhaseSpace::setup3Body;
    using Pythia8::PhaseSpace::setupSampling123;
    using Pythia8::PhaseSpace::trialKin123;
    using Pythia8::PhaseSpace::idResA;
    using Pythia8::PhaseSpace::idResB;
    using Pythia8::PhaseSpace::mResA;
    using Pythia8::PhaseSpace::mResB;
    using Pythia8::PhaseSpace::GammaResA;
    using Pythia8::PhaseSpace::GammaResB;
    using Pythia8::PhaseSpace::tauResA;
    using Pythia8::PhaseSpace::tauResB;
    using Pythia8::PhaseSpace::widResA;
    using Pythia8::PhaseSpace::widResB;
    using Pythia8::PhaseSpace::sameResMass;
    using Pythia8::PhaseSpace::useMirrorWeight;
    using Pythia8::PhaseSpace::hasNegZ;
    using Pythia8::PhaseSpace::hasPosZ;
    using Pythia8::PhaseSpace::tau;
    using Pythia8::PhaseSpace::y;
    using Pythia8::PhaseSpace::z;
    using Pythia8::PhaseSpace::tauMin;
    using Pythia8::PhaseSpace::tauMax;
    using Pythia8::PhaseSpace::yMax;
    using Pythia8::PhaseSpace::zMin;
    using Pythia8::PhaseSpace::zMax;
    using Pythia8::PhaseSpace::ratio34;
    using Pythia8::PhaseSpace::unity34;
    using Pythia8::PhaseSpace::zNeg;
    using Pythia8::PhaseSpace::zPos;
    using Pythia8::PhaseSpace::wtTau;
    using Pythia8::PhaseSpace::wtY;
    using Pythia8::PhaseSpace::wtZ;
    using Pythia8::PhaseSpace::wt3Body;
    using Pythia8::PhaseSpace::runBW3H;
    using Pythia8::PhaseSpace::runBW4H;
    using Pythia8::PhaseSpace::runBW5H;
    using Pythia8::PhaseSpace::intTau0;
    using Pythia8::PhaseSpace::intTau1;
    using Pythia8::PhaseSpace::intTau2;
    using Pythia8::PhaseSpace::intTau3;
    using Pythia8::PhaseSpace::intTau4;
    using Pythia8::PhaseSpace::intTau5;
    using Pythia8::PhaseSpace::intTau6;
    using Pythia8::PhaseSpace::intY0;
    using Pythia8::PhaseSpace::intY12;
    using Pythia8::PhaseSpace::intY34;
    using Pythia8::PhaseSpace::intY56;
    using Pythia8::PhaseSpace::mTchan1;
    using Pythia8::PhaseSpace::sTchan1;
    using Pythia8::PhaseSpace::mTchan2;
    using Pythia8::PhaseSpace::sTchan2;
    using Pythia8::PhaseSpace::frac3Flat;
    using Pythia8::PhaseSpace::frac3Pow1;
    using Pythia8::PhaseSpace::frac3Pow2;
    using Pythia8::PhaseSpace::zNegMin;
    using Pythia8::PhaseSpace::zNegMax;
    using Pythia8::PhaseSpace::zPosMin;
    using Pythia8::PhaseSpace::zPosMax;
    using Pythia8::PhaseSpace::p3cm;
    using Pythia8::PhaseSpace::p4cm;
    using Pythia8::PhaseSpace::p5cm;
    using Pythia8::PhaseSpace::nTau;
    using Pythia8::PhaseSpace::nY;
    using Pythia8::PhaseSpace::nZ;
    using Pythia8::PhaseSpace::tauCoef;
    using Pythia8::PhaseSpace::yCoef;
    using Pythia8::PhaseSpace::zCoef;
    using Pythia8::PhaseSpace::tauCoefSum;
    using Pythia8::PhaseSpace::yCoefSum;
    using Pythia8::PhaseSpace::zCoefSum;
    using Pythia8::PhaseSpace::limitTau;
    using Pythia8::PhaseSpace::limitY;
    using Pythia8::PhaseSpace::limitZ;
    using Pythia8::PhaseSpace::selectTau;
    using Pythia8::PhaseSpace::selectY;
    using Pythia8::PhaseSpace::selectZ;
    using Pythia8::PhaseSpace::select3Body;
    using Pythia8::PhaseSpace::solveSys;
    using Pythia8::PhaseSpace::useBW;
    using Pythia8::PhaseSpace::idMass;
    using Pythia8::PhaseSpace::mPeak;
    using Pythia8::PhaseSpace::sPeak;
    using Pythia8::PhaseSpace::mWidth;
    using Pythia8::PhaseSpace::mMin;
    using Pythia8::PhaseSpace::mMax;
    using Pythia8::PhaseSpace::mw;
    using Pythia8::PhaseSpace::wmRat;
    using Pythia8::PhaseSpace::mLower;
    using Pythia8::PhaseSpace::mUpper;
    using Pythia8::PhaseSpace::sLower;
    using Pythia8::PhaseSpace::sUpper;
    using Pythia8::PhaseSpace::fracFlatS;
    using Pythia8::PhaseSpace::fracFlatM;
    using Pythia8::PhaseSpace::fracInv;
    using Pythia8::PhaseSpace::fracInv2;
    using Pythia8::PhaseSpace::atanLower;
    using Pythia8::PhaseSpace::atanUpper;
    using Pythia8::PhaseSpace::intBW;
    using Pythia8::PhaseSpace::intFlatS;
    using Pythia8::PhaseSpace::intFlatM;
    using Pythia8::PhaseSpace::intInv;
    using Pythia8::PhaseSpace::intInv2;
    using Pythia8::PhaseSpace::setupMass1;
    using Pythia8::PhaseSpace::setupMass2;
    using Pythia8::PhaseSpace::trialMass;
    using Pythia8::PhaseSpace::weightMass;
    using Pythia8::PhaseSpace::tRange;
    using Pythia8::PhaseSpace::tInRange;

/* Internal director utilities */
public:
    bool swig_get_inner(const char *swig_protected_method_name) const {
      std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
      return (iv != swig_inner.end() ? iv->second : false);
    }
    void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
      swig_inner[swig_protected_method_name] = swig_val;
    }
private:
    mutable std::map<std::string, bool> swig_inner;

#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
/* VTable implementation */
    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
      PyObject *method = vtable[method_index];
      if (!method) {
        swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
        method = PyObject_GetAttr(swig_get_self(), name);
        if (!method) {
          std::string msg = "Method in class PhaseSpace doesn't exist, undefined ";
          msg += method_name;
          Swig::DirectorMethodException::raise(msg.c_str());
        }
        vtable[method_index] = method;
      }
      return method;
    }
private:
    mutable swig::SwigVar_PyObject vtable[11];
#endif

};


class SwigDirector_SpaceShower : public Pythia8::SpaceShower, public Swig::Director {

public:
    SwigDirector_SpaceShower(PyObject *self);
    virtual ~SwigDirector_SpaceShower();
    virtual void init(Pythia8::BeamParticle *beamAPtrIn, Pythia8::BeamParticle *beamBPtrIn);
    virtual bool limitPTmax(Pythia8::Event &event, double Q2Fac = 0., double Q2Ren = 0.);
    virtual double enhancePTmax() const;
    virtual void prepare(int iSys, Pythia8::Event &event, bool limitPTmaxIn = true);
    virtual void update(int arg0, Pythia8::Event &arg1, bool hasWeakRad = false);
    virtual double pTnext(Pythia8::Event &event, double pTbegAll, double pTendAll, int nRadIn = -1, bool doTrialIn = false);
    virtual bool branch(Pythia8::Event &event);
    virtual int system() const;
    virtual Pythia8::Event clustered(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4);
    virtual std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > getStateVariables(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4);
    virtual bool isSpacelike(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4);
    virtual std::vector< std::string,std::allocator< std::string > > getSplittingName(Pythia8::Event const &arg0, int arg1, int arg2, int arg3);
    virtual double getSplittingProb(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4);
    virtual bool allowedSplitting(Pythia8::Event const &arg0, int arg1, int arg2);
    virtual std::vector< int,std::allocator< int > > getRecoilers(Pythia8::Event const &arg0, int arg1, int arg2, std::string arg3);
    using Pythia8::SpaceShower::infoPtr;
    using Pythia8::SpaceShower::settingsPtr;
    using Pythia8::SpaceShower::particleDataPtr;
    using Pythia8::SpaceShower::rndmPtr;
    using Pythia8::SpaceShower::coupSMPtr;
    using Pythia8::SpaceShower::beamAPtr;
    using Pythia8::SpaceShower::beamBPtr;
    using Pythia8::SpaceShower::beamOffset;
    using Pythia8::SpaceShower::partonSystemsPtr;
    using Pythia8::SpaceShower::userHooksPtr;
    using Pythia8::SpaceShower::partonVertexPtr;
    using Pythia8::SpaceShower::weakShowerMEs;
    using Pythia8::SpaceShower::rescatterFail;
    using Pythia8::SpaceShower::iSysSel;
    using Pythia8::SpaceShower::pTmaxFudge;

/* Internal director utilities */
public:
    bool swig_get_inner(const char *swig_protected_method_name) const {
      std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
      return (iv != swig_inner.end() ? iv->second : false);
    }
    void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
      swig_inner[swig_protected_method_name] = swig_val;
    }
private:
    mutable std::map<std::string, bool> swig_inner;

#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
/* VTable implementation */
    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
      PyObject *method = vtable[method_index];
      if (!method) {
        swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
        method = PyObject_GetAttr(swig_get_self(), name);
        if (!method) {
          std::string msg = "Method in class SpaceShower doesn't exist, undefined ";
          msg += method_name;
          Swig::DirectorMethodException::raise(msg.c_str());
        }
        vtable[method_index] = method;
      }
      return method;
    }
private:
    mutable swig::SwigVar_PyObject vtable[21];
#endif

};


class SwigDirector_TimeShower : public Pythia8::TimeShower, public Swig::Director {

public:
    SwigDirector_TimeShower(PyObject *self);
    virtual ~SwigDirector_TimeShower();
    virtual void init(Pythia8::BeamParticle *beamAPtrIn = 0, Pythia8::BeamParticle *beamBPtrIn = 0);
    virtual bool limitPTmax(Pythia8::Event &event, double Q2Fac = 0., double Q2Ren = 0.);
    virtual double enhancePTmax();
    virtual int shower(int iBeg, int iEnd, Pythia8::Event &event, double pTmax, int nBranchMax = 0);
    virtual int showerQED(int i1, int i2, Pythia8::Event &event, double pTmax);
    virtual void prepareGlobal(Pythia8::Event &event);
    virtual void prepare(int iSys, Pythia8::Event &event, bool limitPTmaxIn = true);
    virtual void rescatterUpdate(int iSys, Pythia8::Event &event);
    virtual void update(int iSys, Pythia8::Event &event, bool hasWeakRad = false);
    virtual double pTnext(Pythia8::Event &event, double pTbegAll, double pTendAll, bool isFirstTrial = false, bool doTrialIn = false);
    virtual bool branch(Pythia8::Event &event, bool isInterleaved = false);
    virtual int system() const;
    virtual Pythia8::Event clustered(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4);
    virtual std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > getStateVariables(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4);
    virtual bool isTimelike(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4);
    virtual std::vector< std::string,std::allocator< std::string > > getSplittingName(Pythia8::Event const &arg0, int arg1, int arg2, int arg3);
    virtual double getSplittingProb(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4);
    virtual bool allowedSplitting(Pythia8::Event const &arg0, int arg1, int arg2);
    virtual std::vector< int,std::allocator< int > > getRecoilers(Pythia8::Event const &arg0, int arg1, int arg2, std::string arg3);
    using Pythia8::TimeShower::infoPtr;
    using Pythia8::TimeShower::settingsPtr;
    using Pythia8::TimeShower::particleDataPtr;
    using Pythia8::TimeShower::rndmPtr;
    using Pythia8::TimeShower::coupSMPtr;
    using Pythia8::TimeShower::beamAPtr;
    using Pythia8::TimeShower::beamBPtr;
    using Pythia8::TimeShower::beamOffset;
    using Pythia8::TimeShower::partonSystemsPtr;
    using Pythia8::TimeShower::userHooksPtr;
    using Pythia8::TimeShower::partonVertexPtr;
    using Pythia8::TimeShower::weakShowerMEs;
    using Pythia8::TimeShower::iSysSel;
    using Pythia8::TimeShower::pTmaxFudge;
    using Pythia8::TimeShower::pTLastBranch;

/* Internal director utilities */
public:
    bool swig_get_inner(const char *swig_protected_method_name) const {
      std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
      return (iv != swig_inner.end() ? iv->second : false);
    }
    void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
      swig_inner[swig_protected_method_name] = swig_val;
    }
private:
    mutable std::map<std::string, bool> swig_inner;

#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
/* VTable implementation */
    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
      PyObject *method = vtable[method_index];
      if (!method) {
        swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
        method = PyObject_GetAttr(swig_get_self(), name);
        if (!method) {
          std::string msg = "Method in class TimeShower doesn't exist, undefined ";
          msg += method_name;
          Swig::DirectorMethodException::raise(msg.c_str());
        }
        vtable[method_index] = method;
      }
      return method;
    }
private:
    mutable swig::SwigVar_PyObject vtable[29];
#endif

};


class SwigDirector_DecayHandler : public Pythia8::DecayHandler, public Swig::Director {

public:
    SwigDirector_DecayHandler(PyObject *self);
    virtual ~SwigDirector_DecayHandler();
    virtual bool decay(std::vector< int,std::allocator< int > > &arg0, std::vector< double,std::allocator< double > > &arg1, std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > &arg2, int arg3, Pythia8::Event const &arg4);
    virtual bool chainDecay(std::vector< int,std::allocator< int > > &arg0, std::vector< int,std::allocator< int > > &arg1, std::vector< double,std::allocator< double > > &arg2, std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > &arg3, int arg4, Pythia8::Event const &arg5);

/* Internal director utilities */
public:
    bool swig_get_inner(const char *swig_protected_method_name) const {
      std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
      return (iv != swig_inner.end() ? iv->second : false);
    }
    void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
      swig_inner[swig_protected_method_name] = swig_val;
    }
private:
    mutable std::map<std::string, bool> swig_inner;

#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
/* VTable implementation */
    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
      PyObject *method = vtable[method_index];
      if (!method) {
        swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
        method = PyObject_GetAttr(swig_get_self(), name);
        if (!method) {
          std::string msg = "Method in class DecayHandler doesn't exist, undefined ";
          msg += method_name;
          Swig::DirectorMethodException::raise(msg.c_str());
        }
        vtable[method_index] = method;
      }
      return method;
    }
private:
    mutable swig::SwigVar_PyObject vtable[2];
#endif

};


#endif

SwigDirector_RndmEngine::SwigDirector_RndmEngine(PyObject *self): Pythia8::RndmEngine(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Pythia8::RndmEngine *)this, this); 
}




SwigDirector_RndmEngine::~SwigDirector_RndmEngine() {
}

double SwigDirector_RndmEngine::flat() {
  double c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call RndmEngine.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char * const swig_method_name = "flat";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "flat", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'RndmEngine.flat'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


SwigDirector_BeamShape::SwigDirector_BeamShape(PyObject *self): Pythia8::BeamShape(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Pythia8::BeamShape *)this, this); 
}




SwigDirector_BeamShape::~SwigDirector_BeamShape() {
}

void SwigDirector_BeamShape::init(Pythia8::Settings &settings, Pythia8::Rndm *rndmPtrIn) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&settings), SWIGTYPE_p_Pythia8__Settings,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(rndmPtrIn), SWIGTYPE_p_Pythia8__Rndm,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BeamShape.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char * const swig_method_name = "init";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"init", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'BeamShape.init'");
    }
  }
}


void SwigDirector_BeamShape::pick() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BeamShape.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char * const swig_method_name = "pick";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "pick", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'BeamShape.pick'");
    }
  }
}


SwigDirector_PDF::SwigDirector_PDF(PyObject *self, int idBeamIn): Pythia8::PDF(idBeamIn), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Pythia8::PDF *)this, this); 
}




SwigDirector_PDF::~SwigDirector_PDF() {
}

bool SwigDirector_PDF::isSetup() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char * const swig_method_name = "isSetup";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "isSetup", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.isSetup'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


void SwigDirector_PDF::newValenceContent(int idVal1In, int idVal2In) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(idVal1In));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(idVal2In));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char * const swig_method_name = "newValenceContent";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"newValenceContent", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.newValenceContent'");
    }
  }
}


void SwigDirector_PDF::setExtrapolate(bool arg0) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_bool(static_cast< bool >(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char * const swig_method_name = "setExtrapolate";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"setExtrapolate", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.setExtrapolate'");
    }
  }
}


double SwigDirector_PDF::xf(int id, double x, double Q2) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(id));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_double(static_cast< double >(x));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_double(static_cast< double >(Q2));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char * const swig_method_name = "xf";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"xf", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.xf'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


double SwigDirector_PDF::xfVal(int id, double x, double Q2) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(id));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_double(static_cast< double >(x));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_double(static_cast< double >(Q2));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char * const swig_method_name = "xfVal";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"xfVal", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.xfVal'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


double SwigDirector_PDF::xfSea(int id, double x, double Q2) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(id));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_double(static_cast< double >(x));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_double(static_cast< double >(Q2));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char * const swig_method_name = "xfSea";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"xfSea", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.xfSea'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


bool SwigDirector_PDF::insideBounds(double arg0, double arg1) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_double(static_cast< double >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_double(static_cast< double >(arg1));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char * const swig_method_name = "insideBounds";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"insideBounds", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.insideBounds'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


double SwigDirector_PDF::alphaS(double arg0) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_double(static_cast< double >(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char * const swig_method_name = "alphaS";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"alphaS", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.alphaS'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


double SwigDirector_PDF::mQuarkPDF(int arg0) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char * const swig_method_name = "mQuarkPDF";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"mQuarkPDF", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.mQuarkPDF'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


int SwigDirector_PDF::nMembers() {
  int c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char * const swig_method_name = "nMembers";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "nMembers", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.nMembers'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


void SwigDirector_PDF::calcPDFEnvelope(int arg0, double arg1, double arg2, int arg3) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_double(static_cast< double >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_double(static_cast< double >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char * const swig_method_name = "calcPDFEnvelope";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"calcPDFEnvelope", (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.calcPDFEnvelope'");
    }
  }
}


void SwigDirector_PDF::calcPDFEnvelope(std::pair< int,int > arg0, std::pair< double,double > arg1, double arg2, int arg3) {
  swig::SwigVar_PyObject obj0;
  obj0 = swig::from(static_cast< std::pair< int,int > >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_std__pairT_double_double_t,  0 );
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_double(static_cast< double >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char * const swig_method_name = "calcPDFEnvelope";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"calcPDFEnvelope", (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.calcPDFEnvelope'");
    }
  }
}


Pythia8::PDF::PDFEnvelope SwigDirector_PDF::getPDFEnvelope() {
  void *swig_argp ;
  int swig_res = 0 ;
  
  Pythia8::PDF::PDFEnvelope c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char * const swig_method_name = "getPDFEnvelope";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "getPDFEnvelope", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.getPDFEnvelope'");
    }
  }
  swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_Pythia8__PDF__PDFEnvelope,  0  | 0);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Pythia8::PDF::PDFEnvelope""'");
  }
  c_result = *(reinterpret_cast< Pythia8::PDF::PDFEnvelope * >(swig_argp));
  if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< Pythia8::PDF::PDFEnvelope * >(swig_argp);
  return (Pythia8::PDF::PDFEnvelope) c_result;
}


double SwigDirector_PDF::gammaPDFxDependence(int arg0, double arg1) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_double(static_cast< double >(arg1));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char * const swig_method_name = "gammaPDFxDependence";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"gammaPDFxDependence", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.gammaPDFxDependence'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


double SwigDirector_PDF::gammaPDFRefScale(int arg0) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char * const swig_method_name = "gammaPDFRefScale";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"gammaPDFRefScale", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.gammaPDFRefScale'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


int SwigDirector_PDF::sampleGammaValFlavor(double arg0) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_double(static_cast< double >(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char * const swig_method_name = "sampleGammaValFlavor";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"sampleGammaValFlavor", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.sampleGammaValFlavor'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


double SwigDirector_PDF::xfIntegratedTotal(double arg0) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_double(static_cast< double >(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 16;
  const char * const swig_method_name = "xfIntegratedTotal";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"xfIntegratedTotal", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.xfIntegratedTotal'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


double SwigDirector_PDF::xGamma() {
  double c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 17;
  const char * const swig_method_name = "xGamma";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "xGamma", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.xGamma'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


void SwigDirector_PDF::xPom(double arg0) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_double(static_cast< double >(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 18;
  const char * const swig_method_name = "xPom";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"xPom", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.xPom'");
    }
  }
}


double SwigDirector_PDF::xfFlux(int arg0, double arg1, double arg2) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_double(static_cast< double >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_double(static_cast< double >(arg2));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 20;
  const char * const swig_method_name = "xfFlux";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"xfFlux", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.xfFlux'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


double SwigDirector_PDF::xfApprox(int arg0, double arg1, double arg2) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_double(static_cast< double >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_double(static_cast< double >(arg2));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 21;
  const char * const swig_method_name = "xfApprox";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"xfApprox", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.xfApprox'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


double SwigDirector_PDF::xfGamma(int arg0, double arg1, double arg2) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_double(static_cast< double >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_double(static_cast< double >(arg2));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 22;
  const char * const swig_method_name = "xfGamma";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"xfGamma", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.xfGamma'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


double SwigDirector_PDF::getQ2min() {
  double c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 23;
  const char * const swig_method_name = "getQ2min";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "getQ2min", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.getQ2min'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


double SwigDirector_PDF::getXmin() {
  double c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 24;
  const char * const swig_method_name = "getXmin";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "getXmin", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.getXmin'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


double SwigDirector_PDF::getXhadr() {
  double c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 25;
  const char * const swig_method_name = "getXhadr";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "getXhadr", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.getXhadr'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


double SwigDirector_PDF::getGammaFluxNorm() {
  double c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 26;
  const char * const swig_method_name = "getGammaFluxNorm";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "getGammaFluxNorm", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.getGammaFluxNorm'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


double SwigDirector_PDF::sampleXgamma(double arg0) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_double(static_cast< double >(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 27;
  const char * const swig_method_name = "sampleXgamma";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"sampleXgamma", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.sampleXgamma'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


double SwigDirector_PDF::sampleQ2gamma(double arg0) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_double(static_cast< double >(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 28;
  const char * const swig_method_name = "sampleQ2gamma";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"sampleQ2gamma", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.sampleQ2gamma'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


double SwigDirector_PDF::xfMax(int id, double x, double Q2) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(id));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_double(static_cast< double >(x));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_double(static_cast< double >(Q2));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 29;
  const char * const swig_method_name = "xfMax";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"xfMax", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.xfMax'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


double SwigDirector_PDF::xfSame(int id, double x, double Q2) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(id));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_double(static_cast< double >(x));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_double(static_cast< double >(Q2));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 30;
  const char * const swig_method_name = "xfSame";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"xfSame", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.xfSame'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


void SwigDirector_PDF::setVMDscale(double arg0) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_double(static_cast< double >(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 31;
  const char * const swig_method_name = "setVMDscale";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"setVMDscale", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.setVMDscale'");
    }
  }
}


void SwigDirector_PDF::xfUpdate(int id, double x, double Q2) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(id));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_double(static_cast< double >(x));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_double(static_cast< double >(Q2));
  swig_set_inner("xfUpdate", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PDF.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 33;
  const char * const swig_method_name = "xfUpdate";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"xfUpdate", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#endif
  swig_set_inner("xfUpdate", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PDF.xfUpdate'");
    }
  }
}


SwigDirector_ResonanceWidths::SwigDirector_ResonanceWidths(PyObject *self): Pythia8::ResonanceWidths(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Pythia8::ResonanceWidths *)this, this); 
}




SwigDirector_ResonanceWidths::~SwigDirector_ResonanceWidths() {
}

bool SwigDirector_ResonanceWidths::init(Pythia8::Info *infoPtrIn, Pythia8::Settings *settingsPtrIn, Pythia8::ParticleData *particleDataPtrIn, Pythia8::Couplings *couplingsPtrIn) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(infoPtrIn), SWIGTYPE_p_Pythia8__Info,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(settingsPtrIn), SWIGTYPE_p_Pythia8__Settings,  0 );
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(particleDataPtrIn), SWIGTYPE_p_Pythia8__ParticleData,  0 );
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_NewPointerObj(SWIG_as_voidptr(couplingsPtrIn), SWIGTYPE_p_Pythia8__Couplings,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ResonanceWidths.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char * const swig_method_name = "init";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"init", (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'ResonanceWidths.init'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


void SwigDirector_ResonanceWidths::initConstants() {
  swig_set_inner("initConstants", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ResonanceWidths.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char * const swig_method_name = "initConstants";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "initConstants", NULL);
#endif
  swig_set_inner("initConstants", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'ResonanceWidths.initConstants'");
    }
  }
}


bool SwigDirector_ResonanceWidths::initBSM() {
  bool c_result;
  swig_set_inner("initBSM", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ResonanceWidths.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char * const swig_method_name = "initBSM";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "initBSM", NULL);
#endif
  swig_set_inner("initBSM", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'ResonanceWidths.initBSM'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_ResonanceWidths::allowCalc() {
  bool c_result;
  swig_set_inner("allowCalc", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ResonanceWidths.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char * const swig_method_name = "allowCalc";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "allowCalc", NULL);
#endif
  swig_set_inner("allowCalc", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'ResonanceWidths.allowCalc'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


void SwigDirector_ResonanceWidths::calcPreFac(bool arg0) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_bool(static_cast< bool >(arg0));
  swig_set_inner("calcPreFac", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ResonanceWidths.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char * const swig_method_name = "calcPreFac";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"calcPreFac", (char *)"(O)" ,(PyObject *)obj0);
#endif
  swig_set_inner("calcPreFac", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'ResonanceWidths.calcPreFac'");
    }
  }
}


void SwigDirector_ResonanceWidths::calcWidth(bool arg0) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_bool(static_cast< bool >(arg0));
  swig_set_inner("calcWidth", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call ResonanceWidths.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char * const swig_method_name = "calcWidth";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"calcWidth", (char *)"(O)" ,(PyObject *)obj0);
#endif
  swig_set_inner("calcWidth", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'ResonanceWidths.calcWidth'");
    }
  }
}


SwigDirector_LHAup::SwigDirector_LHAup(PyObject *self, int strategyIn): Pythia8::LHAup(strategyIn), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Pythia8::LHAup *)this, this); 
}




SwigDirector_LHAup::~SwigDirector_LHAup() {
}

void SwigDirector_LHAup::newEventFile(char const *arg0) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_FromCharPtr((const char *)arg0);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call LHAup.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char * const swig_method_name = "newEventFile";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"newEventFile", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'LHAup.newEventFile'");
    }
  }
}


bool SwigDirector_LHAup::fileFound() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call LHAup.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char * const swig_method_name = "fileFound";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "fileFound", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'LHAup.fileFound'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_LHAup::useExternal() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call LHAup.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char * const swig_method_name = "useExternal";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "useExternal", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'LHAup.useExternal'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_LHAup::setInit() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call LHAup.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char * const swig_method_name = "setInit";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "setInit", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'LHAup.setInit'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_LHAup::setEvent(int idProcIn) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(idProcIn));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call LHAup.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char * const swig_method_name = "setEvent";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"setEvent", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'LHAup.setEvent'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_LHAup::skipEvent(int nSkip) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(nSkip));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call LHAup.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char * const swig_method_name = "skipEvent";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"skipEvent", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'LHAup.skipEvent'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_LHAup::openLHEF(std::string fileNameIn) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_std_string(static_cast< std::string >(fileNameIn));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call LHAup.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char * const swig_method_name = "openLHEF";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"openLHEF", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'LHAup.openLHEF'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_LHAup::closeLHEF(bool updateInit) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_bool(static_cast< bool >(updateInit));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call LHAup.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char * const swig_method_name = "closeLHEF";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"closeLHEF", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'LHAup.closeLHEF'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


SwigDirector_MergingHooks::SwigDirector_MergingHooks(PyObject *self): Pythia8::MergingHooks(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Pythia8::MergingHooks *)this, this); 
}




SwigDirector_MergingHooks::~SwigDirector_MergingHooks() {
}

double SwigDirector_MergingHooks::tmsDefinition(Pythia8::Event const &event) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&event), SWIGTYPE_p_Pythia8__Event,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char * const swig_method_name = "tmsDefinition";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"tmsDefinition", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.tmsDefinition'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


double SwigDirector_MergingHooks::dampenIfFailCuts(Pythia8::Event const &inEvent) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&inEvent), SWIGTYPE_p_Pythia8__Event,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char * const swig_method_name = "dampenIfFailCuts";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"dampenIfFailCuts", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.dampenIfFailCuts'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


bool SwigDirector_MergingHooks::canCutOnRecState() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char * const swig_method_name = "canCutOnRecState";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canCutOnRecState", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.canCutOnRecState'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_MergingHooks::doCutOnRecState(Pythia8::Event const &event) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&event), SWIGTYPE_p_Pythia8__Event,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char * const swig_method_name = "doCutOnRecState";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doCutOnRecState", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.doCutOnRecState'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_MergingHooks::canVetoTrialEmission() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char * const swig_method_name = "canVetoTrialEmission";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoTrialEmission", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.canVetoTrialEmission'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_MergingHooks::doVetoTrialEmission(Pythia8::Event const &arg0, Pythia8::Event const &arg1) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_Pythia8__Event,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char * const swig_method_name = "doVetoTrialEmission";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoTrialEmission", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.doVetoTrialEmission'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


double SwigDirector_MergingHooks::hardProcessME(Pythia8::Event const &inEvent) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&inEvent), SWIGTYPE_p_Pythia8__Event,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char * const swig_method_name = "hardProcessME";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"hardProcessME", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.hardProcessME'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


void SwigDirector_MergingHooks::init() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char * const swig_method_name = "init";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "init", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.init'");
    }
  }
}


int SwigDirector_MergingHooks::getNumberOfClusteringSteps(Pythia8::Event const &event, bool resetNjetMax) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&event), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_bool(static_cast< bool >(resetNjetMax));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char * const swig_method_name = "getNumberOfClusteringSteps";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"getNumberOfClusteringSteps", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.getNumberOfClusteringSteps'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


double SwigDirector_MergingHooks::tmsNow(Pythia8::Event const &event) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&event), SWIGTYPE_p_Pythia8__Event,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char * const swig_method_name = "tmsNow";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"tmsNow", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.tmsNow'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


bool SwigDirector_MergingHooks::canVetoEmission() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char * const swig_method_name = "canVetoEmission";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoEmission", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.canVetoEmission'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_MergingHooks::doVetoEmission(Pythia8::Event const &arg0) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char * const swig_method_name = "doVetoEmission";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoEmission", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.doVetoEmission'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_MergingHooks::useShowerPlugin() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char * const swig_method_name = "useShowerPlugin";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "useShowerPlugin", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.useShowerPlugin'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_MergingHooks::canVetoStep() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char * const swig_method_name = "canVetoStep";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoStep", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.canVetoStep'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_MergingHooks::doVetoStep(Pythia8::Event const &process, Pythia8::Event const &event, bool doResonance) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&process), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&event), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_bool(static_cast< bool >(doResonance));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char * const swig_method_name = "doVetoStep";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoStep", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.doVetoStep'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_MergingHooks::setShowerStartingScales(bool isTrial, bool doMergeFirstEmm, double &pTscaleIn, Pythia8::Event const &event, double &pTmaxFSRIn, bool &limitPTmaxFSRin, double &pTmaxISRIn, bool &limitPTmaxISRin, double &pTmaxMPIIn, bool &limitPTmaxMPIin) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_bool(static_cast< bool >(isTrial));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_bool(static_cast< bool >(doMergeFirstEmm));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(&pTscaleIn), SWIGTYPE_p_double,  0 );
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_NewPointerObj(SWIG_as_voidptr(&event), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_NewPointerObj(SWIG_as_voidptr(&pTmaxFSRIn), SWIGTYPE_p_double,  0 );
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_NewPointerObj(SWIG_as_voidptr(&limitPTmaxFSRin), SWIGTYPE_p_bool,  0 );
  swig::SwigVar_PyObject obj6;
  obj6 = SWIG_NewPointerObj(SWIG_as_voidptr(&pTmaxISRIn), SWIGTYPE_p_double,  0 );
  swig::SwigVar_PyObject obj7;
  obj7 = SWIG_NewPointerObj(SWIG_as_voidptr(&limitPTmaxISRin), SWIGTYPE_p_bool,  0 );
  swig::SwigVar_PyObject obj8;
  obj8 = SWIG_NewPointerObj(SWIG_as_voidptr(&pTmaxMPIIn), SWIGTYPE_p_double,  0 );
  swig::SwigVar_PyObject obj9;
  obj9 = SWIG_NewPointerObj(SWIG_as_voidptr(&limitPTmaxMPIin), SWIGTYPE_p_bool,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call MergingHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 17;
  const char * const swig_method_name = "setShowerStartingScales";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOOOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6,(PyObject *)obj7,(PyObject *)obj8,(PyObject *)obj9);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"setShowerStartingScales", (char *)"(OOOOOOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6,(PyObject *)obj7,(PyObject *)obj8,(PyObject *)obj9);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'MergingHooks.setShowerStartingScales'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


SwigDirector_SigmaProcess::SwigDirector_SigmaProcess(PyObject *self): Pythia8::SigmaProcess(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Pythia8::SigmaProcess *)this, this); 
}




SwigDirector_SigmaProcess::~SwigDirector_SigmaProcess() {
}

void SwigDirector_SigmaProcess::initProc() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char * const swig_method_name = "initProc";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "initProc", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.initProc'");
    }
  }
}


bool SwigDirector_SigmaProcess::initFlux() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char * const swig_method_name = "initFlux";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "initFlux", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.initFlux'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


void SwigDirector_SigmaProcess::set1Kin(double arg0, double arg1, double arg2) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_double(static_cast< double >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_double(static_cast< double >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_double(static_cast< double >(arg2));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char * const swig_method_name = "set1Kin";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"set1Kin", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.set1Kin'");
    }
  }
}


void SwigDirector_SigmaProcess::set2Kin(double arg0, double arg1, double arg2, double arg3, double arg4, double arg5, double arg6, double arg7) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_double(static_cast< double >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_double(static_cast< double >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_double(static_cast< double >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_double(static_cast< double >(arg3));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_double(static_cast< double >(arg4));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_double(static_cast< double >(arg5));
  swig::SwigVar_PyObject obj6;
  obj6 = SWIG_From_double(static_cast< double >(arg6));
  swig::SwigVar_PyObject obj7;
  obj7 = SWIG_From_double(static_cast< double >(arg7));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char * const swig_method_name = "set2Kin";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6,(PyObject *)obj7);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"set2Kin", (char *)"(OOOOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6,(PyObject *)obj7);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.set2Kin'");
    }
  }
}


void SwigDirector_SigmaProcess::set2KinMPI(double arg0, double arg1, double arg2, double arg3, double arg4, double arg5, double arg6, bool arg7, double arg8, double arg9) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_double(static_cast< double >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_double(static_cast< double >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_double(static_cast< double >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_double(static_cast< double >(arg3));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_double(static_cast< double >(arg4));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_double(static_cast< double >(arg5));
  swig::SwigVar_PyObject obj6;
  obj6 = SWIG_From_double(static_cast< double >(arg6));
  swig::SwigVar_PyObject obj7;
  obj7 = SWIG_From_bool(static_cast< bool >(arg7));
  swig::SwigVar_PyObject obj8;
  obj8 = SWIG_From_double(static_cast< double >(arg8));
  swig::SwigVar_PyObject obj9;
  obj9 = SWIG_From_double(static_cast< double >(arg9));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char * const swig_method_name = "set2KinMPI";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOOOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6,(PyObject *)obj7,(PyObject *)obj8,(PyObject *)obj9);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"set2KinMPI", (char *)"(OOOOOOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6,(PyObject *)obj7,(PyObject *)obj8,(PyObject *)obj9);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.set2KinMPI'");
    }
  }
}


void SwigDirector_SigmaProcess::set3Kin(double arg0, double arg1, double arg2, Pythia8::Vec4 arg3, Pythia8::Vec4 arg4, Pythia8::Vec4 arg5, double arg6, double arg7, double arg8, double arg9, double arg10, double arg11) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_double(static_cast< double >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_double(static_cast< double >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_double(static_cast< double >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg3), SWIGTYPE_p_Pythia8__Vec4,  0 );
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg4), SWIGTYPE_p_Pythia8__Vec4,  0 );
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg5), SWIGTYPE_p_Pythia8__Vec4,  0 );
  swig::SwigVar_PyObject obj6;
  obj6 = SWIG_From_double(static_cast< double >(arg6));
  swig::SwigVar_PyObject obj7;
  obj7 = SWIG_From_double(static_cast< double >(arg7));
  swig::SwigVar_PyObject obj8;
  obj8 = SWIG_From_double(static_cast< double >(arg8));
  swig::SwigVar_PyObject obj9;
  obj9 = SWIG_From_double(static_cast< double >(arg9));
  swig::SwigVar_PyObject obj10;
  obj10 = SWIG_From_double(static_cast< double >(arg10));
  swig::SwigVar_PyObject obj11;
  obj11 = SWIG_From_double(static_cast< double >(arg11));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char * const swig_method_name = "set3Kin";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOOOOOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6,(PyObject *)obj7,(PyObject *)obj8,(PyObject *)obj9,(PyObject *)obj10,(PyObject *)obj11);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"set3Kin", (char *)"(OOOOOOOOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6,(PyObject *)obj7,(PyObject *)obj8,(PyObject *)obj9,(PyObject *)obj10,(PyObject *)obj11);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.set3Kin'");
    }
  }
}


void SwigDirector_SigmaProcess::sigmaKin() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char * const swig_method_name = "sigmaKin";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "sigmaKin", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.sigmaKin'");
    }
  }
}


double SwigDirector_SigmaProcess::sigmaHat() {
  double c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char * const swig_method_name = "sigmaHat";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "sigmaHat", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.sigmaHat'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


double SwigDirector_SigmaProcess::sigmaHatWrap(int id1in, int id2in) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(id1in));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(id2in));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char * const swig_method_name = "sigmaHatWrap";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"sigmaHatWrap", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.sigmaHatWrap'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


double SwigDirector_SigmaProcess::sigmaPDF(bool initPS, bool samexGamma, bool useNewXvalues, double x1New, double x2New) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_bool(static_cast< bool >(initPS));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_bool(static_cast< bool >(samexGamma));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_bool(static_cast< bool >(useNewXvalues));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_double(static_cast< double >(x1New));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_double(static_cast< double >(x2New));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char * const swig_method_name = "sigmaPDF";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"sigmaPDF", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.sigmaPDF'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


void SwigDirector_SigmaProcess::setIdColAcol() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 17;
  const char * const swig_method_name = "setIdColAcol";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "setIdColAcol", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.setIdColAcol'");
    }
  }
}


bool SwigDirector_SigmaProcess::final2KinMPI(int arg0, int arg1, Pythia8::Vec4 arg2, Pythia8::Vec4 arg3, double arg4, double arg5) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg2), SWIGTYPE_p_Pythia8__Vec4,  0 );
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg3), SWIGTYPE_p_Pythia8__Vec4,  0 );
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_double(static_cast< double >(arg4));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_From_double(static_cast< double >(arg5));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 18;
  const char * const swig_method_name = "final2KinMPI";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"final2KinMPI", (char *)"(OOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.final2KinMPI'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


double SwigDirector_SigmaProcess::weightDecayFlav(Pythia8::Event &arg0) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 25;
  const char * const swig_method_name = "weightDecayFlav";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"weightDecayFlav", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.weightDecayFlav'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


double SwigDirector_SigmaProcess::weightDecay(Pythia8::Event &arg0, int arg1, int arg2) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 26;
  const char * const swig_method_name = "weightDecay";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"weightDecay", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.weightDecay'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


void SwigDirector_SigmaProcess::setScale() {
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 27;
  const char * const swig_method_name = "setScale";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "setScale", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.setScale'");
    }
  }
}


std::string SwigDirector_SigmaProcess::name() const {
  std::string c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 28;
  const char * const swig_method_name = "name";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "name", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.name'");
    }
  }
  std::string *swig_optr = 0;
  int swig_ores = SWIG_AsPtr_std_string(result, &swig_optr);
  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
  }
  c_result = *swig_optr;
  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
  return (std::string) c_result;
}


int SwigDirector_SigmaProcess::code() const {
  int c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 29;
  const char * const swig_method_name = "code";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "code", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.code'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_SigmaProcess::nFinal() const {
  int c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 30;
  const char * const swig_method_name = "nFinal";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "nFinal", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.nFinal'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


std::string SwigDirector_SigmaProcess::inFlux() const {
  std::string c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 31;
  const char * const swig_method_name = "inFlux";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "inFlux", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.inFlux'");
    }
  }
  std::string *swig_optr = 0;
  int swig_ores = SWIG_AsPtr_std_string(result, &swig_optr);
  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::string""'");
  }
  c_result = *swig_optr;
  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
  return (std::string) c_result;
}


bool SwigDirector_SigmaProcess::convert2mb() const {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 32;
  const char * const swig_method_name = "convert2mb";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "convert2mb", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.convert2mb'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_SigmaProcess::convertM2() const {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 33;
  const char * const swig_method_name = "convertM2";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "convertM2", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.convertM2'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_SigmaProcess::isLHA() const {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 34;
  const char * const swig_method_name = "isLHA";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "isLHA", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.isLHA'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_SigmaProcess::isNonDiff() const {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 35;
  const char * const swig_method_name = "isNonDiff";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "isNonDiff", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.isNonDiff'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_SigmaProcess::isResolved() const {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 36;
  const char * const swig_method_name = "isResolved";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "isResolved", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.isResolved'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_SigmaProcess::isDiffA() const {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 37;
  const char * const swig_method_name = "isDiffA";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "isDiffA", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.isDiffA'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_SigmaProcess::isDiffB() const {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 38;
  const char * const swig_method_name = "isDiffB";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "isDiffB", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.isDiffB'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_SigmaProcess::isDiffC() const {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 39;
  const char * const swig_method_name = "isDiffC";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "isDiffC", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.isDiffC'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_SigmaProcess::isSUSY() const {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 40;
  const char * const swig_method_name = "isSUSY";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "isSUSY", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.isSUSY'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_SigmaProcess::allowNegativeSigma() const {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 41;
  const char * const swig_method_name = "allowNegativeSigma";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "allowNegativeSigma", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.allowNegativeSigma'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


int SwigDirector_SigmaProcess::id3Mass() const {
  int c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 42;
  const char * const swig_method_name = "id3Mass";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "id3Mass", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.id3Mass'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_SigmaProcess::id4Mass() const {
  int c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 43;
  const char * const swig_method_name = "id4Mass";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "id4Mass", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.id4Mass'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_SigmaProcess::id5Mass() const {
  int c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 44;
  const char * const swig_method_name = "id5Mass";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "id5Mass", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.id5Mass'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_SigmaProcess::resonanceA() const {
  int c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 45;
  const char * const swig_method_name = "resonanceA";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "resonanceA", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.resonanceA'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_SigmaProcess::resonanceB() const {
  int c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 46;
  const char * const swig_method_name = "resonanceB";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "resonanceB", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.resonanceB'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


bool SwigDirector_SigmaProcess::isSChannel() const {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 47;
  const char * const swig_method_name = "isSChannel";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "isSChannel", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.isSChannel'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


int SwigDirector_SigmaProcess::idSChannel() const {
  int c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 48;
  const char * const swig_method_name = "idSChannel";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "idSChannel", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.idSChannel'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


bool SwigDirector_SigmaProcess::isQCD3body() const {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 49;
  const char * const swig_method_name = "isQCD3body";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "isQCD3body", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.isQCD3body'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


int SwigDirector_SigmaProcess::idTchan1() const {
  int c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 50;
  const char * const swig_method_name = "idTchan1";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "idTchan1", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.idTchan1'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_SigmaProcess::idTchan2() const {
  int c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 51;
  const char * const swig_method_name = "idTchan2";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "idTchan2", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.idTchan2'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


double SwigDirector_SigmaProcess::tChanFracPow1() const {
  double c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 52;
  const char * const swig_method_name = "tChanFracPow1";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "tChanFracPow1", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.tChanFracPow1'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


double SwigDirector_SigmaProcess::tChanFracPow2() const {
  double c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 53;
  const char * const swig_method_name = "tChanFracPow2";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "tChanFracPow2", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.tChanFracPow2'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


bool SwigDirector_SigmaProcess::useMirrorWeight() const {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 54;
  const char * const swig_method_name = "useMirrorWeight";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "useMirrorWeight", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.useMirrorWeight'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


int SwigDirector_SigmaProcess::gmZmode() const {
  int c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 55;
  const char * const swig_method_name = "gmZmode";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "gmZmode", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.gmZmode'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


bool SwigDirector_SigmaProcess::setupForME() {
  bool c_result;
  swig_set_inner("setupForME", true);
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SigmaProcess.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 56;
  const char * const swig_method_name = "setupForME";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "setupForME", NULL);
#endif
  swig_set_inner("setupForME", false);
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SigmaProcess.setupForME'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


SwigDirector_UserHooks::SwigDirector_UserHooks(PyObject *self): Pythia8::UserHooks(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Pythia8::UserHooks *)this, this); 
}




SwigDirector_UserHooks::~SwigDirector_UserHooks() {
}

bool SwigDirector_UserHooks::initAfterBeams() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char * const swig_method_name = "initAfterBeams";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "initAfterBeams", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.initAfterBeams'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_UserHooks::canModifySigma() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char * const swig_method_name = "canModifySigma";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canModifySigma", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canModifySigma'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


double SwigDirector_UserHooks::multiplySigmaBy(Pythia8::SigmaProcess const *sigmaProcessPtr, Pythia8::PhaseSpace const *phaseSpacePtr, bool inEvent) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(sigmaProcessPtr), SWIGTYPE_p_Pythia8__SigmaProcess,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(phaseSpacePtr), SWIGTYPE_p_Pythia8__PhaseSpace,  0 );
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_bool(static_cast< bool >(inEvent));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 2;
  const char * const swig_method_name = "multiplySigmaBy";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"multiplySigmaBy", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.multiplySigmaBy'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


bool SwigDirector_UserHooks::canBiasSelection() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char * const swig_method_name = "canBiasSelection";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canBiasSelection", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canBiasSelection'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


double SwigDirector_UserHooks::biasSelectionBy(Pythia8::SigmaProcess const *sigmaProcessPtr, Pythia8::PhaseSpace const *phaseSpacePtr, bool inEvent) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(sigmaProcessPtr), SWIGTYPE_p_Pythia8__SigmaProcess,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(phaseSpacePtr), SWIGTYPE_p_Pythia8__PhaseSpace,  0 );
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_bool(static_cast< bool >(inEvent));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char * const swig_method_name = "biasSelectionBy";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"biasSelectionBy", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.biasSelectionBy'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


double SwigDirector_UserHooks::biasedSelectionWeight() {
  double c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char * const swig_method_name = "biasedSelectionWeight";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "biasedSelectionWeight", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.biasedSelectionWeight'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


bool SwigDirector_UserHooks::canVetoProcessLevel() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char * const swig_method_name = "canVetoProcessLevel";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoProcessLevel", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canVetoProcessLevel'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_UserHooks::doVetoProcessLevel(Pythia8::Event &arg0) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char * const swig_method_name = "doVetoProcessLevel";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoProcessLevel", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doVetoProcessLevel'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_UserHooks::canVetoResonanceDecays() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char * const swig_method_name = "canVetoResonanceDecays";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoResonanceDecays", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canVetoResonanceDecays'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_UserHooks::doVetoResonanceDecays(Pythia8::Event &arg0) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char * const swig_method_name = "doVetoResonanceDecays";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoResonanceDecays", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doVetoResonanceDecays'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_UserHooks::canVetoPT() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char * const swig_method_name = "canVetoPT";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoPT", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canVetoPT'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


double SwigDirector_UserHooks::scaleVetoPT() {
  double c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char * const swig_method_name = "scaleVetoPT";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "scaleVetoPT", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.scaleVetoPT'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


bool SwigDirector_UserHooks::doVetoPT(int arg0, Pythia8::Event const &arg1) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_Pythia8__Event,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char * const swig_method_name = "doVetoPT";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoPT", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doVetoPT'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_UserHooks::canVetoStep() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char * const swig_method_name = "canVetoStep";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoStep", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canVetoStep'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


int SwigDirector_UserHooks::numberVetoStep() {
  int c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char * const swig_method_name = "numberVetoStep";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "numberVetoStep", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.numberVetoStep'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


bool SwigDirector_UserHooks::doVetoStep(int arg0, int arg1, int arg2, Pythia8::Event const &arg3) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg3), SWIGTYPE_p_Pythia8__Event,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char * const swig_method_name = "doVetoStep";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoStep", (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doVetoStep'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_UserHooks::canVetoMPIStep() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 16;
  const char * const swig_method_name = "canVetoMPIStep";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoMPIStep", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canVetoMPIStep'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


int SwigDirector_UserHooks::numberVetoMPIStep() {
  int c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 17;
  const char * const swig_method_name = "numberVetoMPIStep";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "numberVetoMPIStep", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.numberVetoMPIStep'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


bool SwigDirector_UserHooks::doVetoMPIStep(int arg0, Pythia8::Event const &arg1) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_Pythia8__Event,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 18;
  const char * const swig_method_name = "doVetoMPIStep";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoMPIStep", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doVetoMPIStep'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_UserHooks::canVetoPartonLevelEarly() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 19;
  const char * const swig_method_name = "canVetoPartonLevelEarly";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoPartonLevelEarly", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canVetoPartonLevelEarly'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_UserHooks::doVetoPartonLevelEarly(Pythia8::Event const &arg0) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 20;
  const char * const swig_method_name = "doVetoPartonLevelEarly";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoPartonLevelEarly", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doVetoPartonLevelEarly'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_UserHooks::retryPartonLevel() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 21;
  const char * const swig_method_name = "retryPartonLevel";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "retryPartonLevel", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.retryPartonLevel'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_UserHooks::canVetoPartonLevel() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 22;
  const char * const swig_method_name = "canVetoPartonLevel";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoPartonLevel", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canVetoPartonLevel'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_UserHooks::doVetoPartonLevel(Pythia8::Event const &arg0) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 23;
  const char * const swig_method_name = "doVetoPartonLevel";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoPartonLevel", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doVetoPartonLevel'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_UserHooks::canSetResonanceScale() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 24;
  const char * const swig_method_name = "canSetResonanceScale";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canSetResonanceScale", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canSetResonanceScale'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


double SwigDirector_UserHooks::scaleResonance(int arg0, Pythia8::Event const &arg1) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_Pythia8__Event,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 25;
  const char * const swig_method_name = "scaleResonance";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"scaleResonance", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.scaleResonance'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


bool SwigDirector_UserHooks::canVetoISREmission() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 26;
  const char * const swig_method_name = "canVetoISREmission";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoISREmission", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canVetoISREmission'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_UserHooks::doVetoISREmission(int arg0, Pythia8::Event const &arg1, int arg2) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 27;
  const char * const swig_method_name = "doVetoISREmission";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoISREmission", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doVetoISREmission'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_UserHooks::canVetoFSREmission() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 28;
  const char * const swig_method_name = "canVetoFSREmission";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoFSREmission", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canVetoFSREmission'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_UserHooks::doVetoFSREmission(int arg0, Pythia8::Event const &arg1, int arg2, bool arg3) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_bool(static_cast< bool >(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 29;
  const char * const swig_method_name = "doVetoFSREmission";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoFSREmission", (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doVetoFSREmission'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_UserHooks::canVetoMPIEmission() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 31;
  const char * const swig_method_name = "canVetoMPIEmission";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canVetoMPIEmission", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canVetoMPIEmission'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_UserHooks::doVetoMPIEmission(int arg0, Pythia8::Event const &arg1) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_Pythia8__Event,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 32;
  const char * const swig_method_name = "doVetoMPIEmission";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoMPIEmission", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doVetoMPIEmission'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_UserHooks::canReconnectResonanceSystems() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 33;
  const char * const swig_method_name = "canReconnectResonanceSystems";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canReconnectResonanceSystems", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canReconnectResonanceSystems'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_UserHooks::doReconnectResonanceSystems(int arg0, Pythia8::Event &arg1) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_Pythia8__Event,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 34;
  const char * const swig_method_name = "doReconnectResonanceSystems";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doReconnectResonanceSystems", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doReconnectResonanceSystems'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_UserHooks::canEnhanceEmission() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 35;
  const char * const swig_method_name = "canEnhanceEmission";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canEnhanceEmission", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canEnhanceEmission'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


double SwigDirector_UserHooks::enhanceFactor(std::string arg0) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_std_string(static_cast< std::string >(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 36;
  const char * const swig_method_name = "enhanceFactor";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"enhanceFactor", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.enhanceFactor'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


double SwigDirector_UserHooks::vetoProbability(std::string arg0) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_std_string(static_cast< std::string >(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 37;
  const char * const swig_method_name = "vetoProbability";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"vetoProbability", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.vetoProbability'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


bool SwigDirector_UserHooks::canEnhanceTrial() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 38;
  const char * const swig_method_name = "canEnhanceTrial";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canEnhanceTrial", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canEnhanceTrial'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_UserHooks::canChangeFragPar() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 39;
  const char * const swig_method_name = "canChangeFragPar";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canChangeFragPar", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canChangeFragPar'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_UserHooks::doChangeFragPar(Pythia8::StringFlav *arg0, Pythia8::StringZ *arg1, Pythia8::StringPT *arg2, int arg3, double arg4, std::vector< int,std::allocator< int > > arg5) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(arg0), SWIGTYPE_p_Pythia8__StringFlav,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(arg1), SWIGTYPE_p_Pythia8__StringZ,  0 );
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(arg2), SWIGTYPE_p_Pythia8__StringPT,  0 );
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(arg3));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_double(static_cast< double >(arg4));
  swig::SwigVar_PyObject obj5;
  obj5 = swig::from(static_cast< std::vector< int,std::allocator< int > > >(arg5));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 40;
  const char * const swig_method_name = "doChangeFragPar";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doChangeFragPar", (char *)"(OOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doChangeFragPar'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_UserHooks::doVetoFragmentation(Pythia8::Particle arg0) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Particle,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 41;
  const char * const swig_method_name = "doVetoFragmentation";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"doVetoFragmentation", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doVetoFragmentation'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_UserHooks::canSetImpactParameter() const {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 42;
  const char * const swig_method_name = "canSetImpactParameter";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "canSetImpactParameter", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.canSetImpactParameter'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


double SwigDirector_UserHooks::doSetImpactParameter() {
  double c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call UserHooks.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 43;
  const char * const swig_method_name = "doSetImpactParameter";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "doSetImpactParameter", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'UserHooks.doSetImpactParameter'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


SwigDirector_PhaseSpace::SwigDirector_PhaseSpace(PyObject *self): Pythia8::PhaseSpace(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Pythia8::PhaseSpace *)this, this); 
}




SwigDirector_PhaseSpace::~SwigDirector_PhaseSpace() {
}

bool SwigDirector_PhaseSpace::setupSampling() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PhaseSpace.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char * const swig_method_name = "setupSampling";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "setupSampling", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PhaseSpace.setupSampling'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_PhaseSpace::trialKin(bool inEvent, bool repeatSame) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_bool(static_cast< bool >(inEvent));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_bool(static_cast< bool >(repeatSame));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PhaseSpace.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char * const swig_method_name = "trialKin";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"trialKin", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PhaseSpace.trialKin'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_PhaseSpace::finalKin() {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PhaseSpace.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char * const swig_method_name = "finalKin";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "finalKin", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PhaseSpace.finalKin'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


double SwigDirector_PhaseSpace::sigmaSumSigned() const {
  double c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PhaseSpace.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char * const swig_method_name = "sigmaSumSigned";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "sigmaSumSigned", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PhaseSpace.sigmaSumSigned'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


bool SwigDirector_PhaseSpace::isResolved() const {
  bool c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PhaseSpace.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char * const swig_method_name = "isResolved";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "isResolved", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PhaseSpace.isResolved'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


void SwigDirector_PhaseSpace::rescaleSigma(double arg0) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_double(static_cast< double >(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PhaseSpace.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char * const swig_method_name = "rescaleSigma";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"rescaleSigma", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PhaseSpace.rescaleSigma'");
    }
  }
}


void SwigDirector_PhaseSpace::rescaleMomenta(double arg0) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_double(static_cast< double >(arg0));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PhaseSpace.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 8;
  const char * const swig_method_name = "rescaleMomenta";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"rescaleMomenta", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PhaseSpace.rescaleMomenta'");
    }
  }
}


double SwigDirector_PhaseSpace::weightGammaPDFApprox() {
  double c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PhaseSpace.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char * const swig_method_name = "weightGammaPDFApprox";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "weightGammaPDFApprox", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PhaseSpace.weightGammaPDFApprox'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


void SwigDirector_PhaseSpace::setGammaKinPtr(Pythia8::GammaKinematics *arg0) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(arg0), SWIGTYPE_p_Pythia8__GammaKinematics,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PhaseSpace.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char * const swig_method_name = "setGammaKinPtr";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"setGammaKinPtr", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'PhaseSpace.setGammaKinPtr'");
    }
  }
}


SwigDirector_SpaceShower::SwigDirector_SpaceShower(PyObject *self): Pythia8::SpaceShower(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Pythia8::SpaceShower *)this, this); 
}




SwigDirector_SpaceShower::~SwigDirector_SpaceShower() {
}

void SwigDirector_SpaceShower::init(Pythia8::BeamParticle *beamAPtrIn, Pythia8::BeamParticle *beamBPtrIn) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(beamAPtrIn), SWIGTYPE_p_Pythia8__BeamParticle,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(beamBPtrIn), SWIGTYPE_p_Pythia8__BeamParticle,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char * const swig_method_name = "init";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"init", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.init'");
    }
  }
}


bool SwigDirector_SpaceShower::limitPTmax(Pythia8::Event &event, double Q2Fac, double Q2Ren) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&event), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_double(static_cast< double >(Q2Fac));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_double(static_cast< double >(Q2Ren));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char * const swig_method_name = "limitPTmax";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"limitPTmax", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.limitPTmax'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


double SwigDirector_SpaceShower::enhancePTmax() const {
  double c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 4;
  const char * const swig_method_name = "enhancePTmax";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "enhancePTmax", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.enhancePTmax'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


void SwigDirector_SpaceShower::prepare(int iSys, Pythia8::Event &event, bool limitPTmaxIn) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(iSys));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&event), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_bool(static_cast< bool >(limitPTmaxIn));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 5;
  const char * const swig_method_name = "prepare";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"prepare", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.prepare'");
    }
  }
}


void SwigDirector_SpaceShower::update(int arg0, Pythia8::Event &arg1, bool hasWeakRad) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(arg0));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_bool(static_cast< bool >(hasWeakRad));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char * const swig_method_name = "update";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"update", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.update'");
    }
  }
}


double SwigDirector_SpaceShower::pTnext(Pythia8::Event &event, double pTbegAll, double pTendAll, int nRadIn, bool doTrialIn) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&event), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_double(static_cast< double >(pTbegAll));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_double(static_cast< double >(pTendAll));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(nRadIn));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_bool(static_cast< bool >(doTrialIn));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char * const swig_method_name = "pTnext";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"pTnext", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.pTnext'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


bool SwigDirector_SpaceShower::branch(Pythia8::Event &event) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&event), SWIGTYPE_p_Pythia8__Event,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 12;
  const char * const swig_method_name = "branch";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"branch", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.branch'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


int SwigDirector_SpaceShower::system() const {
  int c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char * const swig_method_name = "system";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "system", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.system'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


Pythia8::Event SwigDirector_SpaceShower::clustered(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4) {
  void *swig_argp ;
  int swig_res = 0 ;
  
  Pythia8::Event c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(arg3));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_std_string(static_cast< std::string >(arg4));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char * const swig_method_name = "clustered";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"clustered", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.clustered'");
    }
  }
  swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Pythia8::Event""'");
  }
  c_result = *(reinterpret_cast< Pythia8::Event * >(swig_argp));
  if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< Pythia8::Event * >(swig_argp);
  return (Pythia8::Event) c_result;
}


std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > SwigDirector_SpaceShower::getStateVariables(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4) {
  void *swig_argp ;
  int swig_res = 0 ;
  
  std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(arg3));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_std_string(static_cast< std::string >(arg4));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 15;
  const char * const swig_method_name = "getStateVariables";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"getStateVariables", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.getStateVariables'");
    }
  }
  swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t,  0  | 0);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > >""'");
  }
  c_result = *(reinterpret_cast< std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > * >(swig_argp));
  if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > * >(swig_argp);
  return (std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > >) c_result;
}


bool SwigDirector_SpaceShower::isSpacelike(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(arg3));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_std_string(static_cast< std::string >(arg4));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 16;
  const char * const swig_method_name = "isSpacelike";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"isSpacelike", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.isSpacelike'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


std::vector< std::string,std::allocator< std::string > > SwigDirector_SpaceShower::getSplittingName(Pythia8::Event const &arg0, int arg1, int arg2, int arg3) {
  std::vector< std::string,std::allocator< std::string > > c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 17;
  const char * const swig_method_name = "getSplittingName";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"getSplittingName", (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.getSplittingName'");
    }
  }
  std::vector< std::string,std::allocator< std::string > > *swig_optr = 0;
  int swig_ores = swig::asptr(result, &swig_optr);
  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< std::string,std::allocator< std::string > >""'");
  }
  c_result = *swig_optr;
  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
  return (std::vector< std::string,std::allocator< std::string > >) c_result;
}


double SwigDirector_SpaceShower::getSplittingProb(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(arg3));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_std_string(static_cast< std::string >(arg4));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 18;
  const char * const swig_method_name = "getSplittingProb";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"getSplittingProb", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.getSplittingProb'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


bool SwigDirector_SpaceShower::allowedSplitting(Pythia8::Event const &arg0, int arg1, int arg2) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 19;
  const char * const swig_method_name = "allowedSplitting";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"allowedSplitting", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.allowedSplitting'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


std::vector< int,std::allocator< int > > SwigDirector_SpaceShower::getRecoilers(Pythia8::Event const &arg0, int arg1, int arg2, std::string arg3) {
  std::vector< int,std::allocator< int > > c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_std_string(static_cast< std::string >(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call SpaceShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 20;
  const char * const swig_method_name = "getRecoilers";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"getRecoilers", (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'SpaceShower.getRecoilers'");
    }
  }
  std::vector< int,std::allocator< int > > *swig_optr = 0;
  int swig_ores = swig::asptr(result, &swig_optr);
  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< int,std::allocator< int > >""'");
  }
  c_result = *swig_optr;
  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
  return (std::vector< int,std::allocator< int > >) c_result;
}


SwigDirector_TimeShower::SwigDirector_TimeShower(PyObject *self): Pythia8::TimeShower(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Pythia8::TimeShower *)this, this); 
}




SwigDirector_TimeShower::~SwigDirector_TimeShower() {
}

void SwigDirector_TimeShower::init(Pythia8::BeamParticle *beamAPtrIn, Pythia8::BeamParticle *beamBPtrIn) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(beamAPtrIn), SWIGTYPE_p_Pythia8__BeamParticle,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(beamBPtrIn), SWIGTYPE_p_Pythia8__BeamParticle,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char * const swig_method_name = "init";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"init", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.init'");
    }
  }
}


bool SwigDirector_TimeShower::limitPTmax(Pythia8::Event &event, double Q2Fac, double Q2Ren) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&event), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_double(static_cast< double >(Q2Fac));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_double(static_cast< double >(Q2Ren));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 3;
  const char * const swig_method_name = "limitPTmax";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"limitPTmax", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.limitPTmax'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


double SwigDirector_TimeShower::enhancePTmax() {
  double c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 6;
  const char * const swig_method_name = "enhancePTmax";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "enhancePTmax", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.enhancePTmax'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


int SwigDirector_TimeShower::shower(int iBeg, int iEnd, Pythia8::Event &event, double pTmax, int nBranchMax) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(iBeg));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(iEnd));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(&event), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_double(static_cast< double >(pTmax));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< int >(nBranchMax));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 7;
  const char * const swig_method_name = "shower";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"shower", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.shower'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


int SwigDirector_TimeShower::showerQED(int i1, int i2, Pythia8::Event &event, double pTmax) {
  int c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(i1));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(i2));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(&event), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_double(static_cast< double >(pTmax));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 9;
  const char * const swig_method_name = "showerQED";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"showerQED", (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.showerQED'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


void SwigDirector_TimeShower::prepareGlobal(Pythia8::Event &event) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&event), SWIGTYPE_p_Pythia8__Event,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 10;
  const char * const swig_method_name = "prepareGlobal";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"prepareGlobal", (char *)"(O)" ,(PyObject *)obj0);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.prepareGlobal'");
    }
  }
}


void SwigDirector_TimeShower::prepare(int iSys, Pythia8::Event &event, bool limitPTmaxIn) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(iSys));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&event), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_bool(static_cast< bool >(limitPTmaxIn));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 11;
  const char * const swig_method_name = "prepare";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"prepare", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.prepare'");
    }
  }
}


void SwigDirector_TimeShower::rescatterUpdate(int iSys, Pythia8::Event &event) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(iSys));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&event), SWIGTYPE_p_Pythia8__Event,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 13;
  const char * const swig_method_name = "rescatterUpdate";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"rescatterUpdate", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.rescatterUpdate'");
    }
  }
}


void SwigDirector_TimeShower::update(int iSys, Pythia8::Event &event, bool hasWeakRad) {
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_From_int(static_cast< int >(iSys));
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&event), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_bool(static_cast< bool >(hasWeakRad));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 14;
  const char * const swig_method_name = "update";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"update", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.update'");
    }
  }
}


double SwigDirector_TimeShower::pTnext(Pythia8::Event &event, double pTbegAll, double pTendAll, bool isFirstTrial, bool doTrialIn) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&event), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_double(static_cast< double >(pTbegAll));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_double(static_cast< double >(pTendAll));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_bool(static_cast< bool >(isFirstTrial));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_bool(static_cast< bool >(doTrialIn));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 16;
  const char * const swig_method_name = "pTnext";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"pTnext", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.pTnext'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


bool SwigDirector_TimeShower::branch(Pythia8::Event &event, bool isInterleaved) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&event), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_bool(static_cast< bool >(isInterleaved));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 19;
  const char * const swig_method_name = "branch";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"branch", (char *)"(OO)" ,(PyObject *)obj0,(PyObject *)obj1);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.branch'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


int SwigDirector_TimeShower::system() const {
  int c_result;
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 21;
  const char * const swig_method_name = "system";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "system", NULL);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.system'");
    }
  }
  int swig_val;
  int swig_res = SWIG_AsVal_int(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'");
  }
  c_result = static_cast< int >(swig_val);
  return (int) c_result;
}


Pythia8::Event SwigDirector_TimeShower::clustered(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4) {
  void *swig_argp ;
  int swig_res = 0 ;
  
  Pythia8::Event c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(arg3));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_std_string(static_cast< std::string >(arg4));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 22;
  const char * const swig_method_name = "clustered";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"clustered", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.clustered'");
    }
  }
  swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""Pythia8::Event""'");
  }
  c_result = *(reinterpret_cast< Pythia8::Event * >(swig_argp));
  if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< Pythia8::Event * >(swig_argp);
  return (Pythia8::Event) c_result;
}


std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > SwigDirector_TimeShower::getStateVariables(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4) {
  void *swig_argp ;
  int swig_res = 0 ;
  
  std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(arg3));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_std_string(static_cast< std::string >(arg4));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 23;
  const char * const swig_method_name = "getStateVariables";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"getStateVariables", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.getStateVariables'");
    }
  }
  swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t,  0  | 0);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > >""'");
  }
  c_result = *(reinterpret_cast< std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > * >(swig_argp));
  if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > * >(swig_argp);
  return (std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > >) c_result;
}


bool SwigDirector_TimeShower::isTimelike(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(arg3));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_std_string(static_cast< std::string >(arg4));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 24;
  const char * const swig_method_name = "isTimelike";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"isTimelike", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.isTimelike'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


std::vector< std::string,std::allocator< std::string > > SwigDirector_TimeShower::getSplittingName(Pythia8::Event const &arg0, int arg1, int arg2, int arg3) {
  std::vector< std::string,std::allocator< std::string > > c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 25;
  const char * const swig_method_name = "getSplittingName";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"getSplittingName", (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.getSplittingName'");
    }
  }
  std::vector< std::string,std::allocator< std::string > > *swig_optr = 0;
  int swig_ores = swig::asptr(result, &swig_optr);
  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< std::string,std::allocator< std::string > >""'");
  }
  c_result = *swig_optr;
  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
  return (std::vector< std::string,std::allocator< std::string > >) c_result;
}


double SwigDirector_TimeShower::getSplittingProb(Pythia8::Event const &arg0, int arg1, int arg2, int arg3, std::string arg4) {
  double c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(arg3));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_std_string(static_cast< std::string >(arg4));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 26;
  const char * const swig_method_name = "getSplittingProb";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"getSplittingProb", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.getSplittingProb'");
    }
  }
  double swig_val;
  int swig_res = SWIG_AsVal_double(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""double""'");
  }
  c_result = static_cast< double >(swig_val);
  return (double) c_result;
}


bool SwigDirector_TimeShower::allowedSplitting(Pythia8::Event const &arg0, int arg1, int arg2) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 27;
  const char * const swig_method_name = "allowedSplitting";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"allowedSplitting", (char *)"(OOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.allowedSplitting'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


std::vector< int,std::allocator< int > > SwigDirector_TimeShower::getRecoilers(Pythia8::Event const &arg0, int arg1, int arg2, std::string arg3) {
  std::vector< int,std::allocator< int > > c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_Pythia8__Event,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_From_int(static_cast< int >(arg1));
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_From_int(static_cast< int >(arg2));
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_std_string(static_cast< std::string >(arg3));
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeShower.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 28;
  const char * const swig_method_name = "getRecoilers";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"getRecoilers", (char *)"(OOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'TimeShower.getRecoilers'");
    }
  }
  std::vector< int,std::allocator< int > > *swig_optr = 0;
  int swig_ores = swig::asptr(result, &swig_optr);
  if (!SWIG_IsOK(swig_ores) || !swig_optr) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< int,std::allocator< int > >""'");
  }
  c_result = *swig_optr;
  if (SWIG_IsNewObj(swig_ores)) delete swig_optr;
  return (std::vector< int,std::allocator< int > >) c_result;
}


SwigDirector_DecayHandler::SwigDirector_DecayHandler(PyObject *self): Pythia8::DecayHandler(), Swig::Director(self) {
  SWIG_DIRECTOR_RGTR((Pythia8::DecayHandler *)this, this); 
}




SwigDirector_DecayHandler::~SwigDirector_DecayHandler() {
}

bool SwigDirector_DecayHandler::decay(std::vector< int,std::allocator< int > > &arg0, std::vector< double,std::allocator< double > > &arg1, std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > &arg2, int arg3, Pythia8::Event const &arg4) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg2), SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t,  0 );
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_From_int(static_cast< int >(arg3));
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg4), SWIGTYPE_p_Pythia8__Event,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call DecayHandler.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 0;
  const char * const swig_method_name = "decay";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"decay", (char *)"(OOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'DecayHandler.decay'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_DecayHandler::chainDecay(std::vector< int,std::allocator< int > > &arg0, std::vector< int,std::allocator< int > > &arg1, std::vector< double,std::allocator< double > > &arg2, std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > &arg3, int arg4, Pythia8::Event const &arg5) {
  bool c_result;
  swig::SwigVar_PyObject obj0;
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  swig::SwigVar_PyObject obj1;
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg1), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  swig::SwigVar_PyObject obj2;
  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg2), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  swig::SwigVar_PyObject obj3;
  obj3 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg3), SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t,  0 );
  swig::SwigVar_PyObject obj4;
  obj4 = SWIG_From_int(static_cast< int >(arg4));
  swig::SwigVar_PyObject obj5;
  obj5 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg5), SWIGTYPE_p_Pythia8__Event,  0 );
  if (!swig_get_self()) {
    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call DecayHandler.__init__.");
  }
#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
  const size_t swig_method_index = 1;
  const char * const swig_method_name = "chainDecay";
  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(OOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5);
#else
  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"chainDecay", (char *)"(OOOOOO)" ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5);
#endif
  if (!result) {
    PyObject *error = PyErr_Occurred();
    if (error) {
      Swig::DirectorMethodException::raise("Error detected when calling 'DecayHandler.chainDecay'");
    }
  }
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SwigPyIterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwigPyIterator" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_value",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_value" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    result = (PyObject *)((swig::SwigPyIterator const *)arg1)->value();
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_incr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_incr" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  try {
    result = (swig::SwigPyIterator *)(arg1)->incr(arg2);
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_incr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    result = (swig::SwigPyIterator *)(arg1)->incr();
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


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


SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_decr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_decr" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  try {
    result = (swig::SwigPyIterator *)(arg1)->decr(arg2);
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_decr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    result = (swig::SwigPyIterator *)(arg1)->decr();
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


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


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


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


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


SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_next",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    result = (PyObject *)(arg1)->next();
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator___next__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    result = (PyObject *)(arg1)->__next__();
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_previous",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    result = (PyObject *)(arg1)->previous();
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_advance",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::SwigPyIterator *)(arg1)->advance(arg2);
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___eq__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___ne__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___iadd__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___isub__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___add__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  ptrdiff_t result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
  resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SwigPyIterator___sub____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SwigPyIterator___sub____SWIG_0(self, args);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN int Swig_var_ios_base_boolalpha_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_boolalpha is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_boolalpha_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::boolalpha));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_dec_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_dec is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_dec_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::dec));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_fixed_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_fixed is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_fixed_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::fixed));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_hex_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_hex is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_hex_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::hex));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_internal_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_internal is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_internal_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::internal));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_left_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_left is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_left_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::left));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_oct_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_oct is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_oct_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::oct));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_right_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_right is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_right_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::right));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_scientific_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_scientific is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_scientific_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::scientific));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_showbase_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_showbase is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_showbase_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::showbase));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_showpoint_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_showpoint is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_showpoint_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::showpoint));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_showpos_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_showpos is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_showpos_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::showpos));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_skipws_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_skipws is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_skipws_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::skipws));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_unitbuf_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_unitbuf is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_unitbuf_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::unitbuf));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_uppercase_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_uppercase is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_uppercase_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::uppercase));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_adjustfield_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_adjustfield is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_adjustfield_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::adjustfield));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_basefield_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_basefield is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_basefield_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::basefield));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_floatfield_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_floatfield is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_floatfield_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::floatfield));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_badbit_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_badbit is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_badbit_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::badbit));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_eofbit_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_eofbit is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_eofbit_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::eofbit));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_failbit_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_failbit is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_failbit_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::failbit));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_goodbit_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_goodbit is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_goodbit_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::goodbit));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_app_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_app is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_app_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::app));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_ate_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_ate is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_ate_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::ate));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_binary_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_binary is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_binary_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::binary));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_ios_base_in_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_ios_base_in is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_ios_base_in_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::in));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_out_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_out is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_out_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::out));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_trunc_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_trunc is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_trunc_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::trunc));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_beg_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_beg is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_beg_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::beg));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_cur_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_cur is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_cur_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::cur));
  return pyobj;
}


SWIGINTERN int Swig_var_ios_base_end_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ios_base_end is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ios_base_end_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(std::ios_base::end));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_ios_base_register_callback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ios_base *arg1 = (std::ios_base *) 0 ;
  std::ios_base::event_callback arg2 = (std::ios_base::event_callback) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ios_base_register_callback",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_register_callback" "', argument " "1"" of type '" "std::ios_base *""'"); 
  }
  arg1 = reinterpret_cast< std::ios_base * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_enum_std__ios_base__event_r_std__ios_base_int__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ios_base_register_callback" "', argument " "2"" of type '" "std::ios_base::event_callback""'"); 
    }
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ios_base_register_callback" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->register_callback(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_base_flags__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ios_base *arg1 = (std::ios_base *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::ios_base::fmtflags result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ios_base_flags",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_flags" "', argument " "1"" of type '" "std::ios_base const *""'"); 
  }
  arg1 = reinterpret_cast< std::ios_base * >(argp1);
  result = (std::ios_base::fmtflags)((std::ios_base const *)arg1)->flags();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_base_flags__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ios_base *arg1 = (std::ios_base *) 0 ;
  std::ios_base::fmtflags arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::ios_base::fmtflags result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ios_base_flags",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_flags" "', argument " "1"" of type '" "std::ios_base *""'"); 
  }
  arg1 = reinterpret_cast< std::ios_base * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_base_flags" "', argument " "2"" of type '" "std::ios_base::fmtflags""'");
  } 
  arg2 = static_cast< std::ios_base::fmtflags >(val2);
  result = (std::ios_base::fmtflags)(arg1)->flags(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_base_flags(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ios_base, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ios_base_flags__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ios_base, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ios_base_flags__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ios_base_flags'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::ios_base::flags() const\n"
    "    std::ios_base::flags(std::ios_base::fmtflags)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ios_base_setf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ios_base *arg1 = (std::ios_base *) 0 ;
  std::ios_base::fmtflags arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::ios_base::fmtflags result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ios_base_setf",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_setf" "', argument " "1"" of type '" "std::ios_base *""'"); 
  }
  arg1 = reinterpret_cast< std::ios_base * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_base_setf" "', argument " "2"" of type '" "std::ios_base::fmtflags""'");
  } 
  arg2 = static_cast< std::ios_base::fmtflags >(val2);
  result = (std::ios_base::fmtflags)(arg1)->setf(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_base_setf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ios_base *arg1 = (std::ios_base *) 0 ;
  std::ios_base::fmtflags arg2 ;
  std::ios_base::fmtflags arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::ios_base::fmtflags result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ios_base_setf",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_setf" "', argument " "1"" of type '" "std::ios_base *""'"); 
  }
  arg1 = reinterpret_cast< std::ios_base * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_base_setf" "', argument " "2"" of type '" "std::ios_base::fmtflags""'");
  } 
  arg2 = static_cast< std::ios_base::fmtflags >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ios_base_setf" "', argument " "3"" of type '" "std::ios_base::fmtflags""'");
  } 
  arg3 = static_cast< std::ios_base::fmtflags >(val3);
  result = (std::ios_base::fmtflags)(arg1)->setf(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_base_setf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ios_base, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ios_base_setf__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ios_base, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ios_base_setf__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ios_base_setf'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::ios_base::setf(std::ios_base::fmtflags)\n"
    "    std::ios_base::setf(std::ios_base::fmtflags,std::ios_base::fmtflags)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ios_base_unsetf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ios_base *arg1 = (std::ios_base *) 0 ;
  std::ios_base::fmtflags arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ios_base_unsetf",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_unsetf" "', argument " "1"" of type '" "std::ios_base *""'"); 
  }
  arg1 = reinterpret_cast< std::ios_base * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_base_unsetf" "', argument " "2"" of type '" "std::ios_base::fmtflags""'");
  } 
  arg2 = static_cast< std::ios_base::fmtflags >(val2);
  (arg1)->unsetf(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_base_precision__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ios_base *arg1 = (std::ios_base *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::streamsize result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ios_base_precision",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_precision" "', argument " "1"" of type '" "std::ios_base const *""'"); 
  }
  arg1 = reinterpret_cast< std::ios_base * >(argp1);
  result = ((std::ios_base const *)arg1)->precision();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_base_precision__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ios_base *arg1 = (std::ios_base *) 0 ;
  std::streamsize arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::streamsize result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ios_base_precision",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_precision" "', argument " "1"" of type '" "std::ios_base *""'"); 
  }
  arg1 = reinterpret_cast< std::ios_base * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_base_precision" "', argument " "2"" of type '" "std::streamsize""'");
  } 
  arg2 = static_cast< std::streamsize >(val2);
  result = (arg1)->precision(arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_base_precision(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ios_base, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ios_base_precision__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ios_base, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ios_base_precision__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ios_base_precision'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::ios_base::precision() const\n"
    "    std::ios_base::precision(std::streamsize)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ios_base_width__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ios_base *arg1 = (std::ios_base *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::streamsize result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ios_base_width",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_width" "', argument " "1"" of type '" "std::ios_base const *""'"); 
  }
  arg1 = reinterpret_cast< std::ios_base * >(argp1);
  result = ((std::ios_base const *)arg1)->width();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_base_width__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ios_base *arg1 = (std::ios_base *) 0 ;
  std::streamsize arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::streamsize result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ios_base_width",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_width" "', argument " "1"" of type '" "std::ios_base *""'"); 
  }
  arg1 = reinterpret_cast< std::ios_base * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_base_width" "', argument " "2"" of type '" "std::streamsize""'");
  } 
  arg2 = static_cast< std::streamsize >(val2);
  result = (arg1)->width(arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_base_width(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ios_base, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ios_base_width__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ios_base, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ios_base_width__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ios_base_width'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::ios_base::width() const\n"
    "    std::ios_base::width(std::streamsize)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ios_base_sync_with_stdio__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ios_base_sync_with_stdio",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ios_base_sync_with_stdio" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  result = (bool)std::ios_base::sync_with_stdio(arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_base_sync_with_stdio__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)":ios_base_sync_with_stdio")) SWIG_fail;
  result = (bool)std::ios_base::sync_with_stdio();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_base_sync_with_stdio(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_ios_base_sync_with_stdio__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_ios_base_sync_with_stdio__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ios_base_sync_with_stdio'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::ios_base::sync_with_stdio(bool)\n"
    "    std::ios_base::sync_with_stdio()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ios_base_imbue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ios_base *arg1 = (std::ios_base *) 0 ;
  std::locale *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::locale result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ios_base_imbue",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_imbue" "', argument " "1"" of type '" "std::ios_base *""'"); 
  }
  arg1 = reinterpret_cast< std::ios_base * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__locale,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ios_base_imbue" "', argument " "2"" of type '" "std::locale const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ios_base_imbue" "', argument " "2"" of type '" "std::locale const &""'"); 
  }
  arg2 = reinterpret_cast< std::locale * >(argp2);
  result = (arg1)->imbue((std::locale const &)*arg2);
  resultobj = SWIG_NewPointerObj((new std::locale(static_cast< const std::locale& >(result))), SWIGTYPE_p_std__locale, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_base_getloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ios_base *arg1 = (std::ios_base *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::locale result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ios_base_getloc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_getloc" "', argument " "1"" of type '" "std::ios_base const *""'"); 
  }
  arg1 = reinterpret_cast< std::ios_base * >(argp1);
  result = ((std::ios_base const *)arg1)->getloc();
  resultobj = SWIG_NewPointerObj((new std::locale(static_cast< const std::locale& >(result))), SWIGTYPE_p_std__locale, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_base_xalloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)":ios_base_xalloc")) SWIG_fail;
  result = (int)std::ios_base::xalloc();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_base_iword(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ios_base *arg1 = (std::ios_base *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  long *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ios_base_iword",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_iword" "', argument " "1"" of type '" "std::ios_base *""'"); 
  }
  arg1 = reinterpret_cast< std::ios_base * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_base_iword" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (long *) &(arg1)->iword(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_long, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_base_pword(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ios_base *arg1 = (std::ios_base *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  void **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ios_base_pword",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_base_pword" "', argument " "1"" of type '" "std::ios_base *""'"); 
  }
  arg1 = reinterpret_cast< std::ios_base * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_base_pword" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (void **) &(arg1)->pword(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ios_base(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ios_base *arg1 = (std::ios_base *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ios_base",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__ios_base, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ios_base" "', argument " "1"" of type '" "std::ios_base *""'"); 
  }
  arg1 = reinterpret_cast< std::ios_base * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ios_base_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__ios_base, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_ios_rdstate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::ios_base::iostate result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ios_rdstate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_rdstate" "', argument " "1"" of type '" "std::basic_ios< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
  result = (std::ios_base::iostate)((std::basic_ios< char > const *)arg1)->rdstate();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_clear__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
  std::ios_base::iostate arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ios_clear",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_clear" "', argument " "1"" of type '" "std::basic_ios< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_clear" "', argument " "2"" of type '" "std::ios_base::iostate""'");
  } 
  arg2 = static_cast< std::ios_base::iostate >(val2);
  (arg1)->clear(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_clear__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ios_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_clear" "', argument " "1"" of type '" "std::basic_ios< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_clear(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ios_clear__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ios_clear__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ios_clear'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_ios< char >::clear(std::ios_base::iostate)\n"
    "    std::basic_ios< char >::clear()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ios_setstate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
  std::ios_base::iostate arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ios_setstate",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_setstate" "', argument " "1"" of type '" "std::basic_ios< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_setstate" "', argument " "2"" of type '" "std::ios_base::iostate""'");
  } 
  arg2 = static_cast< std::ios_base::iostate >(val2);
  (arg1)->setstate(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_good(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ios_good",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_good" "', argument " "1"" of type '" "std::basic_ios< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
  result = (bool)((std::basic_ios< char > const *)arg1)->good();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ios_eof",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_eof" "', argument " "1"" of type '" "std::basic_ios< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
  result = (bool)((std::basic_ios< char > const *)arg1)->eof();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_fail(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ios_fail",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_fail" "', argument " "1"" of type '" "std::basic_ios< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
  result = (bool)((std::basic_ios< char > const *)arg1)->fail();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_bad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ios_bad",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_bad" "', argument " "1"" of type '" "std::basic_ios< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
  result = (bool)((std::basic_ios< char > const *)arg1)->bad();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_exceptions__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::ios_base::iostate result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ios_exceptions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_exceptions" "', argument " "1"" of type '" "std::basic_ios< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
  result = (std::ios_base::iostate)((std::basic_ios< char > const *)arg1)->exceptions();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_exceptions__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
  std::ios_base::iostate arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ios_exceptions",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_exceptions" "', argument " "1"" of type '" "std::basic_ios< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_exceptions" "', argument " "2"" of type '" "std::ios_base::iostate""'");
  } 
  arg2 = static_cast< std::ios_base::iostate >(val2);
  (arg1)->exceptions(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_exceptions(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ios_exceptions__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ios_exceptions__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ios_exceptions'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_ios< char >::exceptions() const\n"
    "    std::basic_ios< char >::exceptions(std::ios_base::iostate)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_ios(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_streambuf< char,std::char_traits< char > > *arg1 = (std::basic_streambuf< char,std::char_traits< char > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_ios< char > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ios",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ios" "', argument " "1"" of type '" "std::basic_streambuf< char,std::char_traits< char > > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_streambuf< char,std::char_traits< char > > * >(argp1);
  result = (std::basic_ios< char > *)new std::basic_ios< char >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ios(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ios",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ios" "', argument " "1"" of type '" "std::basic_ios< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_tie__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ios_tie",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_tie" "', argument " "1"" of type '" "std::basic_ios< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
  result = (std::basic_ostream< char,std::char_traits< char > > *)((std::basic_ios< char > const *)arg1)->tie();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_tie__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
  std::basic_ostream< char,std::char_traits< char > > *arg2 = (std::basic_ostream< char,std::char_traits< char > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ios_tie",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_tie" "', argument " "1"" of type '" "std::basic_ios< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ios_tie" "', argument " "2"" of type '" "std::basic_ostream< char,std::char_traits< char > > *""'"); 
  }
  arg2 = reinterpret_cast< std::basic_ostream< char,std::char_traits< char > > * >(argp2);
  result = (std::basic_ostream< char,std::char_traits< char > > *)(arg1)->tie(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_tie(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ios_tie__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ios_tie__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ios_tie'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_ios< char >::tie() const\n"
    "    std::basic_ios< char >::tie(std::basic_ostream< char,std::char_traits< char > > *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ios_rdbuf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_streambuf< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ios_rdbuf",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_rdbuf" "', argument " "1"" of type '" "std::basic_ios< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
  result = (std::basic_streambuf< char,std::char_traits< char > > *)((std::basic_ios< char > const *)arg1)->rdbuf();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_rdbuf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
  std::basic_streambuf< char,std::char_traits< char > > *arg2 = (std::basic_streambuf< char,std::char_traits< char > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_streambuf< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ios_rdbuf",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_rdbuf" "', argument " "1"" of type '" "std::basic_ios< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ios_rdbuf" "', argument " "2"" of type '" "std::basic_streambuf< char,std::char_traits< char > > *""'"); 
  }
  arg2 = reinterpret_cast< std::basic_streambuf< char,std::char_traits< char > > * >(argp2);
  result = (std::basic_streambuf< char,std::char_traits< char > > *)(arg1)->rdbuf(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_rdbuf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ios_rdbuf__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ios_rdbuf__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ios_rdbuf'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_ios< char >::rdbuf() const\n"
    "    std::basic_ios< char >::rdbuf(std::basic_streambuf< char,std::char_traits< char > > *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ios_copyfmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
  std::basic_ios< char > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_ios< char > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ios_copyfmt",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_copyfmt" "', argument " "1"" of type '" "std::basic_ios< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ios_copyfmt" "', argument " "2"" of type '" "std::basic_ios< char > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ios_copyfmt" "', argument " "2"" of type '" "std::basic_ios< char > const &""'"); 
  }
  arg2 = reinterpret_cast< std::basic_ios< char > * >(argp2);
  result = (std::basic_ios< char > *) &(arg1)->copyfmt((std::basic_ios< char > const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_fill__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_ios< char >::char_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ios_fill",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_fill" "', argument " "1"" of type '" "std::basic_ios< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
  result = (std::basic_ios< char >::char_type)((std::basic_ios< char > const *)arg1)->fill();
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_fill__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
  std::basic_ios< char >::char_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_ios< char >::char_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ios_fill",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_fill" "', argument " "1"" of type '" "std::basic_ios< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
  ecode2 = SWIG_AsVal_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_fill" "', argument " "2"" of type '" "std::basic_ios< char >::char_type""'");
  } 
  arg2 = static_cast< std::basic_ios< char >::char_type >(val2);
  result = (std::basic_ios< char >::char_type)(arg1)->fill(arg2);
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_fill(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ios_fill__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ios_fill__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ios_fill'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_ios< char >::fill() const\n"
    "    std::basic_ios< char >::fill(std::basic_ios< char >::char_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ios_imbue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
  std::locale *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::locale result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ios_imbue",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_imbue" "', argument " "1"" of type '" "std::basic_ios< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__locale,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ios_imbue" "', argument " "2"" of type '" "std::locale const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ios_imbue" "', argument " "2"" of type '" "std::locale const &""'"); 
  }
  arg2 = reinterpret_cast< std::locale * >(argp2);
  result = (arg1)->imbue((std::locale const &)*arg2);
  resultobj = SWIG_NewPointerObj((new std::locale(static_cast< const std::locale& >(result))), SWIGTYPE_p_std__locale, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_narrow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
  std::basic_ios< char >::char_type arg2 ;
  char arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ios_narrow",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_narrow" "', argument " "1"" of type '" "std::basic_ios< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
  ecode2 = SWIG_AsVal_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_narrow" "', argument " "2"" of type '" "std::basic_ios< char >::char_type""'");
  } 
  arg2 = static_cast< std::basic_ios< char >::char_type >(val2);
  ecode3 = SWIG_AsVal_char(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ios_narrow" "', argument " "3"" of type '" "char""'");
  } 
  arg3 = static_cast< char >(val3);
  result = (char)((std::basic_ios< char > const *)arg1)->narrow(arg2,arg3);
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ios_widen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ios< char > *arg1 = (std::basic_ios< char > *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_ios< char >::char_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ios_widen",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ios_widen" "', argument " "1"" of type '" "std::basic_ios< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ios< char > * >(argp1);
  ecode2 = SWIG_AsVal_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ios_widen" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  result = (std::basic_ios< char >::char_type)((std::basic_ios< char > const *)arg1)->widen(arg2);
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ios_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__basic_iosT_char_std__char_traitsT_char_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN int Swig_var_cin_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable cin is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_cin_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&std::cin), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_cout_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable cout is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_cout_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&std::cout), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_cerr_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable cerr is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_cerr_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&std::cerr), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_clog_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable clog is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_clog_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&std::clog), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  return pyobj;
}


SWIGINTERN PyObject *_wrap_new_ostream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_streambuf< char,std::char_traits< char > > *arg1 = (std::basic_streambuf< char,std::char_traits< char > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_ostream< char > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ostream",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ostream" "', argument " "1"" of type '" "std::basic_streambuf< char,std::char_traits< char > > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_streambuf< char,std::char_traits< char > > * >(argp1);
  result = (std::basic_ostream< char > *)new std::basic_ostream< char >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ostream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ostream",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ostream" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  std::basic_ostream< char,std::char_traits< char > > &(*arg2)(std::basic_ostream< char,std::char_traits< char > > &) = (std::basic_ostream< char,std::char_traits< char > > &(*)(std::basic_ostream< char,std::char_traits< char > > &)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "std::basic_ostream< char,std::char_traits< char > > &(*)(std::basic_ostream< char,std::char_traits< char > > &)""'"); 
    }
  }
  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  std::basic_ios< char,std::char_traits< char > > &(*arg2)(std::basic_ios< char,std::char_traits< char > > &) = (std::basic_ios< char,std::char_traits< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "std::basic_ios< char,std::char_traits< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &)""'"); 
    }
  }
  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  std::ios_base &(*arg2)(std::ios_base &) = (std::ios_base &(*)(std::ios_base &)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_r_std__ios_base__r_std__ios_base);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "std::ios_base &(*)(std::ios_base &)""'"); 
    }
  }
  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  ecode2 = SWIG_AsVal_long(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  ecode2 = SWIG_AsVal_short(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "unsigned short""'");
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  long long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long long val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "long long""'");
  } 
  arg2 = static_cast< long long >(val2);
  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  unsigned long long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "unsigned long long""'");
  } 
  arg2 = static_cast< unsigned long long >(val2);
  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  ecode2 = SWIG_AsVal_float(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  long double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_long_double,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "long double""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ostream___lshift__" "', argument " "2"" of type '" "long double""'");
    } else {
      long double * temp = reinterpret_cast< long double * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "void const *""'"); 
  }
  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<((void const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  std::basic_streambuf< char,std::char_traits< char > > *arg2 = (std::basic_streambuf< char,std::char_traits< char > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "std::basic_streambuf< char,std::char_traits< char > > *""'"); 
  }
  arg2 = reinterpret_cast< std::basic_streambuf< char,std::char_traits< char > > * >(argp2);
  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->operator <<(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostream___lshift____SWIG_17(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  std::basic_string< char,std::char_traits< char >,std::allocator< char > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ostream___lshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream___lshift__" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ostream___lshift__" "', argument " "2"" of type '" "std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ostream___lshift__" "', argument " "2"" of type '" "std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'"); 
  }
  arg2 = reinterpret_cast< std::basic_string< char,std::char_traits< char >,std::allocator< char > > * >(argp2);
  result = (std::basic_ostream< char,std::char_traits< char > > *) &std_basic_ostream_Sl_char_Sg__operator_Sl__Sl___SWIG_17(arg1,(std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostream___lshift__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ostream___lshift____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ostream___lshift____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_std__ios_base__r_std__ios_base);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ostream___lshift____SWIG_2(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_long_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ostream___lshift____SWIG_14(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ostream___lshift____SWIG_16(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ostream___lshift____SWIG_17(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ostream___lshift____SWIG_15(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ostream___lshift____SWIG_5(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ostream___lshift____SWIG_7(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ostream___lshift____SWIG_6(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ostream___lshift____SWIG_9(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ostream___lshift____SWIG_8(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ostream___lshift____SWIG_4(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ostream___lshift____SWIG_3(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ostream___lshift____SWIG_11(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ostream___lshift____SWIG_10(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ostream___lshift____SWIG_13(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ostream___lshift____SWIG_12(self, args);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_ostream_put(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  std::basic_ostream< char >::char_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ostream_put",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream_put" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  ecode2 = SWIG_AsVal_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ostream_put" "', argument " "2"" of type '" "std::basic_ostream< char >::char_type""'");
  } 
  arg2 = static_cast< std::basic_ostream< char >::char_type >(val2);
  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->put(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  std::basic_ostream< char >::char_type *arg2 = (std::basic_ostream< char >::char_type *) 0 ;
  std::streamsize arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ostream_write",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream_write" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ostream_write" "', argument " "2"" of type '" "std::basic_ostream< char >::char_type const *""'");
  }
  arg2 = reinterpret_cast< std::basic_ostream< char >::char_type * >(buf2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ostream_write" "', argument " "3"" of type '" "std::streamsize""'");
  } 
  arg3 = static_cast< std::streamsize >(val3);
  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->write((std::basic_ostream< char >::char_type const *)arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ostream_flush",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream_flush" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->flush();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostream_tellp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_ostream< char >::pos_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ostream_tellp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream_tellp" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  result = (arg1)->tellp();
  resultobj = SWIG_NewPointerObj((new std::basic_ostream< char >::pos_type(static_cast< const std::basic_ostream< char >::pos_type& >(result))), SWIGTYPE_p_streampos, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostream_seekp__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  std::basic_ostream< char >::pos_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ostream_seekp",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream_seekp" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_streampos,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ostream_seekp" "', argument " "2"" of type '" "std::basic_ostream< char >::pos_type""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ostream_seekp" "', argument " "2"" of type '" "std::basic_ostream< char >::pos_type""'");
    } else {
      std::basic_ostream< char >::pos_type * temp = reinterpret_cast< std::basic_ostream< char >::pos_type * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->seekp(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostream_seekp__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char > *arg1 = (std::basic_ostream< char > *) 0 ;
  std::basic_ostream< char >::off_type arg2 ;
  std::ios_base::seekdir arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ostream_seekp",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostream_seekp" "', argument " "1"" of type '" "std::basic_ostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_streamoff,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ostream_seekp" "', argument " "2"" of type '" "std::basic_ostream< char >::off_type""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ostream_seekp" "', argument " "2"" of type '" "std::basic_ostream< char >::off_type""'");
    } else {
      std::basic_ostream< char >::off_type * temp = reinterpret_cast< std::basic_ostream< char >::off_type * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ostream_seekp" "', argument " "3"" of type '" "std::ios_base::seekdir""'");
  } 
  arg3 = static_cast< std::ios_base::seekdir >(val3);
  result = (std::basic_ostream< char,std::char_traits< char > > *) &(arg1)->seekp(arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostream_seekp(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_streampos, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ostream_seekp__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_streamoff, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ostream_seekp__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ostream_seekp'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_ostream< char >::seekp(std::basic_ostream< char >::pos_type)\n"
    "    std::basic_ostream< char >::seekp(std::basic_ostream< char >::off_type,std::ios_base::seekdir)\n");
  return 0;
}


SWIGINTERN PyObject *ostream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_istream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_streambuf< char,std::char_traits< char > > *arg1 = (std::basic_streambuf< char,std::char_traits< char > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_istream< char > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_istream",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_istream" "', argument " "1"" of type '" "std::basic_streambuf< char,std::char_traits< char > > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_streambuf< char,std::char_traits< char > > * >(argp1);
  result = (std::basic_istream< char > *)new std::basic_istream< char >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_istream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_istream",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_istream" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  std::basic_istream< char,std::char_traits< char > > &(*arg2)(std::basic_istream< char,std::char_traits< char > > &) = (std::basic_istream< char,std::char_traits< char > > &(*)(std::basic_istream< char,std::char_traits< char > > &)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "istream___rshift__" "', argument " "2"" of type '" "std::basic_istream< char,std::char_traits< char > > &(*)(std::basic_istream< char,std::char_traits< char > > &)""'"); 
    }
  }
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  std::basic_ios< char,std::char_traits< char > > &(*arg2)(std::basic_ios< char,std::char_traits< char > > &) = (std::basic_ios< char,std::char_traits< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "istream___rshift__" "', argument " "2"" of type '" "std::basic_ios< char,std::char_traits< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &)""'"); 
    }
  }
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  std::ios_base &(*arg2)(std::ios_base &) = (std::ios_base &(*)(std::ios_base &)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_r_std__ios_base__r_std__ios_base);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "istream___rshift__" "', argument " "2"" of type '" "std::ios_base &(*)(std::ios_base &)""'"); 
    }
  }
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  bool *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "bool &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "bool &""'"); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  short *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_short,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "short &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "short &""'"); 
  }
  arg2 = reinterpret_cast< short * >(argp2);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  unsigned short *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_unsigned_short,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "unsigned short &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "unsigned short &""'"); 
  }
  arg2 = reinterpret_cast< unsigned short * >(argp2);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "int &""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  unsigned int *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_unsigned_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "unsigned int &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "unsigned int &""'"); 
  }
  arg2 = reinterpret_cast< unsigned int * >(argp2);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  long *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_long,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "long &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "long &""'"); 
  }
  arg2 = reinterpret_cast< long * >(argp2);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  unsigned long *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_unsigned_long,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "unsigned long &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "unsigned long &""'"); 
  }
  arg2 = reinterpret_cast< unsigned long * >(argp2);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  long long *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_long_long,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "long long &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "long long &""'"); 
  }
  arg2 = reinterpret_cast< long long * >(argp2);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  unsigned long long *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_unsigned_long_long,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "unsigned long long &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "unsigned long long &""'"); 
  }
  arg2 = reinterpret_cast< unsigned long long * >(argp2);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  float *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "float &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "float &""'"); 
  }
  arg2 = reinterpret_cast< float * >(argp2);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  long double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_long_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "long double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "long double &""'"); 
  }
  arg2 = reinterpret_cast< long double * >(argp2);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  void **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_p_void,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "void *&""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream___rshift__" "', argument " "2"" of type '" "void *&""'"); 
  }
  arg2 = reinterpret_cast< void ** >(argp2);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream___rshift____SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  std::basic_streambuf< char,std::char_traits< char > > *arg2 = (std::basic_streambuf< char,std::char_traits< char > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:istream___rshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream___rshift__" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream___rshift__" "', argument " "2"" of type '" "std::basic_streambuf< char,std::char_traits< char > > *""'"); 
  }
  arg2 = reinterpret_cast< std::basic_streambuf< char,std::char_traits< char > > * >(argp2);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->operator >>(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream___rshift__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_istream___rshift____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_istream___rshift____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_std__ios_base__r_std__ios_base);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_istream___rshift____SWIG_2(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_bool, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_istream___rshift____SWIG_3(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_short, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_istream___rshift____SWIG_4(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_short, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_istream___rshift____SWIG_5(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_istream___rshift____SWIG_6(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_int, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_istream___rshift____SWIG_7(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_long, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_istream___rshift____SWIG_8(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_long, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_istream___rshift____SWIG_9(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_long_long, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_istream___rshift____SWIG_10(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_long_long, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_istream___rshift____SWIG_11(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_istream___rshift____SWIG_12(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_istream___rshift____SWIG_13(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_long_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_istream___rshift____SWIG_14(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_void, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_istream___rshift____SWIG_15(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_istream___rshift____SWIG_16(self, args);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_istream_gcount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::streamsize result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:istream_gcount",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_gcount" "', argument " "1"" of type '" "std::basic_istream< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  result = ((std::basic_istream< char > const *)arg1)->gcount();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_istream< char >::int_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:istream_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_get" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  result = (std::basic_istream< char >::int_type)(arg1)->get();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  std::basic_istream< char >::char_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:istream_get",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_get" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_char,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream_get" "', argument " "2"" of type '" "std::basic_istream< char >::char_type &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream_get" "', argument " "2"" of type '" "std::basic_istream< char >::char_type &""'"); 
  }
  arg2 = reinterpret_cast< std::basic_istream< char >::char_type * >(argp2);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->get(*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream_get__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  std::basic_istream< char >::char_type *arg2 = (std::basic_istream< char >::char_type *) 0 ;
  std::streamsize arg3 ;
  std::basic_istream< char >::char_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  char val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:istream_get",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_get" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream_get" "', argument " "2"" of type '" "std::basic_istream< char >::char_type *""'");
  }
  arg2 = reinterpret_cast< std::basic_istream< char >::char_type * >(buf2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "istream_get" "', argument " "3"" of type '" "std::streamsize""'");
  } 
  arg3 = static_cast< std::streamsize >(val3);
  ecode4 = SWIG_AsVal_char(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "istream_get" "', argument " "4"" of type '" "std::basic_istream< char >::char_type""'");
  } 
  arg4 = static_cast< std::basic_istream< char >::char_type >(val4);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->get(arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream_get__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  std::basic_istream< char >::char_type *arg2 = (std::basic_istream< char >::char_type *) 0 ;
  std::streamsize arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:istream_get",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_get" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream_get" "', argument " "2"" of type '" "std::basic_istream< char >::char_type *""'");
  }
  arg2 = reinterpret_cast< std::basic_istream< char >::char_type * >(buf2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "istream_get" "', argument " "3"" of type '" "std::streamsize""'");
  } 
  arg3 = static_cast< std::streamsize >(val3);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->get(arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream_get__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  std::basic_streambuf< char,std::char_traits< char > > *arg2 = 0 ;
  std::basic_istream< char >::char_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:istream_get",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_get" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream_get" "', argument " "2"" of type '" "std::basic_streambuf< char,std::char_traits< char > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream_get" "', argument " "2"" of type '" "std::basic_streambuf< char,std::char_traits< char > > &""'"); 
  }
  arg2 = reinterpret_cast< std::basic_streambuf< char,std::char_traits< char > > * >(argp2);
  ecode3 = SWIG_AsVal_char(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "istream_get" "', argument " "3"" of type '" "std::basic_istream< char >::char_type""'");
  } 
  arg3 = static_cast< std::basic_istream< char >::char_type >(val3);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->get(*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream_get__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  std::basic_streambuf< char,std::char_traits< char > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:istream_get",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_get" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream_get" "', argument " "2"" of type '" "std::basic_streambuf< char,std::char_traits< char > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream_get" "', argument " "2"" of type '" "std::basic_streambuf< char,std::char_traits< char > > &""'"); 
  }
  arg2 = reinterpret_cast< std::basic_streambuf< char,std::char_traits< char > > * >(argp2);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->get(*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_istream_get__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_istream_get__SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_istream_get__SWIG_5(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_istream_get__SWIG_4(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_istream_get__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_istream_get__SWIG_2(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'istream_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_istream< char >::get()\n"
    "    std::basic_istream< char >::get(std::basic_istream< char >::char_type &)\n"
    "    std::basic_istream< char >::get(std::basic_istream< char >::char_type *,std::streamsize,std::basic_istream< char >::char_type)\n"
    "    std::basic_istream< char >::get(std::basic_istream< char >::char_type *,std::streamsize)\n"
    "    std::basic_istream< char >::get(std::basic_streambuf< char,std::char_traits< char > > &,std::basic_istream< char >::char_type)\n"
    "    std::basic_istream< char >::get(std::basic_streambuf< char,std::char_traits< char > > &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_istream_getline__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  std::basic_istream< char >::char_type *arg2 = (std::basic_istream< char >::char_type *) 0 ;
  std::streamsize arg3 ;
  std::basic_istream< char >::char_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  char val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:istream_getline",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_getline" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream_getline" "', argument " "2"" of type '" "std::basic_istream< char >::char_type *""'");
  }
  arg2 = reinterpret_cast< std::basic_istream< char >::char_type * >(buf2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "istream_getline" "', argument " "3"" of type '" "std::streamsize""'");
  } 
  arg3 = static_cast< std::streamsize >(val3);
  ecode4 = SWIG_AsVal_char(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "istream_getline" "', argument " "4"" of type '" "std::basic_istream< char >::char_type""'");
  } 
  arg4 = static_cast< std::basic_istream< char >::char_type >(val4);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->getline(arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream_getline__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  std::basic_istream< char >::char_type *arg2 = (std::basic_istream< char >::char_type *) 0 ;
  std::streamsize arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:istream_getline",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_getline" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream_getline" "', argument " "2"" of type '" "std::basic_istream< char >::char_type *""'");
  }
  arg2 = reinterpret_cast< std::basic_istream< char >::char_type * >(buf2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "istream_getline" "', argument " "3"" of type '" "std::streamsize""'");
  } 
  arg3 = static_cast< std::streamsize >(val3);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->getline(arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream_getline(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_istream_getline__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_istream_getline__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'istream_getline'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_istream< char >::getline(std::basic_istream< char >::char_type *,std::streamsize,std::basic_istream< char >::char_type)\n"
    "    std::basic_istream< char >::getline(std::basic_istream< char >::char_type *,std::streamsize)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_istream_ignore__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  std::streamsize arg2 ;
  std::basic_istream< char >::int_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:istream_ignore",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_ignore" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "istream_ignore" "', argument " "2"" of type '" "std::streamsize""'");
  } 
  arg2 = static_cast< std::streamsize >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "istream_ignore" "', argument " "3"" of type '" "std::basic_istream< char >::int_type""'");
  } 
  arg3 = static_cast< std::basic_istream< char >::int_type >(val3);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->ignore(arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream_ignore__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  std::streamsize arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:istream_ignore",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_ignore" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "istream_ignore" "', argument " "2"" of type '" "std::streamsize""'");
  } 
  arg2 = static_cast< std::streamsize >(val2);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->ignore(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream_ignore__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:istream_ignore",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_ignore" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->ignore();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream_ignore(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_istream_ignore__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_istream_ignore__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_istream_ignore__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'istream_ignore'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_istream< char >::ignore(std::streamsize,std::basic_istream< char >::int_type)\n"
    "    std::basic_istream< char >::ignore(std::streamsize)\n"
    "    std::basic_istream< char >::ignore()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_istream_peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_istream< char >::int_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:istream_peek",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_peek" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  result = (std::basic_istream< char >::int_type)(arg1)->peek();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  std::basic_istream< char >::char_type *arg2 = (std::basic_istream< char >::char_type *) 0 ;
  std::streamsize arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:istream_read",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_read" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream_read" "', argument " "2"" of type '" "std::basic_istream< char >::char_type *""'");
  }
  arg2 = reinterpret_cast< std::basic_istream< char >::char_type * >(buf2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "istream_read" "', argument " "3"" of type '" "std::streamsize""'");
  } 
  arg3 = static_cast< std::streamsize >(val3);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->read(arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream_readsome(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  std::basic_istream< char >::char_type *arg2 = (std::basic_istream< char >::char_type *) 0 ;
  std::streamsize arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::streamsize result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:istream_readsome",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_readsome" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream_readsome" "', argument " "2"" of type '" "std::basic_istream< char >::char_type *""'");
  }
  arg2 = reinterpret_cast< std::basic_istream< char >::char_type * >(buf2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "istream_readsome" "', argument " "3"" of type '" "std::streamsize""'");
  } 
  arg3 = static_cast< std::streamsize >(val3);
  result = (arg1)->readsome(arg2,arg3);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream_putback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  std::basic_istream< char >::char_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:istream_putback",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_putback" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  ecode2 = SWIG_AsVal_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "istream_putback" "', argument " "2"" of type '" "std::basic_istream< char >::char_type""'");
  } 
  arg2 = static_cast< std::basic_istream< char >::char_type >(val2);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->putback(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream_unget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:istream_unget",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_unget" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->unget();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream_sync(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:istream_sync",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_sync" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  result = (int)(arg1)->sync();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream_tellg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_istream< char >::pos_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:istream_tellg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_tellg" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  result = (arg1)->tellg();
  resultobj = SWIG_NewPointerObj((new std::basic_istream< char >::pos_type(static_cast< const std::basic_istream< char >::pos_type& >(result))), SWIGTYPE_p_streampos, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream_seekg__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  std::basic_istream< char >::pos_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:istream_seekg",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_seekg" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_streampos,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream_seekg" "', argument " "2"" of type '" "std::basic_istream< char >::pos_type""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream_seekg" "', argument " "2"" of type '" "std::basic_istream< char >::pos_type""'");
    } else {
      std::basic_istream< char >::pos_type * temp = reinterpret_cast< std::basic_istream< char >::pos_type * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->seekg(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream_seekg__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istream< char > *arg1 = (std::basic_istream< char > *) 0 ;
  std::basic_istream< char >::off_type arg2 ;
  std::ios_base::seekdir arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::basic_istream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:istream_seekg",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream_seekg" "', argument " "1"" of type '" "std::basic_istream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istream< char > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_streamoff,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istream_seekg" "', argument " "2"" of type '" "std::basic_istream< char >::off_type""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istream_seekg" "', argument " "2"" of type '" "std::basic_istream< char >::off_type""'");
    } else {
      std::basic_istream< char >::off_type * temp = reinterpret_cast< std::basic_istream< char >::off_type * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "istream_seekg" "', argument " "3"" of type '" "std::ios_base::seekdir""'");
  } 
  arg3 = static_cast< std::ios_base::seekdir >(val3);
  result = (std::basic_istream< char,std::char_traits< char > > *) &(arg1)->seekg(arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istream_seekg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_streampos, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_istream_seekg__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_streamoff, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_istream_seekg__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'istream_seekg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_istream< char >::seekg(std::basic_istream< char >::pos_type)\n"
    "    std::basic_istream< char >::seekg(std::basic_istream< char >::off_type,std::ios_base::seekdir)\n");
  return 0;
}


SWIGINTERN PyObject *istream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_iostream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_streambuf< char,std::char_traits< char > > *arg1 = (std::basic_streambuf< char,std::char_traits< char > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_iostream< char > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_iostream",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_iostream" "', argument " "1"" of type '" "std::basic_streambuf< char,std::char_traits< char > > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_streambuf< char,std::char_traits< char > > * >(argp1);
  result = (std::basic_iostream< char > *)new std::basic_iostream< char >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_iostreamT_char_std__char_traitsT_char_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_iostream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_iostream< char > *arg1 = (std::basic_iostream< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_iostream",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_iostreamT_char_std__char_traitsT_char_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_iostream" "', argument " "1"" of type '" "std::basic_iostream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_iostream< char > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *iostream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__basic_iostreamT_char_std__char_traitsT_char_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *endl_cb_ptr_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *module;
  PyObject *d;
  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
  d = PyModule_GetDict(module);
  if (!d) return NULL;
  
  return SWIG_Py_Void();
}


SWIGINTERN PyObject *_wrap_endl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char,std::char_traits< char > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:endl",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "endl" "', argument " "1"" of type '" "std::basic_ostream< char,std::char_traits< char > > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "endl" "', argument " "1"" of type '" "std::basic_ostream< char,std::char_traits< char > > &""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char,std::char_traits< char > > * >(argp1);
  result = (std::basic_ostream< char,std::char_traits< char > > *) &std::SWIGTEMPLATEDISAMBIGUATOR endl< char,std::char_traits< char > >(*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ends_cb_ptr_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *module;
  PyObject *d;
  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
  d = PyModule_GetDict(module);
  if (!d) return NULL;
  
  return SWIG_Py_Void();
}


SWIGINTERN PyObject *_wrap_ends(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char,std::char_traits< char > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ends",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ends" "', argument " "1"" of type '" "std::basic_ostream< char,std::char_traits< char > > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ends" "', argument " "1"" of type '" "std::basic_ostream< char,std::char_traits< char > > &""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char,std::char_traits< char > > * >(argp1);
  result = (std::basic_ostream< char,std::char_traits< char > > *) &std::SWIGTEMPLATEDISAMBIGUATOR ends< char,std::char_traits< char > >(*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *flush_cb_ptr_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *module;
  PyObject *d;
  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
  d = PyModule_GetDict(module);
  if (!d) return NULL;
  
  return SWIG_Py_Void();
}


SWIGINTERN PyObject *_wrap_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostream< char,std::char_traits< char > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_ostream< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:flush",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "flush" "', argument " "1"" of type '" "std::basic_ostream< char,std::char_traits< char > > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "flush" "', argument " "1"" of type '" "std::basic_ostream< char,std::char_traits< char > > &""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostream< char,std::char_traits< char > > * >(argp1);
  result = (std::basic_ostream< char,std::char_traits< char > > *) &std::SWIGTEMPLATEDISAMBIGUATOR flush< char,std::char_traits< char > >(*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_streambuf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_streambuf",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_streambuf" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_streambuf_pubimbue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
  std::locale *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::locale result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:streambuf_pubimbue",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_pubimbue" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__locale,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streambuf_pubimbue" "', argument " "2"" of type '" "std::locale const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "streambuf_pubimbue" "', argument " "2"" of type '" "std::locale const &""'"); 
  }
  arg2 = reinterpret_cast< std::locale * >(argp2);
  result = (arg1)->pubimbue((std::locale const &)*arg2);
  resultobj = SWIG_NewPointerObj((new std::locale(static_cast< const std::locale& >(result))), SWIGTYPE_p_std__locale, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_streambuf_getloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::locale result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:streambuf_getloc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_getloc" "', argument " "1"" of type '" "std::basic_streambuf< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
  result = ((std::basic_streambuf< char > const *)arg1)->getloc();
  resultobj = SWIG_NewPointerObj((new std::locale(static_cast< const std::locale& >(result))), SWIGTYPE_p_std__locale, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_streambuf_pubsetbuf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
  std::basic_streambuf< char >::char_type *arg2 = (std::basic_streambuf< char >::char_type *) 0 ;
  std::streamsize arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::basic_streambuf< char,std::char_traits< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:streambuf_pubsetbuf",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_pubsetbuf" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streambuf_pubsetbuf" "', argument " "2"" of type '" "std::basic_streambuf< char >::char_type *""'");
  }
  arg2 = reinterpret_cast< std::basic_streambuf< char >::char_type * >(buf2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "streambuf_pubsetbuf" "', argument " "3"" of type '" "std::streamsize""'");
  } 
  arg3 = static_cast< std::streamsize >(val3);
  result = (std::basic_streambuf< char,std::char_traits< char > > *)(arg1)->pubsetbuf(arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_streambuf_pubseekoff__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
  std::basic_streambuf< char >::off_type arg2 ;
  std::ios_base::seekdir arg3 ;
  std::ios_base::openmode arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  std::basic_streambuf< char >::pos_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:streambuf_pubseekoff",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_pubseekoff" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_streamoff,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streambuf_pubseekoff" "', argument " "2"" of type '" "std::basic_streambuf< char >::off_type""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "streambuf_pubseekoff" "', argument " "2"" of type '" "std::basic_streambuf< char >::off_type""'");
    } else {
      std::basic_streambuf< char >::off_type * temp = reinterpret_cast< std::basic_streambuf< char >::off_type * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "streambuf_pubseekoff" "', argument " "3"" of type '" "std::ios_base::seekdir""'");
  } 
  arg3 = static_cast< std::ios_base::seekdir >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "streambuf_pubseekoff" "', argument " "4"" of type '" "std::ios_base::openmode""'");
  } 
  arg4 = static_cast< std::ios_base::openmode >(val4);
  result = (arg1)->pubseekoff(arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj((new std::basic_streambuf< char >::pos_type(static_cast< const std::basic_streambuf< char >::pos_type& >(result))), SWIGTYPE_p_streampos, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_streambuf_pubseekoff__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
  std::basic_streambuf< char >::off_type arg2 ;
  std::ios_base::seekdir arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::basic_streambuf< char >::pos_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:streambuf_pubseekoff",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_pubseekoff" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_streamoff,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streambuf_pubseekoff" "', argument " "2"" of type '" "std::basic_streambuf< char >::off_type""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "streambuf_pubseekoff" "', argument " "2"" of type '" "std::basic_streambuf< char >::off_type""'");
    } else {
      std::basic_streambuf< char >::off_type * temp = reinterpret_cast< std::basic_streambuf< char >::off_type * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "streambuf_pubseekoff" "', argument " "3"" of type '" "std::ios_base::seekdir""'");
  } 
  arg3 = static_cast< std::ios_base::seekdir >(val3);
  result = (arg1)->pubseekoff(arg2,arg3);
  resultobj = SWIG_NewPointerObj((new std::basic_streambuf< char >::pos_type(static_cast< const std::basic_streambuf< char >::pos_type& >(result))), SWIGTYPE_p_streampos, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_streambuf_pubseekoff(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_streamoff, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_streambuf_pubseekoff__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_streamoff, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_streambuf_pubseekoff__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'streambuf_pubseekoff'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_streambuf< char >::pubseekoff(std::basic_streambuf< char >::off_type,std::ios_base::seekdir,std::ios_base::openmode)\n"
    "    std::basic_streambuf< char >::pubseekoff(std::basic_streambuf< char >::off_type,std::ios_base::seekdir)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_streambuf_pubseekpos__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
  std::basic_streambuf< char >::pos_type arg2 ;
  std::ios_base::openmode arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::basic_streambuf< char >::pos_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:streambuf_pubseekpos",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_pubseekpos" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_streampos,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streambuf_pubseekpos" "', argument " "2"" of type '" "std::basic_streambuf< char >::pos_type""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "streambuf_pubseekpos" "', argument " "2"" of type '" "std::basic_streambuf< char >::pos_type""'");
    } else {
      std::basic_streambuf< char >::pos_type * temp = reinterpret_cast< std::basic_streambuf< char >::pos_type * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "streambuf_pubseekpos" "', argument " "3"" of type '" "std::ios_base::openmode""'");
  } 
  arg3 = static_cast< std::ios_base::openmode >(val3);
  result = (arg1)->pubseekpos(arg2,arg3);
  resultobj = SWIG_NewPointerObj((new std::basic_streambuf< char >::pos_type(static_cast< const std::basic_streambuf< char >::pos_type& >(result))), SWIGTYPE_p_streampos, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_streambuf_pubseekpos__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
  std::basic_streambuf< char >::pos_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_streambuf< char >::pos_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:streambuf_pubseekpos",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_pubseekpos" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_streampos,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streambuf_pubseekpos" "', argument " "2"" of type '" "std::basic_streambuf< char >::pos_type""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "streambuf_pubseekpos" "', argument " "2"" of type '" "std::basic_streambuf< char >::pos_type""'");
    } else {
      std::basic_streambuf< char >::pos_type * temp = reinterpret_cast< std::basic_streambuf< char >::pos_type * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (arg1)->pubseekpos(arg2);
  resultobj = SWIG_NewPointerObj((new std::basic_streambuf< char >::pos_type(static_cast< const std::basic_streambuf< char >::pos_type& >(result))), SWIGTYPE_p_streampos, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_streambuf_pubseekpos(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_streampos, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_streambuf_pubseekpos__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_streampos, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_streambuf_pubseekpos__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'streambuf_pubseekpos'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_streambuf< char >::pubseekpos(std::basic_streambuf< char >::pos_type,std::ios_base::openmode)\n"
    "    std::basic_streambuf< char >::pubseekpos(std::basic_streambuf< char >::pos_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_streambuf_pubsync(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:streambuf_pubsync",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_pubsync" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
  result = (int)(arg1)->pubsync();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_streambuf_in_avail(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::streamsize result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:streambuf_in_avail",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_in_avail" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
  result = (arg1)->in_avail();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_streambuf_snextc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_streambuf< char >::int_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:streambuf_snextc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_snextc" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
  result = (std::basic_streambuf< char >::int_type)(arg1)->snextc();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_streambuf_sbumpc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_streambuf< char >::int_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:streambuf_sbumpc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_sbumpc" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
  result = (std::basic_streambuf< char >::int_type)(arg1)->sbumpc();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_streambuf_sgetc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_streambuf< char >::int_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:streambuf_sgetc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_sgetc" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
  result = (std::basic_streambuf< char >::int_type)(arg1)->sgetc();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_streambuf_sgetn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
  std::basic_streambuf< char >::char_type *arg2 = (std::basic_streambuf< char >::char_type *) 0 ;
  std::streamsize arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::streamsize result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:streambuf_sgetn",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_sgetn" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streambuf_sgetn" "', argument " "2"" of type '" "std::basic_streambuf< char >::char_type *""'");
  }
  arg2 = reinterpret_cast< std::basic_streambuf< char >::char_type * >(buf2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "streambuf_sgetn" "', argument " "3"" of type '" "std::streamsize""'");
  } 
  arg3 = static_cast< std::streamsize >(val3);
  result = (arg1)->sgetn(arg2,arg3);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_streambuf_sputbackc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
  std::basic_streambuf< char >::char_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_streambuf< char >::int_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:streambuf_sputbackc",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_sputbackc" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
  ecode2 = SWIG_AsVal_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streambuf_sputbackc" "', argument " "2"" of type '" "std::basic_streambuf< char >::char_type""'");
  } 
  arg2 = static_cast< std::basic_streambuf< char >::char_type >(val2);
  result = (std::basic_streambuf< char >::int_type)(arg1)->sputbackc(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_streambuf_sungetc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_streambuf< char >::int_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:streambuf_sungetc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_sungetc" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
  result = (std::basic_streambuf< char >::int_type)(arg1)->sungetc();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_streambuf_sputc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
  std::basic_streambuf< char >::char_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_streambuf< char >::int_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:streambuf_sputc",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_sputc" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
  ecode2 = SWIG_AsVal_char(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "streambuf_sputc" "', argument " "2"" of type '" "std::basic_streambuf< char >::char_type""'");
  } 
  arg2 = static_cast< std::basic_streambuf< char >::char_type >(val2);
  result = (std::basic_streambuf< char >::int_type)(arg1)->sputc(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_streambuf_sputn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_streambuf< char > *arg1 = (std::basic_streambuf< char > *) 0 ;
  std::basic_streambuf< char >::char_type *arg2 = (std::basic_streambuf< char >::char_type *) 0 ;
  std::streamsize arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::streamsize result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:streambuf_sputn",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streambuf_sputn" "', argument " "1"" of type '" "std::basic_streambuf< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_streambuf< char > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "streambuf_sputn" "', argument " "2"" of type '" "std::basic_streambuf< char >::char_type const *""'");
  }
  arg2 = reinterpret_cast< std::basic_streambuf< char >::char_type * >(buf2);
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "streambuf_sputn" "', argument " "3"" of type '" "std::streamsize""'");
  } 
  arg3 = static_cast< std::streamsize >(val3);
  result = (arg1)->sputn((std::basic_streambuf< char >::char_type const *)arg2,arg3);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *streambuf_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__basic_streambufT_char_std__char_traitsT_char_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_istringstream__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ios_base::openmode arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_istringstream< char > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_istringstream",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_istringstream" "', argument " "1"" of type '" "std::ios_base::openmode""'");
  } 
  arg1 = static_cast< std::ios_base::openmode >(val1);
  result = (std::basic_istringstream< char > *)new std::basic_istringstream< char >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_istringstream__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istringstream< char > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_istringstream")) SWIG_fail;
  result = (std::basic_istringstream< char > *)new std::basic_istringstream< char >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_istringstream__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  basic_string< char,std::char_traits< char >,std::allocator< char > > *arg1 = 0 ;
  std::ios_base::openmode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_istringstream< char > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_istringstream",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_istringstream" "', argument " "1"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_istringstream" "', argument " "1"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'"); 
  }
  arg1 = reinterpret_cast< basic_string< char,std::char_traits< char >,std::allocator< char > > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_istringstream" "', argument " "2"" of type '" "std::ios_base::openmode""'");
  } 
  arg2 = static_cast< std::ios_base::openmode >(val2);
  result = (std::basic_istringstream< char > *)new std::basic_istringstream< char >((basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_istringstream__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  basic_string< char,std::char_traits< char >,std::allocator< char > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_istringstream< char > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_istringstream",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_istringstream" "', argument " "1"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_istringstream" "', argument " "1"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'"); 
  }
  arg1 = reinterpret_cast< basic_string< char,std::char_traits< char >,std::allocator< char > > * >(argp1);
  result = (std::basic_istringstream< char > *)new std::basic_istringstream< char >((basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_istringstream(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_istringstream__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_istringstream__SWIG_3(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_istringstream__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_istringstream__SWIG_2(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_istringstream'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_istringstream< char >::basic_istringstream(std::ios_base::openmode)\n"
    "    std::basic_istringstream< char >::basic_istringstream()\n"
    "    std::basic_istringstream< char >::basic_istringstream(basic_string< char,std::char_traits< char >,std::allocator< char > > const &,std::ios_base::openmode)\n"
    "    std::basic_istringstream< char >::basic_istringstream(basic_string< char,std::char_traits< char >,std::allocator< char > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_istringstream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istringstream< char > *arg1 = (std::basic_istringstream< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_istringstream",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_istringstream" "', argument " "1"" of type '" "std::basic_istringstream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istringstream< char > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istringstream_rdbuf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istringstream< char > *arg1 = (std::basic_istringstream< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_stringbuf< char,std::char_traits< char >,std::allocator< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:istringstream_rdbuf",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istringstream_rdbuf" "', argument " "1"" of type '" "std::basic_istringstream< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istringstream< char > * >(argp1);
  result = (std::basic_stringbuf< char,std::char_traits< char >,std::allocator< char > > *)((std::basic_istringstream< char > const *)arg1)->rdbuf();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringbufT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istringstream_str__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istringstream< char > *arg1 = (std::basic_istringstream< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  basic_string< char,std::char_traits< char >,std::allocator< char > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:istringstream_str",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istringstream_str" "', argument " "1"" of type '" "std::basic_istringstream< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istringstream< char > * >(argp1);
  result = ((std::basic_istringstream< char > const *)arg1)->str();
  resultobj = SWIG_NewPointerObj((new basic_string< char,std::char_traits< char >,std::allocator< char > >(static_cast< const basic_string< char,std::char_traits< char >,std::allocator< char > >& >(result))), SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istringstream_str__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_istringstream< char > *arg1 = (std::basic_istringstream< char > *) 0 ;
  basic_string< char,std::char_traits< char >,std::allocator< char > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:istringstream_str",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istringstream_str" "', argument " "1"" of type '" "std::basic_istringstream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_istringstream< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istringstream_str" "', argument " "2"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istringstream_str" "', argument " "2"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'"); 
  }
  arg2 = reinterpret_cast< basic_string< char,std::char_traits< char >,std::allocator< char > > * >(argp2);
  (arg1)->str((basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_istringstream_str(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_istringstream_str__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_istringstream_str__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'istringstream_str'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_istringstream< char >::str() const\n"
    "    std::basic_istringstream< char >::str(basic_string< char,std::char_traits< char >,std::allocator< char > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *istringstream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ostringstream__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ios_base::openmode arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_ostringstream< char > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ostringstream",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ostringstream" "', argument " "1"" of type '" "std::ios_base::openmode""'");
  } 
  arg1 = static_cast< std::ios_base::openmode >(val1);
  result = (std::basic_ostringstream< char > *)new std::basic_ostringstream< char >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ostringstream__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostringstream< char > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ostringstream")) SWIG_fail;
  result = (std::basic_ostringstream< char > *)new std::basic_ostringstream< char >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ostringstream__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  basic_string< char,std::char_traits< char >,std::allocator< char > > *arg1 = 0 ;
  std::ios_base::openmode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_ostringstream< char > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_ostringstream",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ostringstream" "', argument " "1"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ostringstream" "', argument " "1"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'"); 
  }
  arg1 = reinterpret_cast< basic_string< char,std::char_traits< char >,std::allocator< char > > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ostringstream" "', argument " "2"" of type '" "std::ios_base::openmode""'");
  } 
  arg2 = static_cast< std::ios_base::openmode >(val2);
  result = (std::basic_ostringstream< char > *)new std::basic_ostringstream< char >((basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ostringstream__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  basic_string< char,std::char_traits< char >,std::allocator< char > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_ostringstream< char > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ostringstream",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ostringstream" "', argument " "1"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ostringstream" "', argument " "1"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'"); 
  }
  arg1 = reinterpret_cast< basic_string< char,std::char_traits< char >,std::allocator< char > > * >(argp1);
  result = (std::basic_ostringstream< char > *)new std::basic_ostringstream< char >((basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ostringstream(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_ostringstream__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ostringstream__SWIG_3(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ostringstream__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ostringstream__SWIG_2(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ostringstream'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_ostringstream< char >::basic_ostringstream(std::ios_base::openmode)\n"
    "    std::basic_ostringstream< char >::basic_ostringstream()\n"
    "    std::basic_ostringstream< char >::basic_ostringstream(basic_string< char,std::char_traits< char >,std::allocator< char > > const &,std::ios_base::openmode)\n"
    "    std::basic_ostringstream< char >::basic_ostringstream(basic_string< char,std::char_traits< char >,std::allocator< char > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ostringstream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostringstream< char > *arg1 = (std::basic_ostringstream< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ostringstream",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ostringstream" "', argument " "1"" of type '" "std::basic_ostringstream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostringstream< char > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostringstream_rdbuf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostringstream< char > *arg1 = (std::basic_ostringstream< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_stringbuf< char,std::char_traits< char >,std::allocator< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ostringstream_rdbuf",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostringstream_rdbuf" "', argument " "1"" of type '" "std::basic_ostringstream< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostringstream< char > * >(argp1);
  result = (std::basic_stringbuf< char,std::char_traits< char >,std::allocator< char > > *)((std::basic_ostringstream< char > const *)arg1)->rdbuf();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringbufT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostringstream_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_ostringstream< char > *arg1 = (std::basic_ostringstream< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  basic_string< char,std::char_traits< char >,std::allocator< char > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ostringstream_str",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostringstream_str" "', argument " "1"" of type '" "std::basic_ostringstream< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_ostringstream< char > * >(argp1);
  result = ((std::basic_ostringstream< char > const *)arg1)->str();
  resultobj = SWIG_NewPointerObj((new basic_string< char,std::char_traits< char >,std::allocator< char > >(static_cast< const basic_string< char,std::char_traits< char >,std::allocator< char > >& >(result))), SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ostringstream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_stringstream__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ios_base::openmode arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_stringstream< char > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_stringstream",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_stringstream" "', argument " "1"" of type '" "std::ios_base::openmode""'");
  } 
  arg1 = static_cast< std::ios_base::openmode >(val1);
  result = (std::basic_stringstream< char > *)new std::basic_stringstream< char >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_stringstream__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_stringstream< char > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_stringstream")) SWIG_fail;
  result = (std::basic_stringstream< char > *)new std::basic_stringstream< char >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_stringstream__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  basic_string< char,std::char_traits< char >,std::allocator< char > > *arg1 = 0 ;
  std::ios_base::openmode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::basic_stringstream< char > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_stringstream",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_stringstream" "', argument " "1"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_stringstream" "', argument " "1"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'"); 
  }
  arg1 = reinterpret_cast< basic_string< char,std::char_traits< char >,std::allocator< char > > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_stringstream" "', argument " "2"" of type '" "std::ios_base::openmode""'");
  } 
  arg2 = static_cast< std::ios_base::openmode >(val2);
  result = (std::basic_stringstream< char > *)new std::basic_stringstream< char >((basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_stringstream__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  basic_string< char,std::char_traits< char >,std::allocator< char > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_stringstream< char > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_stringstream",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_stringstream" "', argument " "1"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_stringstream" "', argument " "1"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'"); 
  }
  arg1 = reinterpret_cast< basic_string< char,std::char_traits< char >,std::allocator< char > > * >(argp1);
  result = (std::basic_stringstream< char > *)new std::basic_stringstream< char >((basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_stringstream(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_stringstream__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_stringstream__SWIG_3(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_stringstream__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_stringstream__SWIG_2(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_stringstream'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_stringstream< char >::basic_stringstream(std::ios_base::openmode)\n"
    "    std::basic_stringstream< char >::basic_stringstream()\n"
    "    std::basic_stringstream< char >::basic_stringstream(basic_string< char,std::char_traits< char >,std::allocator< char > > const &,std::ios_base::openmode)\n"
    "    std::basic_stringstream< char >::basic_stringstream(basic_string< char,std::char_traits< char >,std::allocator< char > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_stringstream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_stringstream< char > *arg1 = (std::basic_stringstream< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_stringstream",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_stringstream" "', argument " "1"" of type '" "std::basic_stringstream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_stringstream< char > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_stringstream_rdbuf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_stringstream< char > *arg1 = (std::basic_stringstream< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::basic_stringbuf< char,std::char_traits< char >,std::allocator< char > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:stringstream_rdbuf",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stringstream_rdbuf" "', argument " "1"" of type '" "std::basic_stringstream< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_stringstream< char > * >(argp1);
  result = (std::basic_stringbuf< char,std::char_traits< char >,std::allocator< char > > *)((std::basic_stringstream< char > const *)arg1)->rdbuf();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringbufT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_stringstream_str__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_stringstream< char > *arg1 = (std::basic_stringstream< char > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  basic_string< char,std::char_traits< char >,std::allocator< char > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:stringstream_str",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stringstream_str" "', argument " "1"" of type '" "std::basic_stringstream< char > const *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_stringstream< char > * >(argp1);
  result = ((std::basic_stringstream< char > const *)arg1)->str();
  resultobj = SWIG_NewPointerObj((new basic_string< char,std::char_traits< char >,std::allocator< char > >(static_cast< const basic_string< char,std::char_traits< char >,std::allocator< char > >& >(result))), SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_stringstream_str__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::basic_stringstream< char > *arg1 = (std::basic_stringstream< char > *) 0 ;
  basic_string< char,std::char_traits< char >,std::allocator< char > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:stringstream_str",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stringstream_str" "', argument " "1"" of type '" "std::basic_stringstream< char > *""'"); 
  }
  arg1 = reinterpret_cast< std::basic_stringstream< char > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "stringstream_str" "', argument " "2"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "stringstream_str" "', argument " "2"" of type '" "basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'"); 
  }
  arg2 = reinterpret_cast< basic_string< char,std::char_traits< char >,std::allocator< char > > * >(argp2);
  (arg1)->str((basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_stringstream_str(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_stringstream_str__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_stringstream_str__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'stringstream_str'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::basic_stringstream< char >::str() const\n"
    "    std::basic_stringstream< char >::str(basic_string< char,std::char_traits< char >,std::allocator< char > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *stringstream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PairIntInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< int,int > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PairIntInt")) SWIG_fail;
  result = (std::pair< int,int > *)new std::pair< int,int >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_int_int_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PairIntInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::pair< int,int > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_PairIntInt",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PairIntInt" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PairIntInt" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (std::pair< int,int > *)new std::pair< int,int >(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_int_int_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PairIntInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< int,int > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  std::pair< int,int > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PairIntInt",&obj0)) SWIG_fail;
  {
    std::pair< int,int > *ptr = (std::pair< int,int > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PairIntInt" "', argument " "1"" of type '" "std::pair< int,int > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PairIntInt" "', argument " "1"" of type '" "std::pair< int,int > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::pair< int,int > *)new std::pair< int,int >((std::pair< int,int > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_int_int_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PairIntInt(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_PairIntInt__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::pair< int,int >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PairIntInt__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_PairIntInt__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PairIntInt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::pair< int,int >::pair()\n"
    "    std::pair< int,int >::pair(int,int)\n"
    "    std::pair< int,int >::pair(std::pair< int,int > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PairIntInt_first_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< int,int > *arg1 = (std::pair< int,int > *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PairIntInt_first_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__pairT_int_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PairIntInt_first_set" "', argument " "1"" of type '" "std::pair< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< int,int > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PairIntInt_first_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->first = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PairIntInt_first_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< int,int > *arg1 = (std::pair< int,int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PairIntInt_first_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__pairT_int_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PairIntInt_first_get" "', argument " "1"" of type '" "std::pair< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< int,int > * >(argp1);
  result = (int) ((arg1)->first);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PairIntInt_second_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< int,int > *arg1 = (std::pair< int,int > *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PairIntInt_second_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__pairT_int_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PairIntInt_second_set" "', argument " "1"" of type '" "std::pair< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< int,int > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PairIntInt_second_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->second = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PairIntInt_second_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< int,int > *arg1 = (std::pair< int,int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PairIntInt_second_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__pairT_int_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PairIntInt_second_get" "', argument " "1"" of type '" "std::pair< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< int,int > * >(argp1);
  result = (int) ((arg1)->second);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PairIntInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< int,int > *arg1 = (std::pair< int,int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PairIntInt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__pairT_int_int_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PairIntInt" "', argument " "1"" of type '" "std::pair< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< int,int > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PairIntInt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_int_int_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MapIntInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::less< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< int,int > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MapIntInt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__lessT_int_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MapIntInt" "', argument " "1"" of type '" "std::less< int > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MapIntInt" "', argument " "1"" of type '" "std::less< int > const &""'"); 
  }
  arg1 = reinterpret_cast< std::less< int > * >(argp1);
  result = (std::map< int,int > *)new std::map< int,int >((std::less< int > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_iterator" "', argument " "1"" of type '" "std::map< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_int_Sc_int_Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt___nonzero__" "', argument " "1"" of type '" "std::map< int,int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  result = (bool)std_map_Sl_int_Sc_int_Sg____nonzero__((std::map< int,int > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt___bool__" "', argument " "1"" of type '" "std::map< int,int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  result = (bool)std_map_Sl_int_Sc_int_Sg____bool__((std::map< int,int > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< int,int >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt___len__" "', argument " "1"" of type '" "std::map< int,int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  result = std_map_Sl_int_Sc_int_Sg____len__((std::map< int,int > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  std::map< int,int >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< int,int >::key_type temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< int,int >::mapped_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapIntInt___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt___getitem__" "', argument " "1"" of type '" "std::map< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapIntInt___getitem__" "', argument " "2"" of type '" "std::map< int,int >::key_type""'");
  } 
  temp2 = static_cast< std::map< int,int >::key_type >(val2);
  arg2 = &temp2;
  try {
    result = (std::map< int,int >::mapped_type *) &std_map_Sl_int_Sc_int_Sg____getitem__(arg1,(int const &)*arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_From_int(static_cast< int >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  std::map< int,int >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< int,int >::key_type temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapIntInt___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt___delitem__" "', argument " "1"" of type '" "std::map< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapIntInt___delitem__" "', argument " "2"" of type '" "std::map< int,int >::key_type""'");
  } 
  temp2 = static_cast< std::map< int,int >::key_type >(val2);
  arg2 = &temp2;
  try {
    std_map_Sl_int_Sc_int_Sg____delitem__(arg1,(int const &)*arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt_has_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  std::map< int,int >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< int,int >::key_type temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapIntInt_has_key",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_has_key" "', argument " "1"" of type '" "std::map< int,int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapIntInt_has_key" "', argument " "2"" of type '" "std::map< int,int >::key_type""'");
  } 
  temp2 = static_cast< std::map< int,int >::key_type >(val2);
  arg2 = &temp2;
  result = (bool)std_map_Sl_int_Sc_int_Sg__has_key((std::map< int,int > const *)arg1,(int const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_keys",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_keys" "', argument " "1"" of type '" "std::map< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  result = (PyObject *)std_map_Sl_int_Sc_int_Sg__keys(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt_values(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_values",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_values" "', argument " "1"" of type '" "std::map< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  result = (PyObject *)std_map_Sl_int_Sc_int_Sg__values(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt_items(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_items",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_items" "', argument " "1"" of type '" "std::map< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  result = (PyObject *)std_map_Sl_int_Sc_int_Sg__items(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  std::map< int,int >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< int,int >::key_type temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapIntInt___contains__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt___contains__" "', argument " "1"" of type '" "std::map< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapIntInt___contains__" "', argument " "2"" of type '" "std::map< int,int >::key_type""'");
  } 
  temp2 = static_cast< std::map< int,int >::key_type >(val2);
  arg2 = &temp2;
  result = (bool)std_map_Sl_int_Sc_int_Sg____contains__(arg1,(int const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt_key_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_key_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_key_iterator" "', argument " "1"" of type '" "std::map< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_int_Sc_int_Sg__key_iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt_value_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_value_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_value_iterator" "', argument " "1"" of type '" "std::map< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_int_Sc_int_Sg__value_iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  std::map< int,int >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< int,int >::key_type temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapIntInt___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt___setitem__" "', argument " "1"" of type '" "std::map< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapIntInt___setitem__" "', argument " "2"" of type '" "std::map< int,int >::key_type""'");
  } 
  temp2 = static_cast< std::map< int,int >::key_type >(val2);
  arg2 = &temp2;
  std_map_Sl_int_Sc_int_Sg____setitem____SWIG_0(arg1,(int const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  std::map< int,int >::key_type *arg2 = 0 ;
  std::map< int,int >::mapped_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< int,int >::key_type temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  std::map< int,int >::mapped_type temp3 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MapIntInt___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt___setitem__" "', argument " "1"" of type '" "std::map< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapIntInt___setitem__" "', argument " "2"" of type '" "std::map< int,int >::key_type""'");
  } 
  temp2 = static_cast< std::map< int,int >::key_type >(val2);
  arg2 = &temp2;
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MapIntInt___setitem__" "', argument " "3"" of type '" "std::map< int,int >::mapped_type""'");
  } 
  temp3 = static_cast< std::map< int,int >::mapped_type >(val3);
  arg3 = &temp3;
  try {
    std_map_Sl_int_Sc_int_Sg____setitem____SWIG_1(arg1,(int const &)*arg2,(int const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MapIntInt___setitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MapIntInt___setitem____SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MapIntInt___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< int,int >::__setitem__(std::map< int,int >::key_type const &)\n"
    "    std::map< int,int >::__setitem__(std::map< int,int >::key_type const &,std::map< int,int >::mapped_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapIntInt_asdict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_asdict",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_asdict" "', argument " "1"" of type '" "std::map< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  result = (PyObject *)std_map_Sl_int_Sc_int_Sg__asdict(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapIntInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MapIntInt")) SWIG_fail;
  result = (std::map< int,int > *)new std::map< int,int >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapIntInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  std::map< int,int > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MapIntInt",&obj0)) SWIG_fail;
  {
    std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > > *ptr = (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MapIntInt" "', argument " "1"" of type '" "std::map< int,int > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MapIntInt" "', argument " "1"" of type '" "std::map< int,int > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::map< int,int > *)new std::map< int,int >((std::map< int,int > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapIntInt(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_MapIntInt__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__lessT_int_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MapIntInt__SWIG_0(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MapIntInt__SWIG_2(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MapIntInt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< int,int >::map(std::less< int > const &)\n"
    "    std::map< int,int >::map()\n"
    "    std::map< int,int >::map(std::map< int,int > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapIntInt_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_empty" "', argument " "1"" of type '" "std::map< int,int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  result = (bool)((std::map< int,int > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< int,int >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_size" "', argument " "1"" of type '" "std::map< int,int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  result = ((std::map< int,int > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  std::map< int,int > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapIntInt_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_swap" "', argument " "1"" of type '" "std::map< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapIntInt_swap" "', argument " "2"" of type '" "std::map< int,int > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapIntInt_swap" "', argument " "2"" of type '" "std::map< int,int > &""'"); 
  }
  arg2 = reinterpret_cast< std::map< int,int > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< int,int >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_begin" "', argument " "1"" of type '" "std::map< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< int,int >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_end" "', argument " "1"" of type '" "std::map< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< int,int >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_rbegin" "', argument " "1"" of type '" "std::map< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,int >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< int,int >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_rend" "', argument " "1"" of type '" "std::map< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,int >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_clear" "', argument " "1"" of type '" "std::map< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< std::pair< int const,int > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapIntInt_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_get_allocator" "', argument " "1"" of type '" "std::map< int,int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  result = ((std::map< int,int > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new std::map< int,int >::allocator_type(static_cast< const std::map< int,int >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__pairT_int_const_int_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  std::map< int,int >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< int,int >::key_type temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< int,int >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapIntInt_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_erase" "', argument " "1"" of type '" "std::map< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapIntInt_erase" "', argument " "2"" of type '" "std::map< int,int >::key_type""'");
  } 
  temp2 = static_cast< std::map< int,int >::key_type >(val2);
  arg2 = &temp2;
  result = (arg1)->erase((std::map< int,int >::key_type const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  std::map< int,int >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< int,int >::key_type temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< int,int >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapIntInt_count",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_count" "', argument " "1"" of type '" "std::map< int,int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapIntInt_count" "', argument " "2"" of type '" "std::map< int,int >::key_type""'");
  } 
  temp2 = static_cast< std::map< int,int >::key_type >(val2);
  arg2 = &temp2;
  result = ((std::map< int,int > const *)arg1)->count((std::map< int,int >::key_type const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  std::map< int,int >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapIntInt_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_erase" "', argument " "1"" of type '" "std::map< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapIntInt_erase" "', argument " "2"" of type '" "std::map< int,int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< int,int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< int,int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapIntInt_erase" "', argument " "2"" of type '" "std::map< int,int >::iterator""'");
    }
  }
  std_map_Sl_int_Sc_int_Sg__erase__SWIG_1(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt_erase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  std::map< int,int >::iterator arg2 ;
  std::map< int,int >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MapIntInt_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_erase" "', argument " "1"" of type '" "std::map< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapIntInt_erase" "', argument " "2"" of type '" "std::map< int,int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< int,int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< int,int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapIntInt_erase" "', argument " "2"" of type '" "std::map< int,int >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapIntInt_erase" "', argument " "3"" of type '" "std::map< int,int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< int,int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< int,int >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapIntInt_erase" "', argument " "3"" of type '" "std::map< int,int >::iterator""'");
    }
  }
  std_map_Sl_int_Sc_int_Sg__erase__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< int,int >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_MapIntInt_erase__SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MapIntInt_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< int,int >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< int,int >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_MapIntInt_erase__SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MapIntInt_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< int,int >::erase(std::map< int,int >::key_type const &)\n"
    "    std::map< int,int >::erase(std::map< int,int >::iterator)\n"
    "    std::map< int,int >::erase(std::map< int,int >::iterator,std::map< int,int >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapIntInt_find(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  std::map< int,int >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< int,int >::key_type temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< int,int >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapIntInt_find",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_find" "', argument " "1"" of type '" "std::map< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapIntInt_find" "', argument " "2"" of type '" "std::map< int,int >::key_type""'");
  } 
  temp2 = static_cast< std::map< int,int >::key_type >(val2);
  arg2 = &temp2;
  result = (arg1)->find((std::map< int,int >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt_lower_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  std::map< int,int >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< int,int >::key_type temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< int,int >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapIntInt_lower_bound",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_lower_bound" "', argument " "1"" of type '" "std::map< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapIntInt_lower_bound" "', argument " "2"" of type '" "std::map< int,int >::key_type""'");
  } 
  temp2 = static_cast< std::map< int,int >::key_type >(val2);
  arg2 = &temp2;
  result = (arg1)->lower_bound((std::map< int,int >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapIntInt_upper_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  std::map< int,int >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< int,int >::key_type temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< int,int >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapIntInt_upper_bound",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapIntInt_upper_bound" "', argument " "1"" of type '" "std::map< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapIntInt_upper_bound" "', argument " "2"" of type '" "std::map< int,int >::key_type""'");
  } 
  temp2 = static_cast< std::map< int,int >::key_type >(val2);
  arg2 = &temp2;
  result = (arg1)->upper_bound((std::map< int,int >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< int,int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MapIntInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< int,int > *arg1 = (std::map< int,int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MapIntInt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MapIntInt" "', argument " "1"" of type '" "std::map< int,int > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< int,int > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MapIntInt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MapStringString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::less< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,std::string > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MapStringString",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__lessT_std__string_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MapStringString" "', argument " "1"" of type '" "std::less< std::string > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MapStringString" "', argument " "1"" of type '" "std::less< std::string > const &""'"); 
  }
  arg1 = reinterpret_cast< std::less< std::string > * >(argp1);
  result = (std::map< std::string,std::string > *)new std::map< std::string,std::string >((std::less< std::string > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_iterator" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_std_string_Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString___nonzero__" "', argument " "1"" of type '" "std::map< std::string,std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  result = (bool)std_map_Sl_std_string_Sc_std_string_Sg____nonzero__((std::map< std::string,std::string > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString___bool__" "', argument " "1"" of type '" "std::map< std::string,std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  result = (bool)std_map_Sl_std_string_Sc_std_string_Sg____bool__((std::map< std::string,std::string > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,std::string >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString___len__" "', argument " "1"" of type '" "std::map< std::string,std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  result = std_map_Sl_std_string_Sc_std_string_Sg____len__((std::map< std::string,std::string > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,std::string >::mapped_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringString___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString___getitem__" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringString___getitem__" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringString___getitem__" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  try {
    result = (std::map< std::string,std::string >::mapped_type *) &std_map_Sl_std_string_Sc_std_string_Sg____getitem__(arg1,(std::string const &)*arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringString___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString___delitem__" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringString___delitem__" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringString___delitem__" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  try {
    std_map_Sl_std_string_Sc_std_string_Sg____delitem__(arg1,(std::string const &)*arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString_has_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringString_has_key",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_has_key" "', argument " "1"" of type '" "std::map< std::string,std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringString_has_key" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringString_has_key" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)std_map_Sl_std_string_Sc_std_string_Sg__has_key((std::map< std::string,std::string > const *)arg1,(std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString_keys",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_keys" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_std_string_Sg__keys(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString_values(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString_values",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_values" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_std_string_Sg__values(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString_items(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString_items",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_items" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_std_string_Sg__items(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringString___contains__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString___contains__" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringString___contains__" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringString___contains__" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)std_map_Sl_std_string_Sc_std_string_Sg____contains__(arg1,(std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString_key_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString_key_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_key_iterator" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_std_string_Sg__key_iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString_value_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString_value_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_value_iterator" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_std_string_Sg__value_iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringString___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString___setitem__" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringString___setitem__" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringString___setitem__" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  std_map_Sl_std_string_Sc_std_string_Sg____setitem____SWIG_0(arg1,(std::string const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::key_type *arg2 = 0 ;
  std::map< std::string,std::string >::mapped_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MapStringString___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString___setitem__" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringString___setitem__" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringString___setitem__" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MapStringString___setitem__" "', argument " "3"" of type '" "std::map< std::string,std::string >::mapped_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringString___setitem__" "', argument " "3"" of type '" "std::map< std::string,std::string >::mapped_type const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    std_map_Sl_std_string_Sc_std_string_Sg____setitem____SWIG_1(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MapStringString___setitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MapStringString___setitem____SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MapStringString___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< std::string,std::string >::__setitem__(std::map< std::string,std::string >::key_type const &)\n"
    "    std::map< std::string,std::string >::__setitem__(std::map< std::string,std::string >::key_type const &,std::map< std::string,std::string >::mapped_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapStringString_asdict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString_asdict",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_asdict" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_std_string_Sg__asdict(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapStringString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MapStringString")) SWIG_fail;
  result = (std::map< std::string,std::string > *)new std::map< std::string,std::string >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapStringString__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  std::map< std::string,std::string > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MapStringString",&obj0)) SWIG_fail;
  {
    std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *ptr = (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MapStringString" "', argument " "1"" of type '" "std::map< std::string,std::string > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MapStringString" "', argument " "1"" of type '" "std::map< std::string,std::string > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::map< std::string,std::string > *)new std::map< std::string,std::string >((std::map< std::string,std::string > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapStringString(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_MapStringString__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__lessT_std__string_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MapStringString__SWIG_0(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MapStringString__SWIG_2(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MapStringString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< std::string,std::string >::map(std::less< std::string > const &)\n"
    "    std::map< std::string,std::string >::map()\n"
    "    std::map< std::string,std::string >::map(std::map< std::string,std::string > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapStringString_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_empty" "', argument " "1"" of type '" "std::map< std::string,std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  result = (bool)((std::map< std::string,std::string > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,std::string >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_size" "', argument " "1"" of type '" "std::map< std::string,std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  result = ((std::map< std::string,std::string > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringString_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_swap" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringString_swap" "', argument " "2"" of type '" "std::map< std::string,std::string > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringString_swap" "', argument " "2"" of type '" "std::map< std::string,std::string > &""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,std::string > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,std::string >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_begin" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,std::string >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_end" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,std::string >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_rbegin" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,std::string >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,std::string >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_rend" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,std::string >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_clear" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< std::pair< std::string const,std::string > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringString_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_get_allocator" "', argument " "1"" of type '" "std::map< std::string,std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  result = ((std::map< std::string,std::string > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new std::map< std::string,std::string >::allocator_type(static_cast< const std::map< std::string,std::string >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_std__string_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,std::string >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringString_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_erase" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringString_erase" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringString_erase" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->erase((std::map< std::string,std::string >::key_type const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,std::string >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringString_count",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_count" "', argument " "1"" of type '" "std::map< std::string,std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringString_count" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringString_count" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = ((std::map< std::string,std::string > const *)arg1)->count((std::map< std::string,std::string >::key_type const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringString_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_erase" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringString_erase" "', argument " "2"" of type '" "std::map< std::string,std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< std::string,std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringString_erase" "', argument " "2"" of type '" "std::map< std::string,std::string >::iterator""'");
    }
  }
  std_map_Sl_std_string_Sc_std_string_Sg__erase__SWIG_1(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString_erase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::iterator arg2 ;
  std::map< std::string,std::string >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MapStringString_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_erase" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringString_erase" "', argument " "2"" of type '" "std::map< std::string,std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< std::string,std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringString_erase" "', argument " "2"" of type '" "std::map< std::string,std::string >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringString_erase" "', argument " "3"" of type '" "std::map< std::string,std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< std::string,std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,std::string >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringString_erase" "', argument " "3"" of type '" "std::map< std::string,std::string >::iterator""'");
    }
  }
  std_map_Sl_std_string_Sc_std_string_Sg__erase__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,std::string >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_MapStringString_erase__SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MapStringString_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,std::string >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,std::string >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_MapStringString_erase__SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MapStringString_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< std::string,std::string >::erase(std::map< std::string,std::string >::key_type const &)\n"
    "    std::map< std::string,std::string >::erase(std::map< std::string,std::string >::iterator)\n"
    "    std::map< std::string,std::string >::erase(std::map< std::string,std::string >::iterator,std::map< std::string,std::string >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapStringString_find(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,std::string >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringString_find",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_find" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringString_find" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringString_find" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->find((std::map< std::string,std::string >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString_lower_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,std::string >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringString_lower_bound",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_lower_bound" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringString_lower_bound" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringString_lower_bound" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->lower_bound((std::map< std::string,std::string >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringString_upper_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,std::string >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringString_upper_bound",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringString_upper_bound" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringString_upper_bound" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringString_upper_bound" "', argument " "2"" of type '" "std::map< std::string,std::string >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->upper_bound((std::map< std::string,std::string >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MapStringString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MapStringString",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MapStringString" "', argument " "1"" of type '" "std::map< std::string,std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,std::string > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MapStringString_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MapDoublePairIntInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::less< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< double,std::pair< int,int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MapDoublePairIntInt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__lessT_double_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MapDoublePairIntInt" "', argument " "1"" of type '" "std::less< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MapDoublePairIntInt" "', argument " "1"" of type '" "std::less< double > const &""'"); 
  }
  arg1 = reinterpret_cast< std::less< double > * >(argp1);
  result = (std::map< double,std::pair< int,int > > *)new std::map< double,std::pair< int,int > >((std::less< double > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapDoublePairIntInt_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt_iterator" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapDoublePairIntInt___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt___nonzero__" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  result = (bool)std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg____nonzero__((std::map< double,std::pair< int,int > > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapDoublePairIntInt___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt___bool__" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  result = (bool)std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg____bool__((std::map< double,std::pair< int,int > > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< double,std::pair< int,int > >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapDoublePairIntInt___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt___len__" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  result = std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg____len__((std::map< double,std::pair< int,int > > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  std::map< double,std::pair< int,int > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< double,std::pair< int,int > >::key_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< double,std::pair< int,int > >::mapped_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapDoublePairIntInt___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt___getitem__" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapDoublePairIntInt___getitem__" "', argument " "2"" of type '" "std::map< double,std::pair< int,int > >::key_type""'");
  } 
  temp2 = static_cast< std::map< double,std::pair< int,int > >::key_type >(val2);
  arg2 = &temp2;
  try {
    result = (std::map< double,std::pair< int,int > >::mapped_type *) &std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg____getitem__(arg1,(double const &)*arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = swig::from(static_cast< std::pair< int,int > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  std::map< double,std::pair< int,int > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< double,std::pair< int,int > >::key_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapDoublePairIntInt___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt___delitem__" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapDoublePairIntInt___delitem__" "', argument " "2"" of type '" "std::map< double,std::pair< int,int > >::key_type""'");
  } 
  temp2 = static_cast< std::map< double,std::pair< int,int > >::key_type >(val2);
  arg2 = &temp2;
  try {
    std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg____delitem__(arg1,(double const &)*arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt_has_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  std::map< double,std::pair< int,int > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< double,std::pair< int,int > >::key_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapDoublePairIntInt_has_key",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt_has_key" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapDoublePairIntInt_has_key" "', argument " "2"" of type '" "std::map< double,std::pair< int,int > >::key_type""'");
  } 
  temp2 = static_cast< std::map< double,std::pair< int,int > >::key_type >(val2);
  arg2 = &temp2;
  result = (bool)std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__has_key((std::map< double,std::pair< int,int > > const *)arg1,(double const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapDoublePairIntInt_keys",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt_keys" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  result = (PyObject *)std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__keys(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt_values(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapDoublePairIntInt_values",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt_values" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  result = (PyObject *)std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__values(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt_items(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapDoublePairIntInt_items",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt_items" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  result = (PyObject *)std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__items(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  std::map< double,std::pair< int,int > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< double,std::pair< int,int > >::key_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapDoublePairIntInt___contains__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt___contains__" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapDoublePairIntInt___contains__" "', argument " "2"" of type '" "std::map< double,std::pair< int,int > >::key_type""'");
  } 
  temp2 = static_cast< std::map< double,std::pair< int,int > >::key_type >(val2);
  arg2 = &temp2;
  result = (bool)std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg____contains__(arg1,(double const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt_key_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapDoublePairIntInt_key_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt_key_iterator" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__key_iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt_value_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapDoublePairIntInt_value_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt_value_iterator" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__value_iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  std::map< double,std::pair< int,int > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< double,std::pair< int,int > >::key_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapDoublePairIntInt___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt___setitem__" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapDoublePairIntInt___setitem__" "', argument " "2"" of type '" "std::map< double,std::pair< int,int > >::key_type""'");
  } 
  temp2 = static_cast< std::map< double,std::pair< int,int > >::key_type >(val2);
  arg2 = &temp2;
  std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg____setitem____SWIG_0(arg1,(double const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  std::map< double,std::pair< int,int > >::key_type *arg2 = 0 ;
  std::map< double,std::pair< int,int > >::mapped_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< double,std::pair< int,int > >::key_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MapDoublePairIntInt___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt___setitem__" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapDoublePairIntInt___setitem__" "', argument " "2"" of type '" "std::map< double,std::pair< int,int > >::key_type""'");
  } 
  temp2 = static_cast< std::map< double,std::pair< int,int > >::key_type >(val2);
  arg2 = &temp2;
  {
    std::pair< int,int > *ptr = (std::pair< int,int > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MapDoublePairIntInt___setitem__" "', argument " "3"" of type '" "std::map< double,std::pair< int,int > >::mapped_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapDoublePairIntInt___setitem__" "', argument " "3"" of type '" "std::map< double,std::pair< int,int > >::mapped_type const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg____setitem____SWIG_1(arg1,(double const &)*arg2,(std::pair< int,int > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MapDoublePairIntInt___setitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::pair< int,int >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MapDoublePairIntInt___setitem____SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MapDoublePairIntInt___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< double,std::pair< int,int > >::__setitem__(std::map< double,std::pair< int,int > >::key_type const &)\n"
    "    std::map< double,std::pair< int,int > >::__setitem__(std::map< double,std::pair< int,int > >::key_type const &,std::map< double,std::pair< int,int > >::mapped_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt_asdict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapDoublePairIntInt_asdict",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt_asdict" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  result = (PyObject *)std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__asdict(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapDoublePairIntInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MapDoublePairIntInt")) SWIG_fail;
  result = (std::map< double,std::pair< int,int > > *)new std::map< double,std::pair< int,int > >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapDoublePairIntInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  std::map< double,std::pair< int,int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MapDoublePairIntInt",&obj0)) SWIG_fail;
  {
    std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > > *ptr = (std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MapDoublePairIntInt" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MapDoublePairIntInt" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::map< double,std::pair< int,int > > *)new std::map< double,std::pair< int,int > >((std::map< double,std::pair< int,int > > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapDoublePairIntInt(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_MapDoublePairIntInt__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__lessT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MapDoublePairIntInt__SWIG_0(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MapDoublePairIntInt__SWIG_2(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MapDoublePairIntInt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< double,std::pair< int,int > >::map(std::less< double > const &)\n"
    "    std::map< double,std::pair< int,int > >::map()\n"
    "    std::map< double,std::pair< int,int > >::map(std::map< double,std::pair< int,int > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapDoublePairIntInt_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt_empty" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  result = (bool)((std::map< double,std::pair< int,int > > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< double,std::pair< int,int > >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapDoublePairIntInt_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt_size" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  result = ((std::map< double,std::pair< int,int > > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  std::map< double,std::pair< int,int > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapDoublePairIntInt_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt_swap" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapDoublePairIntInt_swap" "', argument " "2"" of type '" "std::map< double,std::pair< int,int > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapDoublePairIntInt_swap" "', argument " "2"" of type '" "std::map< double,std::pair< int,int > > &""'"); 
  }
  arg2 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< double,std::pair< int,int > >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapDoublePairIntInt_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt_begin" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< double,std::pair< int,int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< double,std::pair< int,int > >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapDoublePairIntInt_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt_end" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< double,std::pair< int,int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< double,std::pair< int,int > >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapDoublePairIntInt_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt_rbegin" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< double,std::pair< int,int > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< double,std::pair< int,int > >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapDoublePairIntInt_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt_rend" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< double,std::pair< int,int > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapDoublePairIntInt_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt_clear" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< std::pair< double const,std::pair< int,int > > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapDoublePairIntInt_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt_get_allocator" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  result = ((std::map< double,std::pair< int,int > > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new std::map< double,std::pair< int,int > >::allocator_type(static_cast< const std::map< double,std::pair< int,int > >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  std::map< double,std::pair< int,int > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< double,std::pair< int,int > >::key_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< double,std::pair< int,int > >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapDoublePairIntInt_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt_erase" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapDoublePairIntInt_erase" "', argument " "2"" of type '" "std::map< double,std::pair< int,int > >::key_type""'");
  } 
  temp2 = static_cast< std::map< double,std::pair< int,int > >::key_type >(val2);
  arg2 = &temp2;
  result = (arg1)->erase((std::map< double,std::pair< int,int > >::key_type const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  std::map< double,std::pair< int,int > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< double,std::pair< int,int > >::key_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< double,std::pair< int,int > >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapDoublePairIntInt_count",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt_count" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapDoublePairIntInt_count" "', argument " "2"" of type '" "std::map< double,std::pair< int,int > >::key_type""'");
  } 
  temp2 = static_cast< std::map< double,std::pair< int,int > >::key_type >(val2);
  arg2 = &temp2;
  result = ((std::map< double,std::pair< int,int > > const *)arg1)->count((std::map< double,std::pair< int,int > >::key_type const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  std::map< double,std::pair< int,int > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapDoublePairIntInt_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt_erase" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapDoublePairIntInt_erase" "', argument " "2"" of type '" "std::map< double,std::pair< int,int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< double,std::pair< int,int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< double,std::pair< int,int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapDoublePairIntInt_erase" "', argument " "2"" of type '" "std::map< double,std::pair< int,int > >::iterator""'");
    }
  }
  std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__erase__SWIG_1(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt_erase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  std::map< double,std::pair< int,int > >::iterator arg2 ;
  std::map< double,std::pair< int,int > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MapDoublePairIntInt_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt_erase" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapDoublePairIntInt_erase" "', argument " "2"" of type '" "std::map< double,std::pair< int,int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< double,std::pair< int,int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< double,std::pair< int,int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapDoublePairIntInt_erase" "', argument " "2"" of type '" "std::map< double,std::pair< int,int > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapDoublePairIntInt_erase" "', argument " "3"" of type '" "std::map< double,std::pair< int,int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< double,std::pair< int,int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< double,std::pair< int,int > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapDoublePairIntInt_erase" "', argument " "3"" of type '" "std::map< double,std::pair< int,int > >::iterator""'");
    }
  }
  std_map_Sl_double_Sc_std_pair_Sl_int_Sc_int_Sg__Sg__erase__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< double,std::pair< int,int > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_MapDoublePairIntInt_erase__SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MapDoublePairIntInt_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< double,std::pair< int,int > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< double,std::pair< int,int > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_MapDoublePairIntInt_erase__SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MapDoublePairIntInt_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< double,std::pair< int,int > >::erase(std::map< double,std::pair< int,int > >::key_type const &)\n"
    "    std::map< double,std::pair< int,int > >::erase(std::map< double,std::pair< int,int > >::iterator)\n"
    "    std::map< double,std::pair< int,int > >::erase(std::map< double,std::pair< int,int > >::iterator,std::map< double,std::pair< int,int > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt_find(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  std::map< double,std::pair< int,int > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< double,std::pair< int,int > >::key_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< double,std::pair< int,int > >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapDoublePairIntInt_find",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt_find" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapDoublePairIntInt_find" "', argument " "2"" of type '" "std::map< double,std::pair< int,int > >::key_type""'");
  } 
  temp2 = static_cast< std::map< double,std::pair< int,int > >::key_type >(val2);
  arg2 = &temp2;
  result = (arg1)->find((std::map< double,std::pair< int,int > >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< double,std::pair< int,int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt_lower_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  std::map< double,std::pair< int,int > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< double,std::pair< int,int > >::key_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< double,std::pair< int,int > >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapDoublePairIntInt_lower_bound",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt_lower_bound" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapDoublePairIntInt_lower_bound" "', argument " "2"" of type '" "std::map< double,std::pair< int,int > >::key_type""'");
  } 
  temp2 = static_cast< std::map< double,std::pair< int,int > >::key_type >(val2);
  arg2 = &temp2;
  result = (arg1)->lower_bound((std::map< double,std::pair< int,int > >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< double,std::pair< int,int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapDoublePairIntInt_upper_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  std::map< double,std::pair< int,int > >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< double,std::pair< int,int > >::key_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< double,std::pair< int,int > >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapDoublePairIntInt_upper_bound",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapDoublePairIntInt_upper_bound" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MapDoublePairIntInt_upper_bound" "', argument " "2"" of type '" "std::map< double,std::pair< int,int > >::key_type""'");
  } 
  temp2 = static_cast< std::map< double,std::pair< int,int > >::key_type >(val2);
  arg2 = &temp2;
  result = (arg1)->upper_bound((std::map< double,std::pair< int,int > >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< double,std::pair< int,int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MapDoublePairIntInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< double,std::pair< int,int > > *arg1 = (std::map< double,std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MapDoublePairIntInt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MapDoublePairIntInt" "', argument " "1"" of type '" "std::map< double,std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< double,std::pair< int,int > > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MapDoublePairIntInt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_VectorBool_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:VectorBool_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool_iterator" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  result = (swig::SwigPyIterator *)std_vector_Sl_bool_Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorBool___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool___nonzero__" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  result = (bool)std_vector_Sl_bool_Sg____nonzero__((std::vector< bool > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorBool___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool___bool__" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  result = (bool)std_vector_Sl_bool_Sg____bool__((std::vector< bool > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< bool >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorBool___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool___len__" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  result = std_vector_Sl_bool_Sg____len__((std::vector< bool > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::difference_type arg2 ;
  std::vector< bool >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< bool,std::allocator< bool > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorBool___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool___getslice__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorBool___getslice__" "', argument " "2"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorBool___getslice__" "', argument " "3"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::difference_type >(val3);
  try {
    result = (std::vector< bool,std::allocator< bool > > *)std_vector_Sl_bool_Sg____getslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::difference_type arg2 ;
  std::vector< bool >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorBool___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool___setslice__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorBool___setslice__" "', argument " "2"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorBool___setslice__" "', argument " "3"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::difference_type >(val3);
  try {
    std_vector_Sl_bool_Sg____setslice____SWIG_0(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::difference_type arg2 ;
  std::vector< bool >::difference_type arg3 ;
  std::vector< bool,std::allocator< bool > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorBool___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool___setslice__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorBool___setslice__" "', argument " "2"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorBool___setslice__" "', argument " "3"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::difference_type >(val3);
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorBool___setslice__" "', argument " "4"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorBool___setslice__" "', argument " "4"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg4 = ptr;
  }
  try {
    std_vector_Sl_bool_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< bool,std::allocator< bool > > const &)*arg4);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorBool___setslice____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector<bool,std::allocator< bool > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorBool___setslice____SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorBool___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bool >::__setslice__(std::vector< bool >::difference_type,std::vector< bool >::difference_type)\n"
    "    std::vector< bool >::__setslice__(std::vector< bool >::difference_type,std::vector< bool >::difference_type,std::vector< bool,std::allocator< bool > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorBool___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::difference_type arg2 ;
  std::vector< bool >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorBool___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool___delslice__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorBool___delslice__" "', argument " "2"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorBool___delslice__" "', argument " "3"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::difference_type >(val3);
  try {
    std_vector_Sl_bool_Sg____delslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorBool___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool___delitem__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorBool___delitem__" "', argument " "2"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::difference_type >(val2);
  try {
    std_vector_Sl_bool_Sg____delitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< bool,std::allocator< bool > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorBool___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool___getitem__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorBool___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    result = (std::vector< bool,std::allocator< bool > > *)std_vector_Sl_bool_Sg____getitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< bool,std::allocator< bool > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorBool___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool___setitem__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorBool___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorBool___setitem__" "', argument " "3"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorBool___setitem__" "', argument " "3"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    std_vector_Sl_bool_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< bool,std::allocator< bool > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorBool___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool___setitem__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorBool___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_bool_Sg____setitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorBool___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool___delitem__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorBool___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_bool_Sg____delitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorBool___delitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorBool___delitem____SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorBool___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bool >::__delitem__(std::vector< bool >::difference_type)\n"
    "    std::vector< bool >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorBool___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< bool >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorBool___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool___getitem__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorBool___getitem__" "', argument " "2"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::difference_type >(val2);
  try {
    result = (std::vector< bool >::value_type)std_vector_Sl_bool_Sg____getitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorBool___getitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorBool___getitem____SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorBool___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bool >::__getitem__(PySliceObject *)\n"
    "    std::vector< bool >::__getitem__(std::vector< bool >::difference_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorBool___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::difference_type arg2 ;
  std::vector< bool >::value_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorBool___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool___setitem__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorBool___setitem__" "', argument " "2"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::difference_type >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorBool___setitem__" "', argument " "3"" of type '" "std::vector< bool >::value_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::value_type >(val3);
  try {
    std_vector_Sl_bool_Sg____setitem____SWIG_2(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorBool___setitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector<bool,std::allocator< bool > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorBool___setitem____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorBool___setitem____SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorBool___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bool >::__setitem__(PySliceObject *,std::vector< bool,std::allocator< bool > > const &)\n"
    "    std::vector< bool >::__setitem__(PySliceObject *)\n"
    "    std::vector< bool >::__setitem__(std::vector< bool >::difference_type,std::vector< bool >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorBool_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< bool >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorBool_pop",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool_pop" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  try {
    result = (std::vector< bool >::value_type)std_vector_Sl_bool_Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::value_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorBool_append",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool_append" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorBool_append" "', argument " "2"" of type '" "std::vector< bool >::value_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::value_type >(val2);
  std_vector_Sl_bool_Sg__append(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorBool__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_VectorBool")) SWIG_fail;
  result = (std::vector< bool > *)new std::vector< bool >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorBool__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  std::vector< bool > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorBool",&obj0)) SWIG_fail;
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorBool" "', argument " "1"" of type '" "std::vector< bool > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorBool" "', argument " "1"" of type '" "std::vector< bool > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::vector< bool > *)new std::vector< bool >((std::vector< bool > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorBool_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool_empty" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  result = (bool)((std::vector< bool > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< bool >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorBool_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool_size" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  result = ((std::vector< bool > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorBool_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool_swap" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorBool_swap" "', argument " "2"" of type '" "std::vector< bool > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorBool_swap" "', argument " "2"" of type '" "std::vector< bool > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< bool > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< bool >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorBool_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool_begin" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bool >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< bool >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorBool_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool_end" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bool >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< bool >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorBool_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool_rbegin" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bool >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< bool >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorBool_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool_rend" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bool >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorBool_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool_clear" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< bool > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorBool_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool_get_allocator" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  result = ((std::vector< bool > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new std::vector< bool >::allocator_type(static_cast< const std::vector< bool >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_bool_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorBool__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< bool > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorBool",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorBool" "', argument " "1"" of type '" "std::vector< bool >::size_type""'");
  } 
  arg1 = static_cast< std::vector< bool >::size_type >(val1);
  result = (std::vector< bool > *)new std::vector< bool >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorBool_pop_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool_pop_back" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorBool_resize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool_resize" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorBool_resize" "', argument " "2"" of type '" "std::vector< bool >::size_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::size_type >(val2);
  (arg1)->resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< bool >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorBool_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool_erase" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorBool_erase" "', argument " "2"" of type '" "std::vector< bool >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< bool >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< bool >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorBool_erase" "', argument " "2"" of type '" "std::vector< bool >::iterator""'");
    }
  }
  result = std_vector_Sl_bool_Sg__erase__SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bool >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::iterator arg2 ;
  std::vector< bool >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< bool >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorBool_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool_erase" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorBool_erase" "', argument " "2"" of type '" "std::vector< bool >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< bool >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< bool >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorBool_erase" "', argument " "2"" of type '" "std::vector< bool >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorBool_erase" "', argument " "3"" of type '" "std::vector< bool >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< bool >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< bool >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorBool_erase" "', argument " "3"" of type '" "std::vector< bool >::iterator""'");
    }
  }
  result = std_vector_Sl_bool_Sg__erase__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bool >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< bool >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_VectorBool_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< bool >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< bool >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_VectorBool_erase__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorBool_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bool >::erase(std::vector< bool >::iterator)\n"
    "    std::vector< bool >::erase(std::vector< bool >::iterator,std::vector< bool >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_VectorBool__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool >::size_type arg1 ;
  std::vector< bool >::value_type arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< bool > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorBool",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorBool" "', argument " "1"" of type '" "std::vector< bool >::size_type""'");
  } 
  arg1 = static_cast< std::vector< bool >::size_type >(val1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorBool" "', argument " "2"" of type '" "std::vector< bool >::value_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::value_type >(val2);
  result = (std::vector< bool > *)new std::vector< bool >(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorBool(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_VectorBool__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_VectorBool__SWIG_2(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VectorBool__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_VectorBool__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorBool'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bool >::vector()\n"
    "    std::vector< bool >::vector(std::vector< bool > const &)\n"
    "    std::vector< bool >::vector(std::vector< bool >::size_type)\n"
    "    std::vector< bool >::vector(std::vector< bool >::size_type,std::vector< bool >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorBool_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::value_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorBool_push_back",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool_push_back" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorBool_push_back" "', argument " "2"" of type '" "std::vector< bool >::value_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::value_type >(val2);
  (arg1)->push_back(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< bool >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorBool_front",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool_front" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  result = (std::vector< bool >::value_type)((std::vector< bool > const *)arg1)->front();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< bool >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorBool_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool_back" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  result = (std::vector< bool >::value_type)((std::vector< bool > const *)arg1)->back();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::size_type arg2 ;
  std::vector< bool >::value_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorBool_assign",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool_assign" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorBool_assign" "', argument " "2"" of type '" "std::vector< bool >::size_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::size_type >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorBool_assign" "', argument " "3"" of type '" "std::vector< bool >::value_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::value_type >(val3);
  (arg1)->assign(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::size_type arg2 ;
  std::vector< bool >::value_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorBool_resize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool_resize" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorBool_resize" "', argument " "2"" of type '" "std::vector< bool >::size_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::size_type >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorBool_resize" "', argument " "3"" of type '" "std::vector< bool >::value_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::value_type >(val3);
  (arg1)->resize(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorBool_resize__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorBool_resize__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorBool_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bool >::resize(std::vector< bool >::size_type)\n"
    "    std::vector< bool >::resize(std::vector< bool >::size_type,std::vector< bool >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorBool_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::iterator arg2 ;
  std::vector< bool >::value_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< bool >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorBool_insert",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool_insert" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorBool_insert" "', argument " "2"" of type '" "std::vector< bool >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< bool >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< bool >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorBool_insert" "', argument " "2"" of type '" "std::vector< bool >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorBool_insert" "', argument " "3"" of type '" "std::vector< bool >::value_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::value_type >(val3);
  result = std_vector_Sl_bool_Sg__insert__SWIG_0(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bool >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::iterator arg2 ;
  std::vector< bool >::size_type arg3 ;
  std::vector< bool >::value_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorBool_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool_insert" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorBool_insert" "', argument " "2"" of type '" "std::vector< bool >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< bool >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< bool >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorBool_insert" "', argument " "2"" of type '" "std::vector< bool >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorBool_insert" "', argument " "3"" of type '" "std::vector< bool >::size_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::size_type >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorBool_insert" "', argument " "4"" of type '" "std::vector< bool >::value_type""'");
  } 
  arg4 = static_cast< std::vector< bool >::value_type >(val4);
  std_vector_Sl_bool_Sg__insert__SWIG_1(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< bool >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorBool_insert__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< bool >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_VectorBool_insert__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorBool_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bool >::insert(std::vector< bool >::iterator,std::vector< bool >::value_type)\n"
    "    std::vector< bool >::insert(std::vector< bool >::iterator,std::vector< bool >::size_type,std::vector< bool >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorBool_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorBool_reserve",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool_reserve" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorBool_reserve" "', argument " "2"" of type '" "std::vector< bool >::size_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::size_type >(val2);
  (arg1)->reserve(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorBool_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< bool >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorBool_capacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorBool_capacity" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  result = ((std::vector< bool > const *)arg1)->capacity();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VectorBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorBool",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorBool" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VectorBool_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_VectorComplex_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:VectorComplex_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex_iterator" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  result = (swig::SwigPyIterator *)std_vector_Sl_std_complex_Sl_double_Sg__Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorComplex___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex___nonzero__" "', argument " "1"" of type '" "std::vector< std::complex< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  result = (bool)std_vector_Sl_std_complex_Sl_double_Sg__Sg____nonzero__((std::vector< std::complex< double > > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorComplex___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex___bool__" "', argument " "1"" of type '" "std::vector< std::complex< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  result = (bool)std_vector_Sl_std_complex_Sl_double_Sg__Sg____bool__((std::vector< std::complex< double > > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::complex< double > >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorComplex___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex___len__" "', argument " "1"" of type '" "std::vector< std::complex< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  result = std_vector_Sl_std_complex_Sl_double_Sg__Sg____len__((std::vector< std::complex< double > > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  std::vector< std::complex< double > >::difference_type arg2 ;
  std::vector< std::complex< double > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< std::complex< double >,std::allocator< std::complex< double > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorComplex___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex___getslice__" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorComplex___getslice__" "', argument " "2"" of type '" "std::vector< std::complex< double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::complex< double > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorComplex___getslice__" "', argument " "3"" of type '" "std::vector< std::complex< double > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::complex< double > >::difference_type >(val3);
  try {
    result = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)std_vector_Sl_std_complex_Sl_double_Sg__Sg____getslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  std::vector< std::complex< double > >::difference_type arg2 ;
  std::vector< std::complex< double > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorComplex___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex___setslice__" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorComplex___setslice__" "', argument " "2"" of type '" "std::vector< std::complex< double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::complex< double > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorComplex___setslice__" "', argument " "3"" of type '" "std::vector< std::complex< double > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::complex< double > >::difference_type >(val3);
  try {
    std_vector_Sl_std_complex_Sl_double_Sg__Sg____setslice____SWIG_0(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  std::vector< std::complex< double > >::difference_type arg2 ;
  std::vector< std::complex< double > >::difference_type arg3 ;
  std::vector< std::complex< double >,std::allocator< std::complex< double > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorComplex___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex___setslice__" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorComplex___setslice__" "', argument " "2"" of type '" "std::vector< std::complex< double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::complex< double > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorComplex___setslice__" "', argument " "3"" of type '" "std::vector< std::complex< double > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::complex< double > >::difference_type >(val3);
  {
    std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorComplex___setslice__" "', argument " "4"" of type '" "std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorComplex___setslice__" "', argument " "4"" of type '" "std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &""'"); 
    }
    arg4 = ptr;
  }
  try {
    std_vector_Sl_std_complex_Sl_double_Sg__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)*arg4);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorComplex___setslice____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorComplex___setslice____SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorComplex___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::complex< double > >::__setslice__(std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double > >::difference_type)\n"
    "    std::vector< std::complex< double > >::__setslice__(std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorComplex___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  std::vector< std::complex< double > >::difference_type arg2 ;
  std::vector< std::complex< double > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorComplex___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex___delslice__" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorComplex___delslice__" "', argument " "2"" of type '" "std::vector< std::complex< double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::complex< double > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorComplex___delslice__" "', argument " "3"" of type '" "std::vector< std::complex< double > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::complex< double > >::difference_type >(val3);
  try {
    std_vector_Sl_std_complex_Sl_double_Sg__Sg____delslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  std::vector< std::complex< double > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorComplex___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex___delitem__" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorComplex___delitem__" "', argument " "2"" of type '" "std::vector< std::complex< double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::complex< double > >::difference_type >(val2);
  try {
    std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< std::complex< double >,std::allocator< std::complex< double > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorComplex___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex___getitem__" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorComplex___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    result = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< std::complex< double >,std::allocator< std::complex< double > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorComplex___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex___setitem__" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorComplex___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  {
    std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorComplex___setitem__" "', argument " "3"" of type '" "std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorComplex___setitem__" "', argument " "3"" of type '" "std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorComplex___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex___setitem__" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorComplex___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorComplex___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex___delitem__" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorComplex___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorComplex___delitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorComplex___delitem____SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorComplex___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::complex< double > >::__delitem__(std::vector< std::complex< double > >::difference_type)\n"
    "    std::vector< std::complex< double > >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorComplex___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  std::vector< std::complex< double > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< std::complex< double > >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorComplex___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex___getitem__" "', argument " "1"" of type '" "std::vector< std::complex< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorComplex___getitem__" "', argument " "2"" of type '" "std::vector< std::complex< double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::complex< double > >::difference_type >(val2);
  try {
    result = (std::vector< std::complex< double > >::value_type *) &std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_1((std::vector< std::complex< double > > const *)arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorComplex___getitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorComplex___getitem____SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorComplex___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::complex< double > >::__getitem__(PySliceObject *)\n"
    "    std::vector< std::complex< double > >::__getitem__(std::vector< std::complex< double > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorComplex___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  std::vector< std::complex< double > >::difference_type arg2 ;
  std::vector< std::complex< double > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< std::complex< double > >::value_type temp3 ;
  std::complex< double > val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorComplex___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex___setitem__" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorComplex___setitem__" "', argument " "2"" of type '" "std::vector< std::complex< double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::complex< double > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorComplex___setitem__" "', argument " "3"" of type '" "std::vector< std::complex< double > >::value_type""'");
  } 
  temp3 = static_cast< std::vector< std::complex< double > >::value_type >(val3);
  arg3 = &temp3;
  try {
    std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_2(arg1,arg2,(std::complex< double > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorComplex___setitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorComplex___setitem____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_std_complex_Sl_double_Sg_(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorComplex___setitem____SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorComplex___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::complex< double > >::__setitem__(PySliceObject *,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)\n"
    "    std::vector< std::complex< double > >::__setitem__(PySliceObject *)\n"
    "    std::vector< std::complex< double > >::__setitem__(std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorComplex_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::complex< double > >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorComplex_pop",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex_pop" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  try {
    result = std_vector_Sl_std_complex_Sl_double_Sg__Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  std::vector< std::complex< double > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::complex< double > >::value_type temp2 ;
  std::complex< double > val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorComplex_append",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex_append" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  ecode2 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorComplex_append" "', argument " "2"" of type '" "std::vector< std::complex< double > >::value_type""'");
  } 
  temp2 = static_cast< std::vector< std::complex< double > >::value_type >(val2);
  arg2 = &temp2;
  std_vector_Sl_std_complex_Sl_double_Sg__Sg__append(arg1,(std::complex< double > const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorComplex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_VectorComplex")) SWIG_fail;
  result = (std::vector< std::complex< double > > *)new std::vector< std::complex< double > >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorComplex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  std::vector< std::complex< double > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorComplex",&obj0)) SWIG_fail;
  {
    std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorComplex" "', argument " "1"" of type '" "std::vector< std::complex< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorComplex" "', argument " "1"" of type '" "std::vector< std::complex< double > > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::vector< std::complex< double > > *)new std::vector< std::complex< double > >((std::vector< std::complex< double > > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorComplex_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex_empty" "', argument " "1"" of type '" "std::vector< std::complex< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  result = (bool)((std::vector< std::complex< double > > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::complex< double > >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorComplex_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex_size" "', argument " "1"" of type '" "std::vector< std::complex< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  result = ((std::vector< std::complex< double > > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  std::vector< std::complex< double > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorComplex_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex_swap" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorComplex_swap" "', argument " "2"" of type '" "std::vector< std::complex< double > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorComplex_swap" "', argument " "2"" of type '" "std::vector< std::complex< double > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::complex< double > > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::complex< double > >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorComplex_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex_begin" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::complex< double > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::complex< double > >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorComplex_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex_end" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::complex< double > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::complex< double > >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorComplex_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex_rbegin" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::complex< double > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::complex< double > >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorComplex_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex_rend" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::complex< double > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorComplex_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex_clear" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< std::complex< double > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorComplex_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex_get_allocator" "', argument " "1"" of type '" "std::vector< std::complex< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  result = ((std::vector< std::complex< double > > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new std::vector< std::complex< double > >::allocator_type(static_cast< const std::vector< std::complex< double > >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__complexT_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorComplex__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::complex< double > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorComplex",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorComplex" "', argument " "1"" of type '" "std::vector< std::complex< double > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::complex< double > >::size_type >(val1);
  result = (std::vector< std::complex< double > > *)new std::vector< std::complex< double > >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorComplex_pop_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex_pop_back" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  std::vector< std::complex< double > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorComplex_resize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex_resize" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorComplex_resize" "', argument " "2"" of type '" "std::vector< std::complex< double > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::complex< double > >::size_type >(val2);
  (arg1)->resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  std::vector< std::complex< double > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< std::complex< double > >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorComplex_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex_erase" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorComplex_erase" "', argument " "2"" of type '" "std::vector< std::complex< double > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::complex< double > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::complex< double > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorComplex_erase" "', argument " "2"" of type '" "std::vector< std::complex< double > >::iterator""'");
    }
  }
  result = std_vector_Sl_std_complex_Sl_double_Sg__Sg__erase__SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::complex< double > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  std::vector< std::complex< double > >::iterator arg2 ;
  std::vector< std::complex< double > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< std::complex< double > >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorComplex_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex_erase" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorComplex_erase" "', argument " "2"" of type '" "std::vector< std::complex< double > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::complex< double > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::complex< double > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorComplex_erase" "', argument " "2"" of type '" "std::vector< std::complex< double > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorComplex_erase" "', argument " "3"" of type '" "std::vector< std::complex< double > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::complex< double > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::complex< double > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorComplex_erase" "', argument " "3"" of type '" "std::vector< std::complex< double > >::iterator""'");
    }
  }
  result = std_vector_Sl_std_complex_Sl_double_Sg__Sg__erase__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::complex< double > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::complex< double > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_VectorComplex_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::complex< double > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::complex< double > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_VectorComplex_erase__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorComplex_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::complex< double > >::erase(std::vector< std::complex< double > >::iterator)\n"
    "    std::vector< std::complex< double > >::erase(std::vector< std::complex< double > >::iterator,std::vector< std::complex< double > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_VectorComplex__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > >::size_type arg1 ;
  std::vector< std::complex< double > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< std::complex< double > >::value_type temp2 ;
  std::complex< double > val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< std::complex< double > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorComplex",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorComplex" "', argument " "1"" of type '" "std::vector< std::complex< double > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::complex< double > >::size_type >(val1);
  ecode2 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorComplex" "', argument " "2"" of type '" "std::vector< std::complex< double > >::value_type""'");
  } 
  temp2 = static_cast< std::vector< std::complex< double > >::value_type >(val2);
  arg2 = &temp2;
  result = (std::vector< std::complex< double > > *)new std::vector< std::complex< double > >(arg1,(std::vector< std::complex< double > >::value_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorComplex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_VectorComplex__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_VectorComplex__SWIG_2(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VectorComplex__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_std_complex_Sl_double_Sg_(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_VectorComplex__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorComplex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::complex< double > >::vector()\n"
    "    std::vector< std::complex< double > >::vector(std::vector< std::complex< double > > const &)\n"
    "    std::vector< std::complex< double > >::vector(std::vector< std::complex< double > >::size_type)\n"
    "    std::vector< std::complex< double > >::vector(std::vector< std::complex< double > >::size_type,std::vector< std::complex< double > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorComplex_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  std::vector< std::complex< double > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::complex< double > >::value_type temp2 ;
  std::complex< double > val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorComplex_push_back",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex_push_back" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  ecode2 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorComplex_push_back" "', argument " "2"" of type '" "std::vector< std::complex< double > >::value_type""'");
  } 
  temp2 = static_cast< std::vector< std::complex< double > >::value_type >(val2);
  arg2 = &temp2;
  (arg1)->push_back((std::vector< std::complex< double > >::value_type const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::complex< double > >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorComplex_front",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex_front" "', argument " "1"" of type '" "std::vector< std::complex< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  result = (std::vector< std::complex< double > >::value_type *) &((std::vector< std::complex< double > > const *)arg1)->front();
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::complex< double > >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorComplex_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex_back" "', argument " "1"" of type '" "std::vector< std::complex< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  result = (std::vector< std::complex< double > >::value_type *) &((std::vector< std::complex< double > > const *)arg1)->back();
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  std::vector< std::complex< double > >::size_type arg2 ;
  std::vector< std::complex< double > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< std::complex< double > >::value_type temp3 ;
  std::complex< double > val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorComplex_assign",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex_assign" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorComplex_assign" "', argument " "2"" of type '" "std::vector< std::complex< double > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::complex< double > >::size_type >(val2);
  ecode3 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorComplex_assign" "', argument " "3"" of type '" "std::vector< std::complex< double > >::value_type""'");
  } 
  temp3 = static_cast< std::vector< std::complex< double > >::value_type >(val3);
  arg3 = &temp3;
  (arg1)->assign(arg2,(std::vector< std::complex< double > >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  std::vector< std::complex< double > >::size_type arg2 ;
  std::vector< std::complex< double > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< std::complex< double > >::value_type temp3 ;
  std::complex< double > val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorComplex_resize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex_resize" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorComplex_resize" "', argument " "2"" of type '" "std::vector< std::complex< double > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::complex< double > >::size_type >(val2);
  ecode3 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorComplex_resize" "', argument " "3"" of type '" "std::vector< std::complex< double > >::value_type""'");
  } 
  temp3 = static_cast< std::vector< std::complex< double > >::value_type >(val3);
  arg3 = &temp3;
  (arg1)->resize(arg2,(std::vector< std::complex< double > >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorComplex_resize__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_std_complex_Sl_double_Sg_(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorComplex_resize__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorComplex_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::complex< double > >::resize(std::vector< std::complex< double > >::size_type)\n"
    "    std::vector< std::complex< double > >::resize(std::vector< std::complex< double > >::size_type,std::vector< std::complex< double > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorComplex_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  std::vector< std::complex< double > >::iterator arg2 ;
  std::vector< std::complex< double > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< std::complex< double > >::value_type temp3 ;
  std::complex< double > val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< std::complex< double > >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorComplex_insert",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex_insert" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorComplex_insert" "', argument " "2"" of type '" "std::vector< std::complex< double > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::complex< double > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::complex< double > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorComplex_insert" "', argument " "2"" of type '" "std::vector< std::complex< double > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorComplex_insert" "', argument " "3"" of type '" "std::vector< std::complex< double > >::value_type""'");
  } 
  temp3 = static_cast< std::vector< std::complex< double > >::value_type >(val3);
  arg3 = &temp3;
  result = std_vector_Sl_std_complex_Sl_double_Sg__Sg__insert__SWIG_0(arg1,arg2,(std::complex< double > const &)*arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::complex< double > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  std::vector< std::complex< double > >::iterator arg2 ;
  std::vector< std::complex< double > >::size_type arg3 ;
  std::vector< std::complex< double > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::vector< std::complex< double > >::value_type temp4 ;
  std::complex< double > val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorComplex_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex_insert" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorComplex_insert" "', argument " "2"" of type '" "std::vector< std::complex< double > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::complex< double > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::complex< double > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorComplex_insert" "', argument " "2"" of type '" "std::vector< std::complex< double > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorComplex_insert" "', argument " "3"" of type '" "std::vector< std::complex< double > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::complex< double > >::size_type >(val3);
  ecode4 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorComplex_insert" "', argument " "4"" of type '" "std::vector< std::complex< double > >::value_type""'");
  } 
  temp4 = static_cast< std::vector< std::complex< double > >::value_type >(val4);
  arg4 = &temp4;
  std_vector_Sl_std_complex_Sl_double_Sg__Sg__insert__SWIG_1(arg1,arg2,arg3,(std::complex< double > const &)*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::complex< double > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_std_complex_Sl_double_Sg_(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorComplex_insert__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::complex< double > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_std_complex_Sl_double_Sg_(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_VectorComplex_insert__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorComplex_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::complex< double > >::insert(std::vector< std::complex< double > >::iterator,std::vector< std::complex< double > >::value_type const &)\n"
    "    std::vector< std::complex< double > >::insert(std::vector< std::complex< double > >::iterator,std::vector< std::complex< double > >::size_type,std::vector< std::complex< double > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorComplex_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  std::vector< std::complex< double > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorComplex_reserve",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex_reserve" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorComplex_reserve" "', argument " "2"" of type '" "std::vector< std::complex< double > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::complex< double > >::size_type >(val2);
  (arg1)->reserve(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorComplex_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::complex< double > >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorComplex_capacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorComplex_capacity" "', argument " "1"" of type '" "std::vector< std::complex< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  result = ((std::vector< std::complex< double > > const *)arg1)->capacity();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VectorComplex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorComplex",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorComplex" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VectorComplex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_VectorDouble_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:VectorDouble_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble_iterator" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  result = (swig::SwigPyIterator *)std_vector_Sl_double_Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorDouble___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble___nonzero__" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  result = (bool)std_vector_Sl_double_Sg____nonzero__((std::vector< double > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorDouble___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble___bool__" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  result = (bool)std_vector_Sl_double_Sg____bool__((std::vector< double > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorDouble___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble___len__" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  result = std_vector_Sl_double_Sg____len__((std::vector< double > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  std::vector< double >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorDouble___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble___getslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorDouble___getslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorDouble___getslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< double >::difference_type >(val3);
  try {
    result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  std::vector< double >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorDouble___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorDouble___setslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorDouble___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< double >::difference_type >(val3);
  try {
    std_vector_Sl_double_Sg____setslice____SWIG_0(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  std::vector< double >::difference_type arg3 ;
  std::vector< double,std::allocator< double > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorDouble___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorDouble___setslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorDouble___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< double >::difference_type >(val3);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorDouble___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDouble___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg4 = ptr;
  }
  try {
    std_vector_Sl_double_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< double,std::allocator< double > > const &)*arg4);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorDouble___setslice____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorDouble___setslice____SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorDouble___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type)\n"
    "    std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorDouble___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  std::vector< double >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorDouble___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble___delslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorDouble___delslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorDouble___delslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< double >::difference_type >(val3);
  try {
    std_vector_Sl_double_Sg____delslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorDouble___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble___delitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorDouble___delitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  try {
    std_vector_Sl_double_Sg____delitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorDouble___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble___getitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorDouble___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorDouble___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorDouble___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDouble___setitem__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDouble___setitem__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    std_vector_Sl_double_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorDouble___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorDouble___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_double_Sg____setitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorDouble___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble___delitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorDouble___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_double_Sg____delitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorDouble___delitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorDouble___delitem____SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorDouble___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::__delitem__(std::vector< double >::difference_type)\n"
    "    std::vector< double >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorDouble___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< double >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorDouble___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble___getitem__" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorDouble___getitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  try {
    result = (std::vector< double >::value_type *) &std_vector_Sl_double_Sg____getitem____SWIG_1((std::vector< double > const *)arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_From_double(static_cast< double >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorDouble___getitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorDouble___getitem____SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorDouble___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::__getitem__(PySliceObject *)\n"
    "    std::vector< double >::__getitem__(std::vector< double >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorDouble___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::difference_type arg2 ;
  std::vector< double >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< double >::value_type temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorDouble___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorDouble___setitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorDouble___setitem__" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
  } 
  temp3 = static_cast< std::vector< double >::value_type >(val3);
  arg3 = &temp3;
  try {
    std_vector_Sl_double_Sg____setitem____SWIG_2(arg1,arg2,(double const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorDouble___setitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorDouble___setitem____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorDouble___setitem____SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorDouble___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::__setitem__(PySliceObject *,std::vector< double,std::allocator< double > > const &)\n"
    "    std::vector< double >::__setitem__(PySliceObject *)\n"
    "    std::vector< double >::__setitem__(std::vector< double >::difference_type,std::vector< double >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorDouble_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorDouble_pop",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble_pop" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  try {
    result = (std::vector< double >::value_type)std_vector_Sl_double_Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< double >::value_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorDouble_append",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble_append" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorDouble_append" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
  } 
  temp2 = static_cast< std::vector< double >::value_type >(val2);
  arg2 = &temp2;
  std_vector_Sl_double_Sg__append(arg1,(double const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorDouble__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_VectorDouble")) SWIG_fail;
  result = (std::vector< double > *)new std::vector< double >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorDouble__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  std::vector< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorDouble",&obj0)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorDouble" "', argument " "1"" of type '" "std::vector< double > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorDouble" "', argument " "1"" of type '" "std::vector< double > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::vector< double > *)new std::vector< double >((std::vector< double > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorDouble_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble_empty" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  result = (bool)((std::vector< double > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorDouble_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble_size" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  result = ((std::vector< double > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorDouble_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble_swap" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDouble_swap" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDouble_swap" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorDouble_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble_begin" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorDouble_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble_end" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorDouble_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble_rbegin" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorDouble_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble_rend" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorDouble_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble_clear" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorDouble_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble_get_allocator" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  result = ((std::vector< double > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new std::vector< double >::allocator_type(static_cast< const std::vector< double >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorDouble__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorDouble",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorDouble" "', argument " "1"" of type '" "std::vector< double >::size_type""'");
  } 
  arg1 = static_cast< std::vector< double >::size_type >(val1);
  result = (std::vector< double > *)new std::vector< double >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorDouble_pop_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble_pop_back" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorDouble_resize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble_resize" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorDouble_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
  } 
  arg2 = static_cast< std::vector< double >::size_type >(val2);
  (arg1)->resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< double >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorDouble_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble_erase" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorDouble_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorDouble_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
    }
  }
  result = std_vector_Sl_double_Sg__erase__SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::iterator arg2 ;
  std::vector< double >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< double >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorDouble_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble_erase" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorDouble_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorDouble_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorDouble_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorDouble_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'");
    }
  }
  result = std_vector_Sl_double_Sg__erase__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_VectorDouble_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_VectorDouble_erase__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorDouble_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::erase(std::vector< double >::iterator)\n"
    "    std::vector< double >::erase(std::vector< double >::iterator,std::vector< double >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_VectorDouble__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double >::size_type arg1 ;
  std::vector< double >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< double >::value_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorDouble",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorDouble" "', argument " "1"" of type '" "std::vector< double >::size_type""'");
  } 
  arg1 = static_cast< std::vector< double >::size_type >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorDouble" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
  } 
  temp2 = static_cast< std::vector< double >::value_type >(val2);
  arg2 = &temp2;
  result = (std::vector< double > *)new std::vector< double >(arg1,(std::vector< double >::value_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorDouble(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_VectorDouble__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_VectorDouble__SWIG_2(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VectorDouble__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_VectorDouble__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorDouble'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::vector()\n"
    "    std::vector< double >::vector(std::vector< double > const &)\n"
    "    std::vector< double >::vector(std::vector< double >::size_type)\n"
    "    std::vector< double >::vector(std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorDouble_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< double >::value_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorDouble_push_back",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble_push_back" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorDouble_push_back" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
  } 
  temp2 = static_cast< std::vector< double >::value_type >(val2);
  arg2 = &temp2;
  (arg1)->push_back((std::vector< double >::value_type const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorDouble_front",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble_front" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  result = (std::vector< double >::value_type *) &((std::vector< double > const *)arg1)->front();
  resultobj = SWIG_From_double(static_cast< double >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorDouble_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble_back" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  result = (std::vector< double >::value_type *) &((std::vector< double > const *)arg1)->back();
  resultobj = SWIG_From_double(static_cast< double >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::size_type arg2 ;
  std::vector< double >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< double >::value_type temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorDouble_assign",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble_assign" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorDouble_assign" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
  } 
  arg2 = static_cast< std::vector< double >::size_type >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorDouble_assign" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
  } 
  temp3 = static_cast< std::vector< double >::value_type >(val3);
  arg3 = &temp3;
  (arg1)->assign(arg2,(std::vector< double >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::size_type arg2 ;
  std::vector< double >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< double >::value_type temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorDouble_resize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble_resize" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorDouble_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
  } 
  arg2 = static_cast< std::vector< double >::size_type >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorDouble_resize" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
  } 
  temp3 = static_cast< std::vector< double >::value_type >(val3);
  arg3 = &temp3;
  (arg1)->resize(arg2,(std::vector< double >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorDouble_resize__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorDouble_resize__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorDouble_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::resize(std::vector< double >::size_type)\n"
    "    std::vector< double >::resize(std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorDouble_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::iterator arg2 ;
  std::vector< double >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< double >::value_type temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< double >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorDouble_insert",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble_insert" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorDouble_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorDouble_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorDouble_insert" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
  } 
  temp3 = static_cast< std::vector< double >::value_type >(val3);
  arg3 = &temp3;
  result = std_vector_Sl_double_Sg__insert__SWIG_0(arg1,arg2,(double const &)*arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::iterator arg2 ;
  std::vector< double >::size_type arg3 ;
  std::vector< double >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::vector< double >::value_type temp4 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorDouble_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble_insert" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorDouble_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorDouble_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorDouble_insert" "', argument " "3"" of type '" "std::vector< double >::size_type""'");
  } 
  arg3 = static_cast< std::vector< double >::size_type >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorDouble_insert" "', argument " "4"" of type '" "std::vector< double >::value_type""'");
  } 
  temp4 = static_cast< std::vector< double >::value_type >(val4);
  arg4 = &temp4;
  std_vector_Sl_double_Sg__insert__SWIG_1(arg1,arg2,arg3,(double const &)*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorDouble_insert__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_VectorDouble_insert__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorDouble_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::insert(std::vector< double >::iterator,std::vector< double >::value_type const &)\n"
    "    std::vector< double >::insert(std::vector< double >::iterator,std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorDouble_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorDouble_reserve",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble_reserve" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorDouble_reserve" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
  } 
  arg2 = static_cast< std::vector< double >::size_type >(val2);
  (arg1)->reserve(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorDouble_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorDouble_capacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDouble_capacity" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  result = ((std::vector< double > const *)arg1)->capacity();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VectorDouble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorDouble",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorDouble" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VectorDouble_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_VectorInt_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_iterator" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  result = (swig::SwigPyIterator *)std_vector_Sl_int_Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorInt___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___nonzero__" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  result = (bool)std_vector_Sl_int_Sg____nonzero__((std::vector< int > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorInt___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___bool__" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  result = (bool)std_vector_Sl_int_Sg____bool__((std::vector< int > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorInt___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___len__" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  result = std_vector_Sl_int_Sg____len__((std::vector< int > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::difference_type arg2 ;
  std::vector< int >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< int,std::allocator< int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___getslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___getslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< int >::difference_type >(val3);
  try {
    result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::difference_type arg2 ;
  std::vector< int >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___setslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< int >::difference_type >(val3);
  try {
    std_vector_Sl_int_Sg____setslice____SWIG_0(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::difference_type arg2 ;
  std::vector< int >::difference_type arg3 ;
  std::vector< int,std::allocator< int > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorInt___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___setslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< int >::difference_type >(val3);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorInt___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
    }
    arg4 = ptr;
  }
  try {
    std_vector_Sl_int_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< int,std::allocator< int > > const &)*arg4);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorInt___setslice____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< int,std::allocator< int > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorInt___setslice____SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type)\n"
    "    std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type,std::vector< int,std::allocator< int > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorInt___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::difference_type arg2 ;
  std::vector< int >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___delslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___delslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< int >::difference_type >(val3);
  try {
    std_vector_Sl_int_Sg____delslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___delitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< int >::difference_type >(val2);
  try {
    std_vector_Sl_int_Sg____delitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< int,std::allocator< int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< int,std::allocator< int > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorInt___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    std_vector_Sl_int_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< int,std::allocator< int > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_int_Sg____setitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_int_Sg____delitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorInt___delitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorInt___delitem____SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::__delitem__(std::vector< int >::difference_type)\n"
    "    std::vector< int >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorInt___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< int >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getitem__" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___getitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< int >::difference_type >(val2);
  try {
    result = (std::vector< int >::value_type *) &std_vector_Sl_int_Sg____getitem____SWIG_1((std::vector< int > const *)arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_From_int(static_cast< int >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorInt___getitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorInt___getitem____SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::__getitem__(PySliceObject *)\n"
    "    std::vector< int >::__getitem__(std::vector< int >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorInt___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::difference_type arg2 ;
  std::vector< int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< int >::value_type temp3 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___setitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___setitem__" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< int >::value_type >(val3);
  arg3 = &temp3;
  try {
    std_vector_Sl_int_Sg____setitem____SWIG_2(arg1,arg2,(int const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorInt___setitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< int,std::allocator< int > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorInt___setitem____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorInt___setitem____SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::__setitem__(PySliceObject *,std::vector< int,std::allocator< int > > const &)\n"
    "    std::vector< int >::__setitem__(PySliceObject *)\n"
    "    std::vector< int >::__setitem__(std::vector< int >::difference_type,std::vector< int >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorInt_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_pop",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_pop" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  try {
    result = (std::vector< int >::value_type)std_vector_Sl_int_Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< int >::value_type temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_append",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_append" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_append" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
  } 
  temp2 = static_cast< std::vector< int >::value_type >(val2);
  arg2 = &temp2;
  std_vector_Sl_int_Sg__append(arg1,(int const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_VectorInt")) SWIG_fail;
  result = (std::vector< int > *)new std::vector< int >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  std::vector< int > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorInt",&obj0)) SWIG_fail;
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_empty" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  result = (bool)((std::vector< int > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_size" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  result = ((std::vector< int > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_swap" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorInt_swap" "', argument " "2"" of type '" "std::vector< int > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt_swap" "', argument " "2"" of type '" "std::vector< int > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_begin" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_end" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rbegin" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rend" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_clear" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< int > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_get_allocator" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  result = ((std::vector< int > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new std::vector< int >::allocator_type(static_cast< const std::vector< int >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_int_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorInt",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int >::size_type""'");
  } 
  arg1 = static_cast< std::vector< int >::size_type >(val1);
  result = (std::vector< int > *)new std::vector< int >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_pop_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_pop_back" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_resize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_resize" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< int >::size_type >(val2);
  (arg1)->resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< int >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_erase" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
    }
  }
  result = std_vector_Sl_int_Sg__erase__SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::iterator arg2 ;
  std::vector< int >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< int >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_erase" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'");
    }
  }
  result = std_vector_Sl_int_Sg__erase__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_VectorInt_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_VectorInt_erase__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::erase(std::vector< int >::iterator)\n"
    "    std::vector< int >::erase(std::vector< int >::iterator,std::vector< int >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int >::size_type arg1 ;
  std::vector< int >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< int >::value_type temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< int > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorInt",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int >::size_type""'");
  } 
  arg1 = static_cast< std::vector< int >::size_type >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorInt" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
  } 
  temp2 = static_cast< std::vector< int >::value_type >(val2);
  arg2 = &temp2;
  result = (std::vector< int > *)new std::vector< int >(arg1,(std::vector< int >::value_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorInt(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_VectorInt__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_VectorInt__SWIG_2(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VectorInt__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_VectorInt__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorInt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::vector()\n"
    "    std::vector< int >::vector(std::vector< int > const &)\n"
    "    std::vector< int >::vector(std::vector< int >::size_type)\n"
    "    std::vector< int >::vector(std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorInt_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< int >::value_type temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_push_back",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_push_back" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_push_back" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
  } 
  temp2 = static_cast< std::vector< int >::value_type >(val2);
  arg2 = &temp2;
  (arg1)->push_back((std::vector< int >::value_type const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_front",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_front" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  result = (std::vector< int >::value_type *) &((std::vector< int > const *)arg1)->front();
  resultobj = SWIG_From_int(static_cast< int >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_back" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  result = (std::vector< int >::value_type *) &((std::vector< int > const *)arg1)->back();
  resultobj = SWIG_From_int(static_cast< int >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type arg2 ;
  std::vector< int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< int >::value_type temp3 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_assign",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_assign" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_assign" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< int >::size_type >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_assign" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< int >::value_type >(val3);
  arg3 = &temp3;
  (arg1)->assign(arg2,(std::vector< int >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type arg2 ;
  std::vector< int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< int >::value_type temp3 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_resize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_resize" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< int >::size_type >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_resize" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< int >::value_type >(val3);
  arg3 = &temp3;
  (arg1)->resize(arg2,(std::vector< int >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorInt_resize__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorInt_resize__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::resize(std::vector< int >::size_type)\n"
    "    std::vector< int >::resize(std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorInt_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::iterator arg2 ;
  std::vector< int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< int >::value_type temp3 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< int >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_insert",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_insert" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_insert" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< int >::value_type >(val3);
  arg3 = &temp3;
  result = std_vector_Sl_int_Sg__insert__SWIG_0(arg1,arg2,(int const &)*arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::iterator arg2 ;
  std::vector< int >::size_type arg3 ;
  std::vector< int >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::vector< int >::value_type temp4 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorInt_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_insert" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_insert" "', argument " "3"" of type '" "std::vector< int >::size_type""'");
  } 
  arg3 = static_cast< std::vector< int >::size_type >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorInt_insert" "', argument " "4"" of type '" "std::vector< int >::value_type""'");
  } 
  temp4 = static_cast< std::vector< int >::value_type >(val4);
  arg4 = &temp4;
  std_vector_Sl_int_Sg__insert__SWIG_1(arg1,arg2,arg3,(int const &)*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorInt_insert__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_VectorInt_insert__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::insert(std::vector< int >::iterator,std::vector< int >::value_type const &)\n"
    "    std::vector< int >::insert(std::vector< int >::iterator,std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorInt_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_reserve",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_reserve" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_reserve" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< int >::size_type >(val2);
  (arg1)->reserve(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorInt_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_capacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_capacity" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  result = ((std::vector< int > const *)arg1)->capacity();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VectorInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorInt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorInt" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VectorInt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_VectorString_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:VectorString_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_iterator" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  result = (swig::SwigPyIterator *)std_vector_Sl_std_string_Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorString___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___nonzero__" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  result = (bool)std_vector_Sl_std_string_Sg____nonzero__((std::vector< std::string > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorString___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___bool__" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  result = (bool)std_vector_Sl_std_string_Sg____bool__((std::vector< std::string > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::string >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorString___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___len__" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  result = std_vector_Sl_std_string_Sg____len__((std::vector< std::string > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorString___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___getslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorString___getslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorString___getslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
  try {
    result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg____getslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorString___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___setslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorString___setslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorString___setslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
  try {
    std_vector_Sl_std_string_Sg____setslice____SWIG_0(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::difference_type arg3 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorString___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___setslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorString___setslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorString___setslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorString___setslice__" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorString___setslice__" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg4 = ptr;
  }
  try {
    std_vector_Sl_std_string_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorString___setslice____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< std::string,std::allocator< std::string > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorString___setslice____SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorString___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::__setslice__(std::vector< std::string >::difference_type,std::vector< std::string >::difference_type)\n"
    "    std::vector< std::string >::__setslice__(std::vector< std::string >::difference_type,std::vector< std::string >::difference_type,std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorString___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorString___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___delslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorString___delslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorString___delslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
  try {
    std_vector_Sl_std_string_Sg____delslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorString___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___delitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorString___delitem__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  try {
    std_vector_Sl_std_string_Sg____delitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorString___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___getitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg____getitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorString___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___setitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorString___setitem__" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorString___setitem__" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    std_vector_Sl_std_string_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorString___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___setitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_std_string_Sg____setitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorString___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___delitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_std_string_Sg____delitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorString___delitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorString___delitem____SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorString___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::__delitem__(std::vector< std::string >::difference_type)\n"
    "    std::vector< std::string >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorString___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< std::string >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorString___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___getitem__" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorString___getitem__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  try {
    result = (std::vector< std::string >::value_type *) &std_vector_Sl_std_string_Sg____getitem____SWIG_1((std::vector< std::string > const *)arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorString___getitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorString___getitem____SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorString___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::__getitem__(PySliceObject *)\n"
    "    std::vector< std::string >::__getitem__(std::vector< std::string >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorString___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorString___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString___setitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorString___setitem__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorString___setitem__" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorString___setitem__" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    std_vector_Sl_std_string_Sg____setitem____SWIG_2(arg1,arg2,(std::string const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorString___setitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorString___setitem____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorString___setitem____SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorString___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::__setitem__(PySliceObject *,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    std::vector< std::string >::__setitem__(PySliceObject *)\n"
    "    std::vector< std::string >::__setitem__(std::vector< std::string >::difference_type,std::vector< std::string >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorString_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::string >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorString_pop",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_pop" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  try {
    result = std_vector_Sl_std_string_Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorString_append",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_append" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorString_append" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorString_append" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  std_vector_Sl_std_string_Sg__append(arg1,(std::string const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_VectorString")) SWIG_fail;
  result = (std::vector< std::string > *)new std::vector< std::string >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  std::vector< std::string > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorString",&obj0)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorString" "', argument " "1"" of type '" "std::vector< std::string > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorString" "', argument " "1"" of type '" "std::vector< std::string > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::vector< std::string > *)new std::vector< std::string >((std::vector< std::string > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorString_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_empty" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  result = (bool)((std::vector< std::string > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::string >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorString_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_size" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  result = ((std::vector< std::string > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorString_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_swap" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorString_swap" "', argument " "2"" of type '" "std::vector< std::string > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorString_swap" "', argument " "2"" of type '" "std::vector< std::string > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::string >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorString_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_begin" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::string >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorString_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_end" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::string >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorString_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_rbegin" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::string >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorString_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_rend" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorString_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_clear" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< std::string > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorString_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_get_allocator" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  result = ((std::vector< std::string > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new std::vector< std::string >::allocator_type(static_cast< const std::vector< std::string >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__string_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorString__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::string > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorString",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorString" "', argument " "1"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::string >::size_type >(val1);
  result = (std::vector< std::string > *)new std::vector< std::string >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorString_pop_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_pop_back" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorString_resize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_resize" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorString_resize" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  (arg1)->resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< std::string >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorString_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_erase" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  result = std_vector_Sl_std_string_Sg__erase__SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::iterator arg2 ;
  std::vector< std::string >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< std::string >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorString_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_erase" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString_erase" "', argument " "3"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString_erase" "', argument " "3"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  result = std_vector_Sl_std_string_Sg__erase__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_VectorString_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_VectorString_erase__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorString_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::erase(std::vector< std::string >::iterator)\n"
    "    std::vector< std::string >::erase(std::vector< std::string >::iterator,std::vector< std::string >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_VectorString__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string >::size_type arg1 ;
  std::vector< std::string >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< std::string > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorString",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorString" "', argument " "1"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::string >::size_type >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorString" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorString" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (std::vector< std::string > *)new std::vector< std::string >(arg1,(std::vector< std::string >::value_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorString(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_VectorString__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_VectorString__SWIG_2(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VectorString__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_VectorString__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::vector()\n"
    "    std::vector< std::string >::vector(std::vector< std::string > const &)\n"
    "    std::vector< std::string >::vector(std::vector< std::string >::size_type)\n"
    "    std::vector< std::string >::vector(std::vector< std::string >::size_type,std::vector< std::string >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorString_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorString_push_back",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_push_back" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorString_push_back" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorString_push_back" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  (arg1)->push_back((std::vector< std::string >::value_type const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::string >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorString_front",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_front" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  result = (std::vector< std::string >::value_type *) &((std::vector< std::string > const *)arg1)->front();
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::string >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorString_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_back" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  result = (std::vector< std::string >::value_type *) &((std::vector< std::string > const *)arg1)->back();
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorString_assign",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_assign" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorString_assign" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorString_assign" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorString_assign" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->assign(arg2,(std::vector< std::string >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorString_resize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_resize" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorString_resize" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorString_resize" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorString_resize" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->resize(arg2,(std::vector< std::string >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorString_resize__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorString_resize__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorString_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::resize(std::vector< std::string >::size_type)\n"
    "    std::vector< std::string >::resize(std::vector< std::string >::size_type,std::vector< std::string >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorString_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::iterator arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< std::string >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorString_insert",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_insert" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorString_insert" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorString_insert" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  result = std_vector_Sl_std_string_Sg__insert__SWIG_0(arg1,arg2,(std::string const &)*arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::iterator arg2 ;
  std::vector< std::string >::size_type arg3 ;
  std::vector< std::string >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorString_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_insert" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorString_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorString_insert" "', argument " "3"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::size_type >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorString_insert" "', argument " "4"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorString_insert" "', argument " "4"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg4 = ptr;
  }
  std_vector_Sl_std_string_Sg__insert__SWIG_1(arg1,arg2,arg3,(std::string const &)*arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorString_insert__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorString_insert__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorString_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::insert(std::vector< std::string >::iterator,std::vector< std::string >::value_type const &)\n"
    "    std::vector< std::string >::insert(std::vector< std::string >::iterator,std::vector< std::string >::size_type,std::vector< std::string >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorString_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorString_reserve",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_reserve" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorString_reserve" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  (arg1)->reserve(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorString_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::string >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorString_capacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorString_capacity" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  result = ((std::vector< std::string > const *)arg1)->capacity();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VectorString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorString",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorString" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VectorString_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_VectorPairIntInt_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:VectorPairIntInt_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt_iterator" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  result = (swig::SwigPyIterator *)std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorPairIntInt___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt___nonzero__" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  result = (bool)std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____nonzero__((std::vector< std::pair< int,int > > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorPairIntInt___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt___bool__" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  result = (bool)std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____bool__((std::vector< std::pair< int,int > > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::pair< int,int > >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorPairIntInt___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt___len__" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  result = std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____len__((std::vector< std::pair< int,int > > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  std::vector< std::pair< int,int > >::difference_type arg2 ;
  std::vector< std::pair< int,int > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorPairIntInt___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt___getslice__" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorPairIntInt___getslice__" "', argument " "2"" of type '" "std::vector< std::pair< int,int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< int,int > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorPairIntInt___getslice__" "', argument " "3"" of type '" "std::vector< std::pair< int,int > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< int,int > >::difference_type >(val3);
  try {
    result = (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *)std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____getslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  std::vector< std::pair< int,int > >::difference_type arg2 ;
  std::vector< std::pair< int,int > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorPairIntInt___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt___setslice__" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorPairIntInt___setslice__" "', argument " "2"" of type '" "std::vector< std::pair< int,int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< int,int > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorPairIntInt___setslice__" "', argument " "3"" of type '" "std::vector< std::pair< int,int > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< int,int > >::difference_type >(val3);
  try {
    std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____setslice____SWIG_0(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  std::vector< std::pair< int,int > >::difference_type arg2 ;
  std::vector< std::pair< int,int > >::difference_type arg3 ;
  std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorPairIntInt___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt___setslice__" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorPairIntInt___setslice__" "', argument " "2"" of type '" "std::vector< std::pair< int,int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< int,int > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorPairIntInt___setslice__" "', argument " "3"" of type '" "std::vector< std::pair< int,int > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< int,int > >::difference_type >(val3);
  {
    std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *ptr = (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorPairIntInt___setslice__" "', argument " "4"" of type '" "std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorPairIntInt___setslice__" "', argument " "4"" of type '" "std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > const &""'"); 
    }
    arg4 = ptr;
  }
  try {
    std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > const &)*arg4);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorPairIntInt___setslice____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorPairIntInt___setslice____SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorPairIntInt___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< int,int > >::__setslice__(std::vector< std::pair< int,int > >::difference_type,std::vector< std::pair< int,int > >::difference_type)\n"
    "    std::vector< std::pair< int,int > >::__setslice__(std::vector< std::pair< int,int > >::difference_type,std::vector< std::pair< int,int > >::difference_type,std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  std::vector< std::pair< int,int > >::difference_type arg2 ;
  std::vector< std::pair< int,int > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorPairIntInt___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt___delslice__" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorPairIntInt___delslice__" "', argument " "2"" of type '" "std::vector< std::pair< int,int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< int,int > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorPairIntInt___delslice__" "', argument " "3"" of type '" "std::vector< std::pair< int,int > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< int,int > >::difference_type >(val3);
  try {
    std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____delslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  std::vector< std::pair< int,int > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorPairIntInt___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt___delitem__" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorPairIntInt___delitem__" "', argument " "2"" of type '" "std::vector< std::pair< int,int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< int,int > >::difference_type >(val2);
  try {
    std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____delitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorPairIntInt___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt___getitem__" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorPairIntInt___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    result = (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *)std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____getitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorPairIntInt___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt___setitem__" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorPairIntInt___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  {
    std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *ptr = (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorPairIntInt___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorPairIntInt___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorPairIntInt___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt___setitem__" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorPairIntInt___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____setitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorPairIntInt___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt___delitem__" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorPairIntInt___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____delitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorPairIntInt___delitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorPairIntInt___delitem____SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorPairIntInt___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< int,int > >::__delitem__(std::vector< std::pair< int,int > >::difference_type)\n"
    "    std::vector< std::pair< int,int > >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  std::vector< std::pair< int,int > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< std::pair< int,int > >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorPairIntInt___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt___getitem__" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorPairIntInt___getitem__" "', argument " "2"" of type '" "std::vector< std::pair< int,int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< int,int > >::difference_type >(val2);
  try {
    result = (std::vector< std::pair< int,int > >::value_type *) &std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____getitem____SWIG_1((std::vector< std::pair< int,int > > const *)arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = swig::from(static_cast< std::pair< int,int > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorPairIntInt___getitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorPairIntInt___getitem____SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorPairIntInt___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< int,int > >::__getitem__(PySliceObject *)\n"
    "    std::vector< std::pair< int,int > >::__getitem__(std::vector< std::pair< int,int > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  std::vector< std::pair< int,int > >::difference_type arg2 ;
  std::vector< std::pair< int,int > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorPairIntInt___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt___setitem__" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorPairIntInt___setitem__" "', argument " "2"" of type '" "std::vector< std::pair< int,int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< int,int > >::difference_type >(val2);
  {
    std::pair< int,int > *ptr = (std::pair< int,int > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorPairIntInt___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< int,int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorPairIntInt___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< int,int > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg____setitem____SWIG_2(arg1,arg2,(std::pair< int,int > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorPairIntInt___setitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorPairIntInt___setitem____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::pair< int,int >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorPairIntInt___setitem____SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorPairIntInt___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< int,int > >::__setitem__(PySliceObject *,std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > const &)\n"
    "    std::vector< std::pair< int,int > >::__setitem__(PySliceObject *)\n"
    "    std::vector< std::pair< int,int > >::__setitem__(std::vector< std::pair< int,int > >::difference_type,std::vector< std::pair< int,int > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::pair< int,int > >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorPairIntInt_pop",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt_pop" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  try {
    result = std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = swig::from(static_cast< std::pair< int,int > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  std::vector< std::pair< int,int > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorPairIntInt_append",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt_append" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  {
    std::pair< int,int > *ptr = (std::pair< int,int > *)0;
    res2 = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorPairIntInt_append" "', argument " "2"" of type '" "std::vector< std::pair< int,int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorPairIntInt_append" "', argument " "2"" of type '" "std::vector< std::pair< int,int > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg__append(arg1,(std::pair< int,int > const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorPairIntInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_VectorPairIntInt")) SWIG_fail;
  result = (std::vector< std::pair< int,int > > *)new std::vector< std::pair< int,int > >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorPairIntInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  std::vector< std::pair< int,int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorPairIntInt",&obj0)) SWIG_fail;
  {
    std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *ptr = (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorPairIntInt" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorPairIntInt" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::vector< std::pair< int,int > > *)new std::vector< std::pair< int,int > >((std::vector< std::pair< int,int > > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorPairIntInt_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt_empty" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  result = (bool)((std::vector< std::pair< int,int > > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::pair< int,int > >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorPairIntInt_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt_size" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  result = ((std::vector< std::pair< int,int > > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  std::vector< std::pair< int,int > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorPairIntInt_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt_swap" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorPairIntInt_swap" "', argument " "2"" of type '" "std::vector< std::pair< int,int > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorPairIntInt_swap" "', argument " "2"" of type '" "std::vector< std::pair< int,int > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::pair< int,int > >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorPairIntInt_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt_begin" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< int,int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::pair< int,int > >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorPairIntInt_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt_end" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< int,int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::pair< int,int > >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorPairIntInt_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt_rbegin" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< int,int > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::pair< int,int > >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorPairIntInt_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt_rend" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< int,int > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorPairIntInt_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt_clear" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< std::pair< int,int > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorPairIntInt_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt_get_allocator" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  result = ((std::vector< std::pair< int,int > > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new std::vector< std::pair< int,int > >::allocator_type(static_cast< const std::vector< std::pair< int,int > >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__pairT_int_int_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorPairIntInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::pair< int,int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorPairIntInt",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorPairIntInt" "', argument " "1"" of type '" "std::vector< std::pair< int,int > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::pair< int,int > >::size_type >(val1);
  result = (std::vector< std::pair< int,int > > *)new std::vector< std::pair< int,int > >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorPairIntInt_pop_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt_pop_back" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  std::vector< std::pair< int,int > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorPairIntInt_resize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt_resize" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorPairIntInt_resize" "', argument " "2"" of type '" "std::vector< std::pair< int,int > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< int,int > >::size_type >(val2);
  (arg1)->resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  std::vector< std::pair< int,int > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< std::pair< int,int > >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorPairIntInt_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt_erase" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorPairIntInt_erase" "', argument " "2"" of type '" "std::vector< std::pair< int,int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< int,int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< int,int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorPairIntInt_erase" "', argument " "2"" of type '" "std::vector< std::pair< int,int > >::iterator""'");
    }
  }
  result = std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg__erase__SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< int,int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  std::vector< std::pair< int,int > >::iterator arg2 ;
  std::vector< std::pair< int,int > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< std::pair< int,int > >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorPairIntInt_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt_erase" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorPairIntInt_erase" "', argument " "2"" of type '" "std::vector< std::pair< int,int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< int,int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< int,int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorPairIntInt_erase" "', argument " "2"" of type '" "std::vector< std::pair< int,int > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorPairIntInt_erase" "', argument " "3"" of type '" "std::vector< std::pair< int,int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< int,int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< int,int > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorPairIntInt_erase" "', argument " "3"" of type '" "std::vector< std::pair< int,int > >::iterator""'");
    }
  }
  result = std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg__erase__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< int,int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< int,int > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_VectorPairIntInt_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< int,int > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< int,int > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_VectorPairIntInt_erase__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorPairIntInt_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< int,int > >::erase(std::vector< std::pair< int,int > >::iterator)\n"
    "    std::vector< std::pair< int,int > >::erase(std::vector< std::pair< int,int > >::iterator,std::vector< std::pair< int,int > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_VectorPairIntInt__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > >::size_type arg1 ;
  std::vector< std::pair< int,int > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< std::pair< int,int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorPairIntInt",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorPairIntInt" "', argument " "1"" of type '" "std::vector< std::pair< int,int > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::pair< int,int > >::size_type >(val1);
  {
    std::pair< int,int > *ptr = (std::pair< int,int > *)0;
    res2 = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorPairIntInt" "', argument " "2"" of type '" "std::vector< std::pair< int,int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorPairIntInt" "', argument " "2"" of type '" "std::vector< std::pair< int,int > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (std::vector< std::pair< int,int > > *)new std::vector< std::pair< int,int > >(arg1,(std::vector< std::pair< int,int > >::value_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorPairIntInt(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_VectorPairIntInt__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_VectorPairIntInt__SWIG_2(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VectorPairIntInt__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::pair< int,int >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_VectorPairIntInt__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorPairIntInt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< int,int > >::vector()\n"
    "    std::vector< std::pair< int,int > >::vector(std::vector< std::pair< int,int > > const &)\n"
    "    std::vector< std::pair< int,int > >::vector(std::vector< std::pair< int,int > >::size_type)\n"
    "    std::vector< std::pair< int,int > >::vector(std::vector< std::pair< int,int > >::size_type,std::vector< std::pair< int,int > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  std::vector< std::pair< int,int > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorPairIntInt_push_back",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt_push_back" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  {
    std::pair< int,int > *ptr = (std::pair< int,int > *)0;
    res2 = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorPairIntInt_push_back" "', argument " "2"" of type '" "std::vector< std::pair< int,int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorPairIntInt_push_back" "', argument " "2"" of type '" "std::vector< std::pair< int,int > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  (arg1)->push_back((std::vector< std::pair< int,int > >::value_type const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::pair< int,int > >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorPairIntInt_front",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt_front" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  result = (std::vector< std::pair< int,int > >::value_type *) &((std::vector< std::pair< int,int > > const *)arg1)->front();
  resultobj = swig::from(static_cast< std::pair< int,int > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::pair< int,int > >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorPairIntInt_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt_back" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  result = (std::vector< std::pair< int,int > >::value_type *) &((std::vector< std::pair< int,int > > const *)arg1)->back();
  resultobj = swig::from(static_cast< std::pair< int,int > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  std::vector< std::pair< int,int > >::size_type arg2 ;
  std::vector< std::pair< int,int > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorPairIntInt_assign",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt_assign" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorPairIntInt_assign" "', argument " "2"" of type '" "std::vector< std::pair< int,int > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< int,int > >::size_type >(val2);
  {
    std::pair< int,int > *ptr = (std::pair< int,int > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorPairIntInt_assign" "', argument " "3"" of type '" "std::vector< std::pair< int,int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorPairIntInt_assign" "', argument " "3"" of type '" "std::vector< std::pair< int,int > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->assign(arg2,(std::vector< std::pair< int,int > >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  std::vector< std::pair< int,int > >::size_type arg2 ;
  std::vector< std::pair< int,int > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorPairIntInt_resize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt_resize" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorPairIntInt_resize" "', argument " "2"" of type '" "std::vector< std::pair< int,int > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< int,int > >::size_type >(val2);
  {
    std::pair< int,int > *ptr = (std::pair< int,int > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorPairIntInt_resize" "', argument " "3"" of type '" "std::vector< std::pair< int,int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorPairIntInt_resize" "', argument " "3"" of type '" "std::vector< std::pair< int,int > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->resize(arg2,(std::vector< std::pair< int,int > >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorPairIntInt_resize__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::pair< int,int >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorPairIntInt_resize__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorPairIntInt_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< int,int > >::resize(std::vector< std::pair< int,int > >::size_type)\n"
    "    std::vector< std::pair< int,int > >::resize(std::vector< std::pair< int,int > >::size_type,std::vector< std::pair< int,int > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  std::vector< std::pair< int,int > >::iterator arg2 ;
  std::vector< std::pair< int,int > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< std::pair< int,int > >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorPairIntInt_insert",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt_insert" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorPairIntInt_insert" "', argument " "2"" of type '" "std::vector< std::pair< int,int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< int,int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< int,int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorPairIntInt_insert" "', argument " "2"" of type '" "std::vector< std::pair< int,int > >::iterator""'");
    }
  }
  {
    std::pair< int,int > *ptr = (std::pair< int,int > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorPairIntInt_insert" "', argument " "3"" of type '" "std::vector< std::pair< int,int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorPairIntInt_insert" "', argument " "3"" of type '" "std::vector< std::pair< int,int > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  result = std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg__insert__SWIG_0(arg1,arg2,(std::pair< int,int > const &)*arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< int,int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  std::vector< std::pair< int,int > >::iterator arg2 ;
  std::vector< std::pair< int,int > >::size_type arg3 ;
  std::vector< std::pair< int,int > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorPairIntInt_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt_insert" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorPairIntInt_insert" "', argument " "2"" of type '" "std::vector< std::pair< int,int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< int,int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< int,int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorPairIntInt_insert" "', argument " "2"" of type '" "std::vector< std::pair< int,int > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorPairIntInt_insert" "', argument " "3"" of type '" "std::vector< std::pair< int,int > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< int,int > >::size_type >(val3);
  {
    std::pair< int,int > *ptr = (std::pair< int,int > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorPairIntInt_insert" "', argument " "4"" of type '" "std::vector< std::pair< int,int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorPairIntInt_insert" "', argument " "4"" of type '" "std::vector< std::pair< int,int > >::value_type const &""'"); 
    }
    arg4 = ptr;
  }
  std_vector_Sl_std_pair_Sl_int_Sc_int_Sg__Sg__insert__SWIG_1(arg1,arg2,arg3,(std::pair< int,int > const &)*arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< int,int > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = swig::asptr(argv[2], (std::pair< int,int >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorPairIntInt_insert__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< int,int > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::pair< int,int >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorPairIntInt_insert__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorPairIntInt_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< int,int > >::insert(std::vector< std::pair< int,int > >::iterator,std::vector< std::pair< int,int > >::value_type const &)\n"
    "    std::vector< std::pair< int,int > >::insert(std::vector< std::pair< int,int > >::iterator,std::vector< std::pair< int,int > >::size_type,std::vector< std::pair< int,int > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  std::vector< std::pair< int,int > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorPairIntInt_reserve",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt_reserve" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorPairIntInt_reserve" "', argument " "2"" of type '" "std::vector< std::pair< int,int > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< int,int > >::size_type >(val2);
  (arg1)->reserve(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorPairIntInt_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::pair< int,int > >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorPairIntInt_capacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPairIntInt_capacity" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  result = ((std::vector< std::pair< int,int > > const *)arg1)->capacity();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VectorPairIntInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< int,int > > *arg1 = (std::vector< std::pair< int,int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorPairIntInt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorPairIntInt" "', argument " "1"" of type '" "std::vector< std::pair< int,int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< int,int > > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VectorPairIntInt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_VectorVectorInt_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorInt_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt_iterator" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  result = (swig::SwigPyIterator *)std_vector_Sl_std_vector_Sl_int_Sg__Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorInt___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt___nonzero__" "', argument " "1"" of type '" "std::vector< std::vector< int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  result = (bool)std_vector_Sl_std_vector_Sl_int_Sg__Sg____nonzero__((std::vector< std::vector< int > > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorInt___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt___bool__" "', argument " "1"" of type '" "std::vector< std::vector< int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  result = (bool)std_vector_Sl_std_vector_Sl_int_Sg__Sg____bool__((std::vector< std::vector< int > > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< int > >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorInt___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt___len__" "', argument " "1"" of type '" "std::vector< std::vector< int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  result = std_vector_Sl_std_vector_Sl_int_Sg__Sg____len__((std::vector< std::vector< int > > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int > >::difference_type arg2 ;
  std::vector< std::vector< int > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVectorInt___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt___getslice__" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVectorInt___getslice__" "', argument " "2"" of type '" "std::vector< std::vector< int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< int > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVectorInt___getslice__" "', argument " "3"" of type '" "std::vector< std::vector< int > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< int > >::difference_type >(val3);
  try {
    result = (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *)std_vector_Sl_std_vector_Sl_int_Sg__Sg____getslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int > >::difference_type arg2 ;
  std::vector< std::vector< int > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVectorInt___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt___setslice__" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVectorInt___setslice__" "', argument " "2"" of type '" "std::vector< std::vector< int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< int > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVectorInt___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< int > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< int > >::difference_type >(val3);
  try {
    std_vector_Sl_std_vector_Sl_int_Sg__Sg____setslice____SWIG_0(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int > >::difference_type arg2 ;
  std::vector< std::vector< int > >::difference_type arg3 ;
  std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorVectorInt___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt___setslice__" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVectorInt___setslice__" "', argument " "2"" of type '" "std::vector< std::vector< int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< int > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVectorInt___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< int > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< int > >::difference_type >(val3);
  {
    std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *ptr = (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorVectorInt___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVectorInt___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &""'"); 
    }
    arg4 = ptr;
  }
  try {
    std_vector_Sl_std_vector_Sl_int_Sg__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &)*arg4);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorVectorInt___setslice____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorVectorInt___setslice____SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVectorInt___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< int > >::__setslice__(std::vector< std::vector< int > >::difference_type,std::vector< std::vector< int > >::difference_type)\n"
    "    std::vector< std::vector< int > >::__setslice__(std::vector< std::vector< int > >::difference_type,std::vector< std::vector< int > >::difference_type,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int > >::difference_type arg2 ;
  std::vector< std::vector< int > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVectorInt___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt___delslice__" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVectorInt___delslice__" "', argument " "2"" of type '" "std::vector< std::vector< int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< int > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVectorInt___delslice__" "', argument " "3"" of type '" "std::vector< std::vector< int > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< int > >::difference_type >(val3);
  try {
    std_vector_Sl_std_vector_Sl_int_Sg__Sg____delslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVectorInt___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt___delitem__" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVectorInt___delitem__" "', argument " "2"" of type '" "std::vector< std::vector< int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< int > >::difference_type >(val2);
  try {
    std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVectorInt___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt___getitem__" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorInt___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    result = (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *)std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVectorInt___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorInt___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  {
    std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *ptr = (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVectorInt___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVectorInt___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVectorInt___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorInt___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVectorInt___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt___delitem__" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorInt___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorVectorInt___delitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorVectorInt___delitem____SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVectorInt___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< int > >::__delitem__(std::vector< std::vector< int > >::difference_type)\n"
    "    std::vector< std::vector< int > >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< std::vector< int > >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVectorInt___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt___getitem__" "', argument " "1"" of type '" "std::vector< std::vector< int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVectorInt___getitem__" "', argument " "2"" of type '" "std::vector< std::vector< int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< int > >::difference_type >(val2);
  try {
    result = (std::vector< std::vector< int > >::value_type *) &std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_1((std::vector< std::vector< int > > const *)arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorVectorInt___getitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorVectorInt___getitem____SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVectorInt___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< int > >::__getitem__(PySliceObject *)\n"
    "    std::vector< std::vector< int > >::__getitem__(std::vector< std::vector< int > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int > >::difference_type arg2 ;
  std::vector< std::vector< int > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVectorInt___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVectorInt___setitem__" "', argument " "2"" of type '" "std::vector< std::vector< int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< int > >::difference_type >(val2);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVectorInt___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVectorInt___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_2(arg1,arg2,(std::vector< int,std::allocator< int > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorVectorInt___setitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorVectorInt___setitem____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< int,std::allocator< int > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorVectorInt___setitem____SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVectorInt___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< int > >::__setitem__(PySliceObject *,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &)\n"
    "    std::vector< std::vector< int > >::__setitem__(PySliceObject *)\n"
    "    std::vector< std::vector< int > >::__setitem__(std::vector< std::vector< int > >::difference_type,std::vector< std::vector< int > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< int > >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorInt_pop",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt_pop" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  try {
    result = std_vector_Sl_std_vector_Sl_int_Sg__Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVectorInt_append",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt_append" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res2 = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVectorInt_append" "', argument " "2"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVectorInt_append" "', argument " "2"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  std_vector_Sl_std_vector_Sl_int_Sg__Sg__append(arg1,(std::vector< int,std::allocator< int > > const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorVectorInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_VectorVectorInt")) SWIG_fail;
  result = (std::vector< std::vector< int > > *)new std::vector< std::vector< int > >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorVectorInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int,std::allocator< int > > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorVectorInt",&obj0)) SWIG_fail;
  {
    std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *ptr = (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorVectorInt" "', argument " "1"" of type '" "std::vector< std::vector< int,std::allocator< int > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorVectorInt" "', argument " "1"" of type '" "std::vector< std::vector< int,std::allocator< int > > > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::vector< std::vector< int > > *)new std::vector< std::vector< int > >((std::vector< std::vector< int,std::allocator< int > > > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorInt_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt_empty" "', argument " "1"" of type '" "std::vector< std::vector< int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  result = (bool)((std::vector< std::vector< int > > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< int > >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorInt_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt_size" "', argument " "1"" of type '" "std::vector< std::vector< int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  result = ((std::vector< std::vector< int > > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int,std::allocator< int > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVectorInt_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt_swap" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVectorInt_swap" "', argument " "2"" of type '" "std::vector< std::vector< int,std::allocator< int > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVectorInt_swap" "', argument " "2"" of type '" "std::vector< std::vector< int,std::allocator< int > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< int,std::allocator< int > > > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< int > >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorInt_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt_begin" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< int > >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorInt_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt_end" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< int > >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorInt_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt_rbegin" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< int > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< int > >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorInt_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt_rend" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< int > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorInt_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt_clear" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< std::vector< int,std::allocator< int > > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorInt_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt_get_allocator" "', argument " "1"" of type '" "std::vector< std::vector< int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  result = ((std::vector< std::vector< int > > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new std::vector< std::vector< int > >::allocator_type(static_cast< const std::vector< std::vector< int > >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorVectorInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorVectorInt",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorVectorInt" "', argument " "1"" of type '" "std::vector< std::vector< int > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::vector< int > >::size_type >(val1);
  result = (std::vector< std::vector< int > > *)new std::vector< std::vector< int > >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorInt_pop_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt_pop_back" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVectorInt_resize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt_resize" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVectorInt_resize" "', argument " "2"" of type '" "std::vector< std::vector< int > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< int > >::size_type >(val2);
  (arg1)->resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< std::vector< int > >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVectorInt_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt_erase" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorInt_erase" "', argument " "2"" of type '" "std::vector< std::vector< int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorInt_erase" "', argument " "2"" of type '" "std::vector< std::vector< int > >::iterator""'");
    }
  }
  result = std_vector_Sl_std_vector_Sl_int_Sg__Sg__erase__SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int > >::iterator arg2 ;
  std::vector< std::vector< int > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< std::vector< int > >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVectorInt_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt_erase" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorInt_erase" "', argument " "2"" of type '" "std::vector< std::vector< int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorInt_erase" "', argument " "2"" of type '" "std::vector< std::vector< int > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorInt_erase" "', argument " "3"" of type '" "std::vector< std::vector< int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorInt_erase" "', argument " "3"" of type '" "std::vector< std::vector< int > >::iterator""'");
    }
  }
  result = std_vector_Sl_std_vector_Sl_int_Sg__Sg__erase__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_VectorVectorInt_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_VectorVectorInt_erase__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVectorInt_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< int > >::erase(std::vector< std::vector< int > >::iterator)\n"
    "    std::vector< std::vector< int > >::erase(std::vector< std::vector< int > >::iterator,std::vector< std::vector< int > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_VectorVectorInt__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > >::size_type arg1 ;
  std::vector< std::vector< int > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< std::vector< int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorVectorInt",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorVectorInt" "', argument " "1"" of type '" "std::vector< std::vector< int > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::vector< int > >::size_type >(val1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res2 = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorVectorInt" "', argument " "2"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorVectorInt" "', argument " "2"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (std::vector< std::vector< int > > *)new std::vector< std::vector< int > >(arg1,(std::vector< std::vector< int > >::value_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorVectorInt(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_VectorVectorInt__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_VectorVectorInt__SWIG_2(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VectorVectorInt__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< int,std::allocator< int > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_VectorVectorInt__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorVectorInt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< int > >::vector()\n"
    "    std::vector< std::vector< int > >::vector(std::vector< std::vector< int,std::allocator< int > > > const &)\n"
    "    std::vector< std::vector< int > >::vector(std::vector< std::vector< int > >::size_type)\n"
    "    std::vector< std::vector< int > >::vector(std::vector< std::vector< int > >::size_type,std::vector< std::vector< int > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVectorInt_push_back",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt_push_back" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res2 = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVectorInt_push_back" "', argument " "2"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVectorInt_push_back" "', argument " "2"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  (arg1)->push_back((std::vector< std::vector< int > >::value_type const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< int > >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorInt_front",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt_front" "', argument " "1"" of type '" "std::vector< std::vector< int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  result = (std::vector< std::vector< int > >::value_type *) &((std::vector< std::vector< int > > const *)arg1)->front();
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< int > >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorInt_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt_back" "', argument " "1"" of type '" "std::vector< std::vector< int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  result = (std::vector< std::vector< int > >::value_type *) &((std::vector< std::vector< int > > const *)arg1)->back();
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int > >::size_type arg2 ;
  std::vector< std::vector< int > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVectorInt_assign",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt_assign" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVectorInt_assign" "', argument " "2"" of type '" "std::vector< std::vector< int > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< int > >::size_type >(val2);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVectorInt_assign" "', argument " "3"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVectorInt_assign" "', argument " "3"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->assign(arg2,(std::vector< std::vector< int > >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int > >::size_type arg2 ;
  std::vector< std::vector< int > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVectorInt_resize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt_resize" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVectorInt_resize" "', argument " "2"" of type '" "std::vector< std::vector< int > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< int > >::size_type >(val2);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVectorInt_resize" "', argument " "3"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVectorInt_resize" "', argument " "3"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->resize(arg2,(std::vector< std::vector< int > >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorVectorInt_resize__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< int,std::allocator< int > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorVectorInt_resize__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVectorInt_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< int > >::resize(std::vector< std::vector< int > >::size_type)\n"
    "    std::vector< std::vector< int > >::resize(std::vector< std::vector< int > >::size_type,std::vector< std::vector< int > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int > >::iterator arg2 ;
  std::vector< std::vector< int > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< std::vector< int > >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVectorInt_insert",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt_insert" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorInt_insert" "', argument " "2"" of type '" "std::vector< std::vector< int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorInt_insert" "', argument " "2"" of type '" "std::vector< std::vector< int > >::iterator""'");
    }
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVectorInt_insert" "', argument " "3"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVectorInt_insert" "', argument " "3"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  result = std_vector_Sl_std_vector_Sl_int_Sg__Sg__insert__SWIG_0(arg1,arg2,(std::vector< int,std::allocator< int > > const &)*arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int > >::iterator arg2 ;
  std::vector< std::vector< int > >::size_type arg3 ;
  std::vector< std::vector< int > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorVectorInt_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt_insert" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorInt_insert" "', argument " "2"" of type '" "std::vector< std::vector< int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorInt_insert" "', argument " "2"" of type '" "std::vector< std::vector< int > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVectorInt_insert" "', argument " "3"" of type '" "std::vector< std::vector< int > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< int > >::size_type >(val3);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorVectorInt_insert" "', argument " "4"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVectorInt_insert" "', argument " "4"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    arg4 = ptr;
  }
  std_vector_Sl_std_vector_Sl_int_Sg__Sg__insert__SWIG_1(arg1,arg2,arg3,(std::vector< int,std::allocator< int > > const &)*arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< int,std::allocator< int > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorVectorInt_insert__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< int,std::allocator< int > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorVectorInt_insert__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVectorInt_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< int > >::insert(std::vector< std::vector< int > >::iterator,std::vector< std::vector< int > >::value_type const &)\n"
    "    std::vector< std::vector< int > >::insert(std::vector< std::vector< int > >::iterator,std::vector< std::vector< int > >::size_type,std::vector< std::vector< int > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVectorInt_reserve",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt_reserve" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVectorInt_reserve" "', argument " "2"" of type '" "std::vector< std::vector< int > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< int > >::size_type >(val2);
  (arg1)->reserve(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorInt_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< int > >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorInt_capacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorInt_capacity" "', argument " "1"" of type '" "std::vector< std::vector< int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  result = ((std::vector< std::vector< int > > const *)arg1)->capacity();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VectorVectorInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorVectorInt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorVectorInt" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VectorVectorInt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_VectorVectorComplex_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorComplex_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex_iterator" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  result = (swig::SwigPyIterator *)std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorComplex___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex___nonzero__" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  result = (bool)std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____nonzero__((std::vector< std::vector< std::complex< double > > > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorComplex___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex___bool__" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  result = (bool)std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____bool__((std::vector< std::vector< std::complex< double > > > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< std::complex< double > > >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorComplex___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex___len__" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  result = std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____len__((std::vector< std::vector< std::complex< double > > > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  std::vector< std::vector< std::complex< double > > >::difference_type arg2 ;
  std::vector< std::vector< std::complex< double > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVectorComplex___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex___getslice__" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVectorComplex___getslice__" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< std::complex< double > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVectorComplex___getslice__" "', argument " "3"" of type '" "std::vector< std::vector< std::complex< double > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< std::complex< double > > >::difference_type >(val3);
  try {
    result = (std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > *)std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____getslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  std::vector< std::vector< std::complex< double > > >::difference_type arg2 ;
  std::vector< std::vector< std::complex< double > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVectorComplex___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex___setslice__" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVectorComplex___setslice__" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< std::complex< double > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVectorComplex___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< std::complex< double > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< std::complex< double > > >::difference_type >(val3);
  try {
    std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____setslice____SWIG_0(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  std::vector< std::vector< std::complex< double > > >::difference_type arg2 ;
  std::vector< std::vector< std::complex< double > > >::difference_type arg3 ;
  std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorVectorComplex___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex___setslice__" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVectorComplex___setslice__" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< std::complex< double > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVectorComplex___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< std::complex< double > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< std::complex< double > > >::difference_type >(val3);
  {
    std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > *ptr = (std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorVectorComplex___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVectorComplex___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > const &""'"); 
    }
    arg4 = ptr;
  }
  try {
    std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > const &)*arg4);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorVectorComplex___setslice____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorVectorComplex___setslice____SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVectorComplex___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< std::complex< double > > >::__setslice__(std::vector< std::vector< std::complex< double > > >::difference_type,std::vector< std::vector< std::complex< double > > >::difference_type)\n"
    "    std::vector< std::vector< std::complex< double > > >::__setslice__(std::vector< std::vector< std::complex< double > > >::difference_type,std::vector< std::vector< std::complex< double > > >::difference_type,std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  std::vector< std::vector< std::complex< double > > >::difference_type arg2 ;
  std::vector< std::vector< std::complex< double > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVectorComplex___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex___delslice__" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVectorComplex___delslice__" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< std::complex< double > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVectorComplex___delslice__" "', argument " "3"" of type '" "std::vector< std::vector< std::complex< double > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< std::complex< double > > >::difference_type >(val3);
  try {
    std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____delslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  std::vector< std::vector< std::complex< double > > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVectorComplex___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex___delitem__" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVectorComplex___delitem__" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< std::complex< double > > >::difference_type >(val2);
  try {
    std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____delitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVectorComplex___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex___getitem__" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorComplex___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    result = (std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > *)std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____getitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVectorComplex___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorComplex___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  {
    std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > *ptr = (std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVectorComplex___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVectorComplex___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVectorComplex___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorComplex___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____setitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVectorComplex___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex___delitem__" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorComplex___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____delitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorVectorComplex___delitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorVectorComplex___delitem____SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVectorComplex___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< std::complex< double > > >::__delitem__(std::vector< std::vector< std::complex< double > > >::difference_type)\n"
    "    std::vector< std::vector< std::complex< double > > >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  std::vector< std::vector< std::complex< double > > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< std::vector< std::complex< double > > >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVectorComplex___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex___getitem__" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVectorComplex___getitem__" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< std::complex< double > > >::difference_type >(val2);
  try {
    result = (std::vector< std::vector< std::complex< double > > >::value_type *) &std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____getitem____SWIG_1((std::vector< std::vector< std::complex< double > > > const *)arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = swig::from(static_cast< std::vector< std::complex< double >,std::allocator< std::complex< double > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorVectorComplex___getitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorVectorComplex___getitem____SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVectorComplex___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< std::complex< double > > >::__getitem__(PySliceObject *)\n"
    "    std::vector< std::vector< std::complex< double > > >::__getitem__(std::vector< std::vector< std::complex< double > > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  std::vector< std::vector< std::complex< double > > >::difference_type arg2 ;
  std::vector< std::vector< std::complex< double > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVectorComplex___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVectorComplex___setitem__" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< std::complex< double > > >::difference_type >(val2);
  {
    std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVectorComplex___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< std::complex< double > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVectorComplex___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< std::complex< double > > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg____setitem____SWIG_2(arg1,arg2,(std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorVectorComplex___setitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorVectorComplex___setitem____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorVectorComplex___setitem____SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVectorComplex___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< std::complex< double > > >::__setitem__(PySliceObject *,std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > const &)\n"
    "    std::vector< std::vector< std::complex< double > > >::__setitem__(PySliceObject *)\n"
    "    std::vector< std::vector< std::complex< double > > >::__setitem__(std::vector< std::vector< std::complex< double > > >::difference_type,std::vector< std::vector< std::complex< double > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< std::complex< double > > >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorComplex_pop",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex_pop" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  try {
    result = std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = swig::from(static_cast< std::vector< std::complex< double >,std::allocator< std::complex< double > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  std::vector< std::vector< std::complex< double > > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVectorComplex_append",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex_append" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  {
    std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
    res2 = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVectorComplex_append" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVectorComplex_append" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double > > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg__append(arg1,(std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorVectorComplex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_VectorVectorComplex")) SWIG_fail;
  result = (std::vector< std::vector< std::complex< double > > > *)new std::vector< std::vector< std::complex< double > > >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorVectorComplex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< std::complex< double > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorVectorComplex",&obj0)) SWIG_fail;
  {
    std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > *ptr = (std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorVectorComplex" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorVectorComplex" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::vector< std::vector< std::complex< double > > > *)new std::vector< std::vector< std::complex< double > > >((std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorComplex_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex_empty" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  result = (bool)((std::vector< std::vector< std::complex< double > > > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< std::complex< double > > >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorComplex_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex_size" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  result = ((std::vector< std::vector< std::complex< double > > > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVectorComplex_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex_swap" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVectorComplex_swap" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVectorComplex_swap" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< std::complex< double > > >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorComplex_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex_begin" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< std::complex< double > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< std::complex< double > > >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorComplex_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex_end" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< std::complex< double > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< std::complex< double > > >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorComplex_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex_rbegin" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< std::complex< double > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< std::complex< double > > >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorComplex_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex_rend" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< std::complex< double > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorComplex_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex_clear" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorComplex_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex_get_allocator" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  result = ((std::vector< std::vector< std::complex< double > > > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new std::vector< std::vector< std::complex< double > > >::allocator_type(static_cast< const std::vector< std::vector< std::complex< double > > >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorVectorComplex__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< std::complex< double > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorVectorComplex",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorVectorComplex" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::vector< std::complex< double > > >::size_type >(val1);
  result = (std::vector< std::vector< std::complex< double > > > *)new std::vector< std::vector< std::complex< double > > >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorComplex_pop_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex_pop_back" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  std::vector< std::vector< std::complex< double > > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVectorComplex_resize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex_resize" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVectorComplex_resize" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< std::complex< double > > >::size_type >(val2);
  (arg1)->resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  std::vector< std::vector< std::complex< double > > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< std::vector< std::complex< double > > >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVectorComplex_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex_erase" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorComplex_erase" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< std::complex< double > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< std::complex< double > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorComplex_erase" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double > > >::iterator""'");
    }
  }
  result = std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg__erase__SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< std::complex< double > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  std::vector< std::vector< std::complex< double > > >::iterator arg2 ;
  std::vector< std::vector< std::complex< double > > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< std::vector< std::complex< double > > >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVectorComplex_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex_erase" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorComplex_erase" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< std::complex< double > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< std::complex< double > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorComplex_erase" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double > > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorComplex_erase" "', argument " "3"" of type '" "std::vector< std::vector< std::complex< double > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< std::complex< double > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< std::complex< double > > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorComplex_erase" "', argument " "3"" of type '" "std::vector< std::vector< std::complex< double > > >::iterator""'");
    }
  }
  result = std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg__erase__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< std::complex< double > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< std::complex< double > > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_VectorVectorComplex_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< std::complex< double > > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< std::complex< double > > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_VectorVectorComplex_erase__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVectorComplex_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< std::complex< double > > >::erase(std::vector< std::vector< std::complex< double > > >::iterator)\n"
    "    std::vector< std::vector< std::complex< double > > >::erase(std::vector< std::vector< std::complex< double > > >::iterator,std::vector< std::vector< std::complex< double > > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_VectorVectorComplex__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > >::size_type arg1 ;
  std::vector< std::vector< std::complex< double > > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< std::vector< std::complex< double > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorVectorComplex",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorVectorComplex" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::vector< std::complex< double > > >::size_type >(val1);
  {
    std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
    res2 = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorVectorComplex" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorVectorComplex" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double > > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (std::vector< std::vector< std::complex< double > > > *)new std::vector< std::vector< std::complex< double > > >(arg1,(std::vector< std::vector< std::complex< double > > >::value_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorVectorComplex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_VectorVectorComplex__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_VectorVectorComplex__SWIG_2(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VectorVectorComplex__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_VectorVectorComplex__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorVectorComplex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< std::complex< double > > >::vector()\n"
    "    std::vector< std::vector< std::complex< double > > >::vector(std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > const &)\n"
    "    std::vector< std::vector< std::complex< double > > >::vector(std::vector< std::vector< std::complex< double > > >::size_type)\n"
    "    std::vector< std::vector< std::complex< double > > >::vector(std::vector< std::vector< std::complex< double > > >::size_type,std::vector< std::vector< std::complex< double > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  std::vector< std::vector< std::complex< double > > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVectorComplex_push_back",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex_push_back" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  {
    std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
    res2 = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVectorComplex_push_back" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVectorComplex_push_back" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double > > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  (arg1)->push_back((std::vector< std::vector< std::complex< double > > >::value_type const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< std::complex< double > > >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorComplex_front",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex_front" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  result = (std::vector< std::vector< std::complex< double > > >::value_type *) &((std::vector< std::vector< std::complex< double > > > const *)arg1)->front();
  resultobj = swig::from(static_cast< std::vector< std::complex< double >,std::allocator< std::complex< double > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< std::complex< double > > >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorComplex_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex_back" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  result = (std::vector< std::vector< std::complex< double > > >::value_type *) &((std::vector< std::vector< std::complex< double > > > const *)arg1)->back();
  resultobj = swig::from(static_cast< std::vector< std::complex< double >,std::allocator< std::complex< double > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  std::vector< std::vector< std::complex< double > > >::size_type arg2 ;
  std::vector< std::vector< std::complex< double > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVectorComplex_assign",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex_assign" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVectorComplex_assign" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< std::complex< double > > >::size_type >(val2);
  {
    std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVectorComplex_assign" "', argument " "3"" of type '" "std::vector< std::vector< std::complex< double > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVectorComplex_assign" "', argument " "3"" of type '" "std::vector< std::vector< std::complex< double > > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->assign(arg2,(std::vector< std::vector< std::complex< double > > >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  std::vector< std::vector< std::complex< double > > >::size_type arg2 ;
  std::vector< std::vector< std::complex< double > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVectorComplex_resize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex_resize" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVectorComplex_resize" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< std::complex< double > > >::size_type >(val2);
  {
    std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVectorComplex_resize" "', argument " "3"" of type '" "std::vector< std::vector< std::complex< double > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVectorComplex_resize" "', argument " "3"" of type '" "std::vector< std::vector< std::complex< double > > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->resize(arg2,(std::vector< std::vector< std::complex< double > > >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorVectorComplex_resize__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorVectorComplex_resize__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVectorComplex_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< std::complex< double > > >::resize(std::vector< std::vector< std::complex< double > > >::size_type)\n"
    "    std::vector< std::vector< std::complex< double > > >::resize(std::vector< std::vector< std::complex< double > > >::size_type,std::vector< std::vector< std::complex< double > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  std::vector< std::vector< std::complex< double > > >::iterator arg2 ;
  std::vector< std::vector< std::complex< double > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< std::vector< std::complex< double > > >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVectorComplex_insert",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex_insert" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorComplex_insert" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< std::complex< double > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< std::complex< double > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorComplex_insert" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double > > >::iterator""'");
    }
  }
  {
    std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVectorComplex_insert" "', argument " "3"" of type '" "std::vector< std::vector< std::complex< double > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVectorComplex_insert" "', argument " "3"" of type '" "std::vector< std::vector< std::complex< double > > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  result = std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg__insert__SWIG_0(arg1,arg2,(std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)*arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< std::complex< double > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  std::vector< std::vector< std::complex< double > > >::iterator arg2 ;
  std::vector< std::vector< std::complex< double > > >::size_type arg3 ;
  std::vector< std::vector< std::complex< double > > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorVectorComplex_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex_insert" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorComplex_insert" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< std::complex< double > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< std::complex< double > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVectorComplex_insert" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double > > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVectorComplex_insert" "', argument " "3"" of type '" "std::vector< std::vector< std::complex< double > > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< std::complex< double > > >::size_type >(val3);
  {
    std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorVectorComplex_insert" "', argument " "4"" of type '" "std::vector< std::vector< std::complex< double > > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVectorComplex_insert" "', argument " "4"" of type '" "std::vector< std::vector< std::complex< double > > >::value_type const &""'"); 
    }
    arg4 = ptr;
  }
  std_vector_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg__insert__SWIG_1(arg1,arg2,arg3,(std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)*arg4);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< std::complex< double > > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorVectorComplex_insert__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< std::complex< double > > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorVectorComplex_insert__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVectorComplex_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< std::complex< double > > >::insert(std::vector< std::vector< std::complex< double > > >::iterator,std::vector< std::vector< std::complex< double > > >::value_type const &)\n"
    "    std::vector< std::vector< std::complex< double > > >::insert(std::vector< std::vector< std::complex< double > > >::iterator,std::vector< std::vector< std::complex< double > > >::size_type,std::vector< std::vector< std::complex< double > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  std::vector< std::vector< std::complex< double > > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVectorComplex_reserve",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex_reserve" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVectorComplex_reserve" "', argument " "2"" of type '" "std::vector< std::vector< std::complex< double > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< std::complex< double > > >::size_type >(val2);
  (arg1)->reserve(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVectorComplex_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< std::complex< double > > >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVectorComplex_capacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVectorComplex_capacity" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  result = ((std::vector< std::vector< std::complex< double > > > const *)arg1)->capacity();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VectorVectorComplex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< std::complex< double > > > *arg1 = (std::vector< std::vector< std::complex< double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorVectorComplex",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorVectorComplex" "', argument " "1"" of type '" "std::vector< std::vector< std::complex< double > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< std::complex< double > > > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VectorVectorComplex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_RndmEngine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RndmEngine *arg1 = (Pythia8::RndmEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RndmEngine",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RndmEngine, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RndmEngine" "', argument " "1"" of type '" "Pythia8::RndmEngine *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RndmEngine * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RndmEngine_flat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RndmEngine *arg1 = (Pythia8::RndmEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RndmEngine_flat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RndmEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RndmEngine_flat" "', argument " "1"" of type '" "Pythia8::RndmEngine *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RndmEngine * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("Pythia8::RndmEngine::flat");
    } else {
      result = (double)(arg1)->flat();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RndmEngine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::RndmEngine *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RndmEngine",&obj0)) SWIG_fail;
  arg1 = obj0;
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (Pythia8::RndmEngine *)new SwigDirector_RndmEngine(arg1); 
  } else {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
    SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__RndmEngine, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_RndmEngine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RndmEngine *arg1 = (Pythia8::RndmEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:disown_RndmEngine",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RndmEngine, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_RndmEngine" "', argument " "1"" of type '" "Pythia8::RndmEngine *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RndmEngine * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RndmEngine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__RndmEngine, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Rndm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Rndm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Rndm")) SWIG_fail;
  result = (Pythia8::Rndm *)new Pythia8::Rndm();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Rndm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Rndm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Rndm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Rndm",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rndm" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Rndm *)new Pythia8::Rndm(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Rndm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Rndm(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Rndm__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Rndm__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Rndm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Rndm::Rndm()\n"
    "    Pythia8::Rndm::Rndm(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Rndm_rndmEnginePtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Rndm *arg1 = (Pythia8::Rndm *) 0 ;
  Pythia8::RndmEngine *arg2 = (Pythia8::RndmEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Rndm_rndmEnginePtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rndm_rndmEnginePtr" "', argument " "1"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Rndm * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__RndmEngine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rndm_rndmEnginePtr" "', argument " "2"" of type '" "Pythia8::RndmEngine *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::RndmEngine * >(argp2);
  result = (bool)(arg1)->rndmEnginePtr(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rndm_init__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Rndm *arg1 = (Pythia8::Rndm *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Rndm_init",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rndm_init" "', argument " "1"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Rndm * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rndm_init" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rndm_init__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Rndm *arg1 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Rndm_init",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rndm_init" "', argument " "1"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Rndm * >(argp1);
  (arg1)->init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rndm_init(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Rndm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Rndm_init__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Rndm, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Rndm_init__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Rndm_init'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Rndm::init(int)\n"
    "    Pythia8::Rndm::init()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Rndm_flat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Rndm *arg1 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Rndm_flat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rndm_flat" "', argument " "1"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Rndm * >(argp1);
  result = (double)(arg1)->flat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rndm_exp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Rndm *arg1 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Rndm_exp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rndm_exp" "', argument " "1"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Rndm * >(argp1);
  result = (double)(arg1)->exp();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rndm_xexp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Rndm *arg1 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Rndm_xexp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rndm_xexp" "', argument " "1"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Rndm * >(argp1);
  result = (double)(arg1)->xexp();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rndm_gauss(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Rndm *arg1 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Rndm_gauss",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rndm_gauss" "', argument " "1"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Rndm * >(argp1);
  result = (double)(arg1)->gauss();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rndm_gauss2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Rndm *arg1 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< pair< double,double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Rndm_gauss2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rndm_gauss2" "', argument " "1"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Rndm * >(argp1);
  result = (arg1)->gauss2();
  resultobj = SWIG_NewPointerObj((new pair< double,double >(static_cast< const pair< double,double >& >(result))), SWIGTYPE_p_std__pairT_double_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rndm_pick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Rndm *arg1 = (Pythia8::Rndm *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Rndm_pick",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rndm_pick" "', argument " "1"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Rndm * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rndm_pick" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rndm_pick" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->pick((std::vector< double,std::allocator< double > > const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rndm_dumpState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Rndm *arg1 = (Pythia8::Rndm *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Rndm_dumpState",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rndm_dumpState" "', argument " "1"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Rndm * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Rndm_dumpState" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->dumpState(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Rndm_readState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Rndm *arg1 = (Pythia8::Rndm *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Rndm_readState",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rndm_readState" "', argument " "1"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Rndm * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Rndm_readState" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->readState(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Rndm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Rndm *arg1 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Rndm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Rndm, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rndm" "', argument " "1"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Rndm * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Rndm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Rndm, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Vec4__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Vec4",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec4" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vec4" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Vec4" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Vec4" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (Pythia8::Vec4 *)new Pythia8::Vec4(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vec4__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Vec4",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec4" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vec4" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Vec4" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (Pythia8::Vec4 *)new Pythia8::Vec4(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vec4__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Vec4",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec4" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vec4" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (Pythia8::Vec4 *)new Pythia8::Vec4(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vec4__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Vec4",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec4" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  result = (Pythia8::Vec4 *)new Pythia8::Vec4(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vec4__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Vec4")) SWIG_fail;
  result = (Pythia8::Vec4 *)new Pythia8::Vec4();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vec4__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Vec4",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vec4" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Vec4" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  result = (Pythia8::Vec4 *)new Pythia8::Vec4((Pythia8::Vec4 const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Vec4(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Vec4__SWIG_4(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Vec4__SWIG_5(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Vec4__SWIG_3(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Vec4__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Vec4__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Vec4__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Vec4'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Vec4::Vec4(double,double,double,double)\n"
    "    Pythia8::Vec4::Vec4(double,double,double)\n"
    "    Pythia8::Vec4::Vec4(double,double)\n"
    "    Pythia8::Vec4::Vec4(double)\n"
    "    Pythia8::Vec4::Vec4()\n"
    "    Pythia8::Vec4::Vec4(Pythia8::Vec4 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vec4_reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Vec4_reset",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_reset" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  (arg1)->reset();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_p__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Vec4_p",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_p" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec4_p" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vec4_p" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Vec4_p" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Vec4_p" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  (arg1)->p(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_p__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  Pythia8::Vec4 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Vec4_p",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_p" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec4_p" "', argument " "2"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec4_p" "', argument " "2"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->p(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_p(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Vec4_p__SWIG_1(self, args);
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Vec4_p__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Vec4_p'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Vec4::p(double,double,double,double)\n"
    "    Pythia8::Vec4::p(Pythia8::Vec4)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vec4_px__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Vec4_px",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_px" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec4_px" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->px(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_py__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Vec4_py",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_py" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec4_py" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->py(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_pz__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Vec4_pz",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_pz" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec4_pz" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->pz(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_e__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Vec4_e",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_e" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec4_e" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->e(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_px__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Vec4_px",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_px" "', argument " "1"" of type '" "Pythia8::Vec4 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  result = (double)((Pythia8::Vec4 const *)arg1)->px();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_px(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vec4_px__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vec4_px__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Vec4_px'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Vec4::px(double)\n"
    "    Pythia8::Vec4::px() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vec4_py__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Vec4_py",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_py" "', argument " "1"" of type '" "Pythia8::Vec4 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  result = (double)((Pythia8::Vec4 const *)arg1)->py();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_py(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vec4_py__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vec4_py__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Vec4_py'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Vec4::py(double)\n"
    "    Pythia8::Vec4::py() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vec4_pz__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Vec4_pz",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_pz" "', argument " "1"" of type '" "Pythia8::Vec4 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  result = (double)((Pythia8::Vec4 const *)arg1)->pz();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_pz(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vec4_pz__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vec4_pz__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Vec4_pz'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Vec4::pz(double)\n"
    "    Pythia8::Vec4::pz() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vec4_e__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Vec4_e",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_e" "', argument " "1"" of type '" "Pythia8::Vec4 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  result = (double)((Pythia8::Vec4 const *)arg1)->e();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_e(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vec4_e__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vec4_e__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Vec4_e'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Vec4::e(double)\n"
    "    Pythia8::Vec4::e() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vec4_mCalc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Vec4_mCalc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_mCalc" "', argument " "1"" of type '" "Pythia8::Vec4 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  result = (double)((Pythia8::Vec4 const *)arg1)->mCalc();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_m2Calc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Vec4_m2Calc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_m2Calc" "', argument " "1"" of type '" "Pythia8::Vec4 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  result = (double)((Pythia8::Vec4 const *)arg1)->m2Calc();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_pT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Vec4_pT",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_pT" "', argument " "1"" of type '" "Pythia8::Vec4 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  result = (double)((Pythia8::Vec4 const *)arg1)->pT();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_pT2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Vec4_pT2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_pT2" "', argument " "1"" of type '" "Pythia8::Vec4 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  result = (double)((Pythia8::Vec4 const *)arg1)->pT2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_pAbs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Vec4_pAbs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_pAbs" "', argument " "1"" of type '" "Pythia8::Vec4 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  result = (double)((Pythia8::Vec4 const *)arg1)->pAbs();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_pAbs2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Vec4_pAbs2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_pAbs2" "', argument " "1"" of type '" "Pythia8::Vec4 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  result = (double)((Pythia8::Vec4 const *)arg1)->pAbs2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_eT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Vec4_eT",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_eT" "', argument " "1"" of type '" "Pythia8::Vec4 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  result = (double)((Pythia8::Vec4 const *)arg1)->eT();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_eT2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Vec4_eT2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_eT2" "', argument " "1"" of type '" "Pythia8::Vec4 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  result = (double)((Pythia8::Vec4 const *)arg1)->eT2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_theta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Vec4_theta",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_theta" "', argument " "1"" of type '" "Pythia8::Vec4 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  result = (double)((Pythia8::Vec4 const *)arg1)->theta();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_phi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Vec4_phi",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_phi" "', argument " "1"" of type '" "Pythia8::Vec4 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  result = (double)((Pythia8::Vec4 const *)arg1)->phi();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_thetaXZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Vec4_thetaXZ",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_thetaXZ" "', argument " "1"" of type '" "Pythia8::Vec4 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  result = (double)((Pythia8::Vec4 const *)arg1)->thetaXZ();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_pPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Vec4_pPos",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_pPos" "', argument " "1"" of type '" "Pythia8::Vec4 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  result = (double)((Pythia8::Vec4 const *)arg1)->pPos();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_pNeg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Vec4_pNeg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_pNeg" "', argument " "1"" of type '" "Pythia8::Vec4 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  result = (double)((Pythia8::Vec4 const *)arg1)->pNeg();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_rap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Vec4_rap",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_rap" "', argument " "1"" of type '" "Pythia8::Vec4 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  result = (double)((Pythia8::Vec4 const *)arg1)->rap();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_eta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Vec4_eta",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_eta" "', argument " "1"" of type '" "Pythia8::Vec4 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  result = (double)((Pythia8::Vec4 const *)arg1)->eta();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_rescale3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Vec4_rescale3",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_rescale3" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec4_rescale3" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->rescale3(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_rescale4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Vec4_rescale4",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_rescale4" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec4_rescale4" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->rescale4(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_flip3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Vec4_flip3",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_flip3" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  (arg1)->flip3();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_flip4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Vec4_flip4",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_flip4" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  (arg1)->flip4();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_rot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Vec4_rot",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_rot" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec4_rot" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vec4_rot" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->rot(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_rotaxis__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Vec4_rotaxis",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_rotaxis" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec4_rotaxis" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vec4_rotaxis" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Vec4_rotaxis" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Vec4_rotaxis" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  (arg1)->rotaxis(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_rotaxis__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  double arg2 ;
  Pythia8::Vec4 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Vec4_rotaxis",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_rotaxis" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec4_rotaxis" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Vec4_rotaxis" "', argument " "3"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec4_rotaxis" "', argument " "3"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Vec4 * >(argp3);
  (arg1)->rotaxis(arg2,(Pythia8::Vec4 const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_rotaxis(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Vec4_rotaxis__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Vec4_rotaxis__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Vec4_rotaxis'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Vec4::rotaxis(double,double,double,double)\n"
    "    Pythia8::Vec4::rotaxis(double,Pythia8::Vec4 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vec4_bst__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Vec4_bst",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_bst" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec4_bst" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vec4_bst" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Vec4_bst" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->bst(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_bst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Vec4_bst",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_bst" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec4_bst" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vec4_bst" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Vec4_bst" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Vec4_bst" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  (arg1)->bst(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_bst__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Vec4_bst",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_bst" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec4_bst" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec4_bst" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  (arg1)->bst((Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_bst__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Vec4_bst",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_bst" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec4_bst" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec4_bst" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vec4_bst" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->bst((Pythia8::Vec4 const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_bst(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Vec4_bst__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Vec4_bst__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Vec4_bst__SWIG_0(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Vec4_bst__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Vec4_bst'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Vec4::bst(double,double,double)\n"
    "    Pythia8::Vec4::bst(double,double,double,double)\n"
    "    Pythia8::Vec4::bst(Pythia8::Vec4 const &)\n"
    "    Pythia8::Vec4::bst(Pythia8::Vec4 const &,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vec4_bstback__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Vec4_bstback",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_bstback" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec4_bstback" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec4_bstback" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  (arg1)->bstback((Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_bstback__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Vec4_bstback",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_bstback" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec4_bstback" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec4_bstback" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vec4_bstback" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->bstback((Pythia8::Vec4 const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4_bstback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Vec4_bstback__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Vec4_bstback__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Vec4_bstback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Vec4::bstback(Pythia8::Vec4 const &)\n"
    "    Pythia8::Vec4::bstback(Pythia8::Vec4 const &,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Vec4_rotbst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  Pythia8::RotBstMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Vec4_rotbst",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4_rotbst" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__RotBstMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec4_rotbst" "', argument " "2"" of type '" "Pythia8::RotBstMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec4_rotbst" "', argument " "2"" of type '" "Pythia8::RotBstMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp2);
  (arg1)->rotbst((Pythia8::RotBstMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Vec4___neg__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4___neg__" "', argument " "1"" of type '" "Pythia8::Vec4 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  result = ((Pythia8::Vec4 const *)arg1)->operator -();
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Vec4___iadd__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4___iadd__" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec4___iadd__" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec4___iadd__" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  result = (Pythia8::Vec4 *) &(arg1)->operator +=((Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Vec4___isub__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4___isub__" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec4___isub__" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec4___isub__" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  result = (Pythia8::Vec4 *) &(arg1)->operator -=((Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Vec4___imul__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4___imul__" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec4___imul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (Pythia8::Vec4 *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Vec4___idiv__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4___idiv__" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec4___idiv__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (Pythia8::Vec4 *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Vec4___add__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4___add__" "', argument " "1"" of type '" "Pythia8::Vec4 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec4___add__" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec4___add__" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  result = ((Pythia8::Vec4 const *)arg1)->operator +((Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Vec4___sub__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4___sub__" "', argument " "1"" of type '" "Pythia8::Vec4 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec4___sub__" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec4___sub__" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  result = ((Pythia8::Vec4 const *)arg1)->operator -((Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Vec4___mul__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4___mul__" "', argument " "1"" of type '" "Pythia8::Vec4 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec4___mul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = ((Pythia8::Vec4 const *)arg1)->operator *(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4___div__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Vec4___div__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4___div__" "', argument " "1"" of type '" "Pythia8::Vec4 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec4___div__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = ((Pythia8::Vec4 const *)arg1)->operator /(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Vec4___mul__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4___mul__" "', argument " "1"" of type '" "Pythia8::Vec4 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec4___mul__" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec4___mul__" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  result = (double)((Pythia8::Vec4 const *)arg1)->operator *((Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4___mul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Vec4___mul____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vec4___mul____SWIG_0(self, args);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Vec4___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Vec4___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4___str__" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  result = Pythia8_Vec4___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Vec4___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4___getitem__" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec4___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    assert(!VEC4_ERROR); result = (double)Pythia8_Vec4___getitem__(arg1,arg2);
    if (VEC4_ERROR) {
      VEC4_ERROR = 0;
      SWIG_exception(SWIG_IndexError, "Index out of bounds");
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Vec4___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Vec4___rmul__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec4___rmul__" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec4___rmul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = Pythia8_Vec4___rmul__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Vec4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Vec4",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vec4" "', argument " "1"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Vec4_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Vec4, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  Pythia8::Vec4 *arg2 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__mul__",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "__mul__" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__mul__" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__mul__" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  result = Pythia8::operator *(arg1,(Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_m__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:m",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "m" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "m" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "m" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "m" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  result = (double)Pythia8::m((Pythia8::Vec4 const &)*arg1,(Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_m2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:m2",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "m2" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "m2" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "m2" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "m2" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  result = (double)Pythia8::m2((Pythia8::Vec4 const &)*arg1,(Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dot3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:dot3",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dot3" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dot3" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dot3" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dot3" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  result = (double)Pythia8::dot3((Pythia8::Vec4 const &)*arg1,(Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cross3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:cross3",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cross3" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cross3" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cross3" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cross3" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  result = Pythia8::cross3((Pythia8::Vec4 const &)*arg1,(Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cross4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  Pythia8::Vec4 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:cross4",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cross4" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cross4" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cross4" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cross4" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cross4" "', argument " "3"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cross4" "', argument " "3"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Vec4 * >(argp3);
  result = Pythia8::cross4((Pythia8::Vec4 const &)*arg1,(Pythia8::Vec4 const &)*arg2,(Pythia8::Vec4 const &)*arg3);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_theta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:theta",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "theta" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "theta" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "theta" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "theta" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  result = (double)Pythia8::theta((Pythia8::Vec4 const &)*arg1,(Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_costheta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:costheta",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "costheta" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "costheta" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "costheta" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "costheta" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  result = (double)Pythia8::costheta((Pythia8::Vec4 const &)*arg1,(Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_phi__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:phi",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "phi" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "phi" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "phi" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "phi" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  result = (double)Pythia8::phi((Pythia8::Vec4 const &)*arg1,(Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cosphi__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:cosphi",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cosphi" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cosphi" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cosphi" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cosphi" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  result = (double)Pythia8::cosphi((Pythia8::Vec4 const &)*arg1,(Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_phi__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  Pythia8::Vec4 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:phi",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "phi" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "phi" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "phi" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "phi" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "phi" "', argument " "3"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "phi" "', argument " "3"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Vec4 * >(argp3);
  result = (double)Pythia8::phi((Pythia8::Vec4 const &)*arg1,(Pythia8::Vec4 const &)*arg2,(Pythia8::Vec4 const &)*arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_phi(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_phi__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_phi__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'phi'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::phi(Pythia8::Vec4 const &,Pythia8::Vec4 const &)\n"
    "    Pythia8::phi(Pythia8::Vec4 const &,Pythia8::Vec4 const &,Pythia8::Vec4 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_cosphi__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  Pythia8::Vec4 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:cosphi",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cosphi" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cosphi" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cosphi" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cosphi" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "cosphi" "', argument " "3"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "cosphi" "', argument " "3"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Vec4 * >(argp3);
  result = (double)Pythia8::cosphi((Pythia8::Vec4 const &)*arg1,(Pythia8::Vec4 const &)*arg2,(Pythia8::Vec4 const &)*arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cosphi(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_cosphi__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_cosphi__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'cosphi'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::cosphi(Pythia8::Vec4 const &,Pythia8::Vec4 const &)\n"
    "    Pythia8::cosphi(Pythia8::Vec4 const &,Pythia8::Vec4 const &,Pythia8::Vec4 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RRapPhi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RRapPhi",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RRapPhi" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RRapPhi" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RRapPhi" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RRapPhi" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  result = (double)Pythia8::RRapPhi((Pythia8::Vec4 const &)*arg1,(Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_REtaPhi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:REtaPhi",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "REtaPhi" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "REtaPhi" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "REtaPhi" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "REtaPhi" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  result = (double)Pythia8::REtaPhi((Pythia8::Vec4 const &)*arg1,(Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap___lshift____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::ostream *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__lshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__lshift__" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lshift__" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  result = (std::ostream *) &Pythia8::operator <<(*arg1,(Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pShift(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:pShift",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pShift" "', argument " "1"" of type '" "Pythia8::Vec4 &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pShift" "', argument " "1"" of type '" "Pythia8::Vec4 &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pShift" "', argument " "2"" of type '" "Pythia8::Vec4 &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pShift" "', argument " "2"" of type '" "Pythia8::Vec4 &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pShift" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pShift" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)Pythia8::pShift(*arg1,*arg2,arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_getTwoPerpendicular(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigValueWrapper< pair< Pythia8::Vec4,Pythia8::Vec4 > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:getTwoPerpendicular",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getTwoPerpendicular" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getTwoPerpendicular" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "getTwoPerpendicular" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getTwoPerpendicular" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  result = Pythia8::getTwoPerpendicular((Pythia8::Vec4 const &)*arg1,(Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_NewPointerObj((new pair< Pythia8::Vec4,Pythia8::Vec4 >(static_cast< const pair< Pythia8::Vec4,Pythia8::Vec4 >& >(result))), SWIGTYPE_p_std__pairT_Pythia8__Vec4_Pythia8__Vec4_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RotBstMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RotBstMatrix *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RotBstMatrix")) SWIG_fail;
  result = (Pythia8::RotBstMatrix *)new Pythia8::RotBstMatrix();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__RotBstMatrix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RotBstMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RotBstMatrix *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::RotBstMatrix *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_RotBstMatrix",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__RotBstMatrix,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RotBstMatrix" "', argument " "1"" of type '" "Pythia8::RotBstMatrix const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RotBstMatrix" "', argument " "1"" of type '" "Pythia8::RotBstMatrix const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp1);
  result = (Pythia8::RotBstMatrix *)new Pythia8::RotBstMatrix((Pythia8::RotBstMatrix const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__RotBstMatrix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RotBstMatrix(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_RotBstMatrix__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__RotBstMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RotBstMatrix__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RotBstMatrix'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::RotBstMatrix::RotBstMatrix()\n"
    "    Pythia8::RotBstMatrix::RotBstMatrix(Pythia8::RotBstMatrix const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RotBstMatrix_rot__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RotBstMatrix *arg1 = (Pythia8::RotBstMatrix *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RotBstMatrix_rot",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RotBstMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotBstMatrix_rot" "', argument " "1"" of type '" "Pythia8::RotBstMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RotBstMatrix_rot" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RotBstMatrix_rot" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->rot(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RotBstMatrix_rot__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RotBstMatrix *arg1 = (Pythia8::RotBstMatrix *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RotBstMatrix_rot",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RotBstMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotBstMatrix_rot" "', argument " "1"" of type '" "Pythia8::RotBstMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RotBstMatrix_rot" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->rot(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RotBstMatrix_rot__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RotBstMatrix *arg1 = (Pythia8::RotBstMatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RotBstMatrix_rot",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RotBstMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotBstMatrix_rot" "', argument " "1"" of type '" "Pythia8::RotBstMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp1);
  (arg1)->rot();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RotBstMatrix_rot__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RotBstMatrix *arg1 = (Pythia8::RotBstMatrix *) 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RotBstMatrix_rot",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RotBstMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotBstMatrix_rot" "', argument " "1"" of type '" "Pythia8::RotBstMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RotBstMatrix_rot" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RotBstMatrix_rot" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  (arg1)->rot((Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RotBstMatrix_rot(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__RotBstMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RotBstMatrix_rot__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__RotBstMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RotBstMatrix_rot__SWIG_3(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__RotBstMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RotBstMatrix_rot__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__RotBstMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RotBstMatrix_rot__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'RotBstMatrix_rot'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::RotBstMatrix::rot(double,double)\n"
    "    Pythia8::RotBstMatrix::rot(double)\n"
    "    Pythia8::RotBstMatrix::rot()\n"
    "    Pythia8::RotBstMatrix::rot(Pythia8::Vec4 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RotBstMatrix_bst__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RotBstMatrix *arg1 = (Pythia8::RotBstMatrix *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:RotBstMatrix_bst",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RotBstMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotBstMatrix_bst" "', argument " "1"" of type '" "Pythia8::RotBstMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RotBstMatrix_bst" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RotBstMatrix_bst" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RotBstMatrix_bst" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->bst(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RotBstMatrix_bst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RotBstMatrix *arg1 = (Pythia8::RotBstMatrix *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RotBstMatrix_bst",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RotBstMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotBstMatrix_bst" "', argument " "1"" of type '" "Pythia8::RotBstMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RotBstMatrix_bst" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RotBstMatrix_bst" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->bst(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RotBstMatrix_bst__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RotBstMatrix *arg1 = (Pythia8::RotBstMatrix *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RotBstMatrix_bst",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RotBstMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotBstMatrix_bst" "', argument " "1"" of type '" "Pythia8::RotBstMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RotBstMatrix_bst" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->bst(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RotBstMatrix_bst__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RotBstMatrix *arg1 = (Pythia8::RotBstMatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RotBstMatrix_bst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RotBstMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotBstMatrix_bst" "', argument " "1"" of type '" "Pythia8::RotBstMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp1);
  (arg1)->bst();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RotBstMatrix_bst__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RotBstMatrix *arg1 = (Pythia8::RotBstMatrix *) 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RotBstMatrix_bst",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RotBstMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotBstMatrix_bst" "', argument " "1"" of type '" "Pythia8::RotBstMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RotBstMatrix_bst" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RotBstMatrix_bst" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  (arg1)->bst((Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RotBstMatrix_bstback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RotBstMatrix *arg1 = (Pythia8::RotBstMatrix *) 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RotBstMatrix_bstback",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RotBstMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotBstMatrix_bstback" "', argument " "1"" of type '" "Pythia8::RotBstMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RotBstMatrix_bstback" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RotBstMatrix_bstback" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  (arg1)->bstback((Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RotBstMatrix_bst__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RotBstMatrix *arg1 = (Pythia8::RotBstMatrix *) 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  Pythia8::Vec4 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RotBstMatrix_bst",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RotBstMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotBstMatrix_bst" "', argument " "1"" of type '" "Pythia8::RotBstMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RotBstMatrix_bst" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RotBstMatrix_bst" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RotBstMatrix_bst" "', argument " "3"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RotBstMatrix_bst" "', argument " "3"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Vec4 * >(argp3);
  (arg1)->bst((Pythia8::Vec4 const &)*arg2,(Pythia8::Vec4 const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RotBstMatrix_bst(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__RotBstMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RotBstMatrix_bst__SWIG_3(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__RotBstMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RotBstMatrix_bst__SWIG_4(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__RotBstMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RotBstMatrix_bst__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__RotBstMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RotBstMatrix_bst__SWIG_5(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__RotBstMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RotBstMatrix_bst__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__RotBstMatrix, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_RotBstMatrix_bst__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'RotBstMatrix_bst'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::RotBstMatrix::bst(double,double,double)\n"
    "    Pythia8::RotBstMatrix::bst(double,double)\n"
    "    Pythia8::RotBstMatrix::bst(double)\n"
    "    Pythia8::RotBstMatrix::bst()\n"
    "    Pythia8::RotBstMatrix::bst(Pythia8::Vec4 const &)\n"
    "    Pythia8::RotBstMatrix::bst(Pythia8::Vec4 const &,Pythia8::Vec4 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RotBstMatrix_toCMframe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RotBstMatrix *arg1 = (Pythia8::RotBstMatrix *) 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  Pythia8::Vec4 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RotBstMatrix_toCMframe",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RotBstMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotBstMatrix_toCMframe" "', argument " "1"" of type '" "Pythia8::RotBstMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RotBstMatrix_toCMframe" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RotBstMatrix_toCMframe" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RotBstMatrix_toCMframe" "', argument " "3"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RotBstMatrix_toCMframe" "', argument " "3"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Vec4 * >(argp3);
  (arg1)->toCMframe((Pythia8::Vec4 const &)*arg2,(Pythia8::Vec4 const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RotBstMatrix_fromCMframe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RotBstMatrix *arg1 = (Pythia8::RotBstMatrix *) 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  Pythia8::Vec4 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RotBstMatrix_fromCMframe",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RotBstMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotBstMatrix_fromCMframe" "', argument " "1"" of type '" "Pythia8::RotBstMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RotBstMatrix_fromCMframe" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RotBstMatrix_fromCMframe" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RotBstMatrix_fromCMframe" "', argument " "3"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RotBstMatrix_fromCMframe" "', argument " "3"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Vec4 * >(argp3);
  (arg1)->fromCMframe((Pythia8::Vec4 const &)*arg2,(Pythia8::Vec4 const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RotBstMatrix_rotbst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RotBstMatrix *arg1 = (Pythia8::RotBstMatrix *) 0 ;
  Pythia8::RotBstMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RotBstMatrix_rotbst",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RotBstMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotBstMatrix_rotbst" "', argument " "1"" of type '" "Pythia8::RotBstMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__RotBstMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RotBstMatrix_rotbst" "', argument " "2"" of type '" "Pythia8::RotBstMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RotBstMatrix_rotbst" "', argument " "2"" of type '" "Pythia8::RotBstMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp2);
  (arg1)->rotbst((Pythia8::RotBstMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RotBstMatrix_invert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RotBstMatrix *arg1 = (Pythia8::RotBstMatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RotBstMatrix_invert",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RotBstMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotBstMatrix_invert" "', argument " "1"" of type '" "Pythia8::RotBstMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp1);
  (arg1)->invert();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RotBstMatrix_reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RotBstMatrix *arg1 = (Pythia8::RotBstMatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RotBstMatrix_reset",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RotBstMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotBstMatrix_reset" "', argument " "1"" of type '" "Pythia8::RotBstMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp1);
  (arg1)->reset();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RotBstMatrix_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RotBstMatrix *arg1 = (Pythia8::RotBstMatrix *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RotBstMatrix_value",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RotBstMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotBstMatrix_value" "', argument " "1"" of type '" "Pythia8::RotBstMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RotBstMatrix_value" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RotBstMatrix_value" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)(arg1)->value(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RotBstMatrix_deviation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RotBstMatrix *arg1 = (Pythia8::RotBstMatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RotBstMatrix_deviation",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RotBstMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotBstMatrix_deviation" "', argument " "1"" of type '" "Pythia8::RotBstMatrix const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp1);
  result = (double)((Pythia8::RotBstMatrix const *)arg1)->deviation();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RotBstMatrix___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RotBstMatrix *arg1 = (Pythia8::RotBstMatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RotBstMatrix___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RotBstMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotBstMatrix___str__" "', argument " "1"" of type '" "Pythia8::RotBstMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp1);
  result = Pythia8_RotBstMatrix___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RotBstMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RotBstMatrix *arg1 = (Pythia8::RotBstMatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RotBstMatrix",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RotBstMatrix, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RotBstMatrix" "', argument " "1"" of type '" "Pythia8::RotBstMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RotBstMatrix_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__RotBstMatrix, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap___lshift____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  Pythia8::RotBstMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::ostream *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__lshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__lshift__" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__RotBstMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lshift__" "', argument " "2"" of type '" "Pythia8::RotBstMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "2"" of type '" "Pythia8::RotBstMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp2);
  result = (std::ostream *) &Pythia8::operator <<(*arg1,(Pythia8::RotBstMatrix const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Hist__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Hist")) SWIG_fail;
  result = (Pythia8::Hist *)new Pythia8::Hist();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Hist__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  bool arg5 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::Hist *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Hist",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Hist" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Hist" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Hist" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Hist" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Hist" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (Pythia8::Hist *)new Pythia8::Hist(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Hist__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::Hist *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Hist",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Hist" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Hist" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Hist" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Hist" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (Pythia8::Hist *)new Pythia8::Hist(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Hist__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  int arg2 ;
  double arg3 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Hist *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Hist",&obj0,&obj1,&obj2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Hist" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Hist" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Hist" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (Pythia8::Hist *)new Pythia8::Hist(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Hist__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  int arg2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Hist",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Hist" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Hist" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::Hist *)new Pythia8::Hist(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Hist__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  Pythia8::Hist *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Hist",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Hist" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::Hist *)new Pythia8::Hist(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Hist__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Hist *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Hist",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Hist" "', argument " "1"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Hist" "', argument " "1"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  result = (Pythia8::Hist *)new Pythia8::Hist((Pythia8::Hist const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Hist__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  Pythia8::Hist *arg2 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Hist",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Hist" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Hist" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Hist" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Hist * >(argp2);
  result = (Pythia8::Hist *)new Pythia8::Hist(arg1,(Pythia8::Hist const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Hist(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Hist__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Hist__SWIG_6(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Hist__SWIG_5(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Hist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Hist__SWIG_7(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Hist__SWIG_4(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Hist__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Hist__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Hist__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Hist'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Hist::Hist()\n"
    "    Pythia8::Hist::Hist(std::string,int,double,double,bool)\n"
    "    Pythia8::Hist::Hist(std::string,int,double,double)\n"
    "    Pythia8::Hist::Hist(std::string,int,double)\n"
    "    Pythia8::Hist::Hist(std::string,int)\n"
    "    Pythia8::Hist::Hist(std::string)\n"
    "    Pythia8::Hist::Hist(Pythia8::Hist const &)\n"
    "    Pythia8::Hist::Hist(std::string,Pythia8::Hist const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Hist_book__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  std::string arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Hist_book",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_book" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Hist_book" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Hist_book" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Hist_book" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Hist_book" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Hist_book" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  (arg1)->book(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_book__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  std::string arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Hist_book",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_book" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Hist_book" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Hist_book" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Hist_book" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Hist_book" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  (arg1)->book(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_book__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  std::string arg2 ;
  int arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Hist_book",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_book" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Hist_book" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Hist_book" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Hist_book" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->book(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_book__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  std::string arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Hist_book",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_book" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Hist_book" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Hist_book" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->book(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_book__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist_book",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_book" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Hist_book" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->book(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_book__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Hist_book",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_book" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  (arg1)->book();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_book(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Hist_book__SWIG_5(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Hist_book__SWIG_4(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Hist_book__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Hist_book__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Hist_book__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Hist_book__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Hist_book'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Hist::book(std::string,int,double,double,bool)\n"
    "    Pythia8::Hist::book(std::string,int,double,double)\n"
    "    Pythia8::Hist::book(std::string,int,double)\n"
    "    Pythia8::Hist::book(std::string,int)\n"
    "    Pythia8::Hist::book(std::string)\n"
    "    Pythia8::Hist::book()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Hist_title__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist_title",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_title" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Hist_title" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->title(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_title__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Hist_title",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_title" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  (arg1)->title();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_title(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Hist_title__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Hist_title__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Hist_title'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Hist::title(std::string)\n"
    "    Pythia8::Hist::title()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Hist_null(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Hist_null",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_null" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  (arg1)->null();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_fill__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Hist_fill",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_fill" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hist_fill" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Hist_fill" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->fill(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_fill__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist_fill",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_fill" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hist_fill" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->fill(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_fill(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Hist_fill__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Hist_fill__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Hist_fill'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Hist::fill(double,double)\n"
    "    Pythia8::Hist::fill(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Hist_table__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  std::ostream *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Hist_table",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_table" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hist_table" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hist_table" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Hist_table" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Hist_table" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ((Pythia8::Hist const *)arg1)->table(*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_table__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  std::ostream *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Hist_table",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_table" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hist_table" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hist_table" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Hist_table" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ((Pythia8::Hist const *)arg1)->table(*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_table__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist_table",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_table" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hist_table" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hist_table" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  ((Pythia8::Hist const *)arg1)->table(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_table__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Hist_table",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_table" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  ((Pythia8::Hist const *)arg1)->table();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_table__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Hist_table",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_table" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Hist_table" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Hist_table" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Hist_table" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ((Pythia8::Hist const *)arg1)->table(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_table__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Hist_table",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_table" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Hist_table" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Hist_table" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ((Pythia8::Hist const *)arg1)->table(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_table__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist_table",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_table" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Hist_table" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ((Pythia8::Hist const *)arg1)->table(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_table(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Hist_table__SWIG_3(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Hist_table__SWIG_2(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Hist_table__SWIG_6(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Hist_table__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Hist_table__SWIG_5(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Hist_table__SWIG_0(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Hist_table__SWIG_4(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Hist_table'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Hist::table(std::ostream &,bool,bool) const\n"
    "    Pythia8::Hist::table(std::ostream &,bool) const\n"
    "    Pythia8::Hist::table(std::ostream &) const\n"
    "    Pythia8::Hist::table() const\n"
    "    Pythia8::Hist::table(std::string,bool,bool) const\n"
    "    Pythia8::Hist::table(std::string,bool) const\n"
    "    Pythia8::Hist::table(std::string) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Hist_rivetTable__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  std::ostream *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Hist_rivetTable",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_rivetTable" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hist_rivetTable" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hist_rivetTable" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Hist_rivetTable" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ((Pythia8::Hist const *)arg1)->rivetTable(*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_rivetTable__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist_rivetTable",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_rivetTable" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hist_rivetTable" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hist_rivetTable" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  ((Pythia8::Hist const *)arg1)->rivetTable(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_rivetTable__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Hist_rivetTable",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_rivetTable" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  ((Pythia8::Hist const *)arg1)->rivetTable();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_rivetTable__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Hist_rivetTable",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_rivetTable" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Hist_rivetTable" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Hist_rivetTable" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ((Pythia8::Hist const *)arg1)->rivetTable(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_rivetTable__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist_rivetTable",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_rivetTable" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Hist_rivetTable" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ((Pythia8::Hist const *)arg1)->rivetTable(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_rivetTable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Hist_rivetTable__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Hist_rivetTable__SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Hist_rivetTable__SWIG_4(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Hist_rivetTable__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Hist_rivetTable__SWIG_3(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Hist_rivetTable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Hist::rivetTable(std::ostream &,bool) const\n"
    "    Pythia8::Hist::rivetTable(std::ostream &) const\n"
    "    Pythia8::Hist::rivetTable() const\n"
    "    Pythia8::Hist::rivetTable(std::string,bool) const\n"
    "    Pythia8::Hist::rivetTable(std::string) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Hist_pyplotTable__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  std::ostream *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Hist_pyplotTable",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_pyplotTable" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hist_pyplotTable" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hist_pyplotTable" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Hist_pyplotTable" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ((Pythia8::Hist const *)arg1)->pyplotTable(*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_pyplotTable__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist_pyplotTable",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_pyplotTable" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hist_pyplotTable" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hist_pyplotTable" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  ((Pythia8::Hist const *)arg1)->pyplotTable(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_pyplotTable__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Hist_pyplotTable",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_pyplotTable" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  ((Pythia8::Hist const *)arg1)->pyplotTable();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_pyplotTable__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Hist_pyplotTable",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_pyplotTable" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Hist_pyplotTable" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Hist_pyplotTable" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ((Pythia8::Hist const *)arg1)->pyplotTable(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_pyplotTable__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist_pyplotTable",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_pyplotTable" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Hist_pyplotTable" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ((Pythia8::Hist const *)arg1)->pyplotTable(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_pyplotTable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Hist_pyplotTable__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Hist_pyplotTable__SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Hist_pyplotTable__SWIG_4(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Hist_pyplotTable__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Hist_pyplotTable__SWIG_3(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Hist_pyplotTable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Hist::pyplotTable(std::ostream &,bool) const\n"
    "    Pythia8::Hist::pyplotTable(std::ostream &) const\n"
    "    Pythia8::Hist::pyplotTable() const\n"
    "    Pythia8::Hist::pyplotTable(std::string,bool) const\n"
    "    Pythia8::Hist::pyplotTable(std::string) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Hist_getTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Hist_getTitle",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_getTitle" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  result = ((Pythia8::Hist const *)arg1)->getTitle();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_getBinNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Hist_getBinNumber",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_getBinNumber" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  result = (int)((Pythia8::Hist const *)arg1)->getBinNumber();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_getLinX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Hist_getLinX",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_getLinX" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  result = (bool)((Pythia8::Hist const *)arg1)->getLinX();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_getBinContent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist_getBinContent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_getBinContent" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hist_getBinContent" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Hist const *)arg1)->getBinContent(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_getEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Hist_getEntries",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_getEntries" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  result = (int)((Pythia8::Hist const *)arg1)->getEntries();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_sameSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  Pythia8::Hist *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist_sameSize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_sameSize" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hist_sameSize" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hist_sameSize" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Hist * >(argp2);
  result = (bool)((Pythia8::Hist const *)arg1)->sameSize((Pythia8::Hist const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_takeLog__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist_takeLog",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_takeLog" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hist_takeLog" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->takeLog(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_takeLog__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Hist_takeLog",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_takeLog" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  (arg1)->takeLog();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_takeLog(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Hist_takeLog__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Hist_takeLog__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Hist_takeLog'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Hist::takeLog(bool)\n"
    "    Pythia8::Hist::takeLog()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Hist_takeSqrt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Hist_takeSqrt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_takeSqrt" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  (arg1)->takeSqrt();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist_smallestAbsValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Hist_smallestAbsValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist_smallestAbsValue" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  result = (double)((Pythia8::Hist const *)arg1)->smallestAbsValue();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  Pythia8::Hist *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist___iadd__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist___iadd__" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hist___iadd__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hist___iadd__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Hist * >(argp2);
  result = (Pythia8::Hist *) &(arg1)->operator +=((Pythia8::Hist const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  Pythia8::Hist *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist___isub__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist___isub__" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hist___isub__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hist___isub__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Hist * >(argp2);
  result = (Pythia8::Hist *) &(arg1)->operator -=((Pythia8::Hist const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist___imul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  Pythia8::Hist *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist___imul__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist___imul__" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hist___imul__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hist___imul__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Hist * >(argp2);
  result = (Pythia8::Hist *) &(arg1)->operator *=((Pythia8::Hist const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist___idiv____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  Pythia8::Hist *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist___idiv__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist___idiv__" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hist___idiv__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hist___idiv__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Hist * >(argp2);
  result = (Pythia8::Hist *) &(arg1)->operator /=((Pythia8::Hist const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist___iadd__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist___iadd__" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hist___iadd__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (Pythia8::Hist *) &(arg1)->operator +=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist___iadd__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Hist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Hist___iadd____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Hist___iadd____SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Hist___iadd__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Hist::operator +=(Pythia8::Hist const &)\n"
    "    Pythia8::Hist::operator +=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Hist___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist___isub__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist___isub__" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hist___isub__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (Pythia8::Hist *) &(arg1)->operator -=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist___isub__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Hist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Hist___isub____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Hist___isub____SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Hist___isub__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Hist::operator -=(Pythia8::Hist const &)\n"
    "    Pythia8::Hist::operator -=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Hist___imul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist___imul__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist___imul__" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hist___imul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (Pythia8::Hist *) &(arg1)->operator *=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist___imul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Hist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Hist___imul____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Hist___imul____SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Hist___imul__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Hist::operator *=(Pythia8::Hist const &)\n"
    "    Pythia8::Hist::operator *=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Hist___idiv____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist___idiv__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist___idiv__" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hist___idiv__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (Pythia8::Hist *) &(arg1)->operator /=(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist___idiv__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Hist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Hist___idiv____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Hist___idiv____SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Hist___idiv__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Hist::operator /=(Pythia8::Hist const &)\n"
    "    Pythia8::Hist::operator /=(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Hist___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist___add__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist___add__" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hist___add__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = ((Pythia8::Hist const *)arg1)->operator +(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Hist(static_cast< const Pythia8::Hist& >(result))), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  Pythia8::Hist *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist___add__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist___add__" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hist___add__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hist___add__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Hist * >(argp2);
  result = ((Pythia8::Hist const *)arg1)->operator +((Pythia8::Hist const &)*arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Hist(static_cast< const Pythia8::Hist& >(result))), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist___add__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Hist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Hist___add____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Hist___add____SWIG_0(self, args);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Hist___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist___sub__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist___sub__" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hist___sub__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = ((Pythia8::Hist const *)arg1)->operator -(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Hist(static_cast< const Pythia8::Hist& >(result))), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  Pythia8::Hist *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist___sub__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist___sub__" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hist___sub__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hist___sub__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Hist * >(argp2);
  result = ((Pythia8::Hist const *)arg1)->operator -((Pythia8::Hist const &)*arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Hist(static_cast< const Pythia8::Hist& >(result))), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist___sub__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Hist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Hist___sub____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Hist___sub____SWIG_0(self, args);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Hist___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist___mul__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist___mul__" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hist___mul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = ((Pythia8::Hist const *)arg1)->operator *(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Hist(static_cast< const Pythia8::Hist& >(result))), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  Pythia8::Hist *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist___mul__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist___mul__" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hist___mul__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hist___mul__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Hist * >(argp2);
  result = ((Pythia8::Hist const *)arg1)->operator *((Pythia8::Hist const &)*arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Hist(static_cast< const Pythia8::Hist& >(result))), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist___mul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Hist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Hist___mul____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Hist___mul____SWIG_0(self, args);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Hist___div____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist___div__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist___div__" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hist___div__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = ((Pythia8::Hist const *)arg1)->operator /(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Hist(static_cast< const Pythia8::Hist& >(result))), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist___div____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  Pythia8::Hist *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist___div__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist___div__" "', argument " "1"" of type '" "Pythia8::Hist const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hist___div__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hist___div__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Hist * >(argp2);
  result = ((Pythia8::Hist const *)arg1)->operator /((Pythia8::Hist const &)*arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Hist(static_cast< const Pythia8::Hist& >(result))), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist___div__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Hist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Hist___div____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Hist___div____SWIG_0(self, args);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Hist___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Hist___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist___str__" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  result = Pythia8_Hist___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist___radd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist___radd__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist___radd__" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hist___radd__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = Pythia8_Hist___radd__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Hist(static_cast< const Pythia8::Hist& >(result))), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist___rsub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist___rsub__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist___rsub__" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hist___rsub__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = Pythia8_Hist___rsub__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Hist(static_cast< const Pythia8::Hist& >(result))), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist___rmul__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist___rmul__" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hist___rmul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = Pythia8_Hist___rmul__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Hist(static_cast< const Pythia8::Hist& >(result))), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Hist___rdiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Hist___rdiv__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hist___rdiv__" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hist___rdiv__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = Pythia8_Hist___rdiv__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Hist(static_cast< const Pythia8::Hist& >(result))), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Hist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = (Pythia8::Hist *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Hist",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Hist" "', argument " "1"" of type '" "Pythia8::Hist *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Hist_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Hist, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap___lshift____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  Pythia8::Hist *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::ostream *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__lshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__lshift__" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lshift__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Hist * >(argp2);
  result = (std::ostream *) &Pythia8::operator <<(*arg1,(Pythia8::Hist const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_table__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = 0 ;
  Pythia8::Hist *arg2 = 0 ;
  std::ostream *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:table",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "table" "', argument " "1"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "table" "', argument " "1"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "table" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "table" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Hist * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "table" "', argument " "3"" of type '" "std::ostream &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "table" "', argument " "3"" of type '" "std::ostream &""'"); 
  }
  arg3 = reinterpret_cast< std::ostream * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "table" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "table" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  Pythia8::table((Pythia8::Hist const &)*arg1,(Pythia8::Hist const &)*arg2,*arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_table__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = 0 ;
  Pythia8::Hist *arg2 = 0 ;
  std::ostream *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:table",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "table" "', argument " "1"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "table" "', argument " "1"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "table" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "table" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Hist * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "table" "', argument " "3"" of type '" "std::ostream &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "table" "', argument " "3"" of type '" "std::ostream &""'"); 
  }
  arg3 = reinterpret_cast< std::ostream * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "table" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  Pythia8::table((Pythia8::Hist const &)*arg1,(Pythia8::Hist const &)*arg2,*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_table__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = 0 ;
  Pythia8::Hist *arg2 = 0 ;
  std::ostream *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:table",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "table" "', argument " "1"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "table" "', argument " "1"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "table" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "table" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Hist * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "table" "', argument " "3"" of type '" "std::ostream &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "table" "', argument " "3"" of type '" "std::ostream &""'"); 
  }
  arg3 = reinterpret_cast< std::ostream * >(argp3);
  Pythia8::table((Pythia8::Hist const &)*arg1,(Pythia8::Hist const &)*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_table__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = 0 ;
  Pythia8::Hist *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:table",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "table" "', argument " "1"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "table" "', argument " "1"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "table" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "table" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Hist * >(argp2);
  Pythia8::table((Pythia8::Hist const &)*arg1,(Pythia8::Hist const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_table__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = 0 ;
  Pythia8::Hist *arg2 = 0 ;
  std::string arg3 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:table",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "table" "', argument " "1"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "table" "', argument " "1"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "table" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "table" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Hist * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "table" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "table" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "table" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  Pythia8::table((Pythia8::Hist const &)*arg1,(Pythia8::Hist const &)*arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_table__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = 0 ;
  Pythia8::Hist *arg2 = 0 ;
  std::string arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:table",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "table" "', argument " "1"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "table" "', argument " "1"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "table" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "table" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Hist * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "table" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "table" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  Pythia8::table((Pythia8::Hist const &)*arg1,(Pythia8::Hist const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_table__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Hist *arg1 = 0 ;
  Pythia8::Hist *arg2 = 0 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:table",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "table" "', argument " "1"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "table" "', argument " "1"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Hist * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "table" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "table" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Hist * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "table" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  Pythia8::table((Pythia8::Hist const &)*arg1,(Pythia8::Hist const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_table(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Hist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_table__SWIG_3(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Hist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_table__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Hist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_table__SWIG_6(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Hist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_table__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Hist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_table__SWIG_5(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Hist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_table__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Hist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Hist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_table__SWIG_4(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'table'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::table(Pythia8::Hist const &,Pythia8::Hist const &,std::ostream &,bool,bool)\n"
    "    Pythia8::table(Pythia8::Hist const &,Pythia8::Hist const &,std::ostream &,bool)\n"
    "    Pythia8::table(Pythia8::Hist const &,Pythia8::Hist const &,std::ostream &)\n"
    "    Pythia8::table(Pythia8::Hist const &,Pythia8::Hist const &)\n"
    "    Pythia8::table(Pythia8::Hist const &,Pythia8::Hist const &,std::string,bool,bool)\n"
    "    Pythia8::table(Pythia8::Hist const &,Pythia8::Hist const &,std::string,bool)\n"
    "    Pythia8::table(Pythia8::Hist const &,Pythia8::Hist const &,std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  Pythia8::Hist *arg2 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__add__",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "__add__" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__add__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__add__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Hist * >(argp2);
  result = Pythia8::operator +(arg1,(Pythia8::Hist const &)*arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Hist(static_cast< const Pythia8::Hist& >(result))), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  Pythia8::Hist *arg2 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__sub__",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "__sub__" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__sub__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__sub__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Hist * >(argp2);
  result = Pythia8::operator -(arg1,(Pythia8::Hist const &)*arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Hist(static_cast< const Pythia8::Hist& >(result))), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  Pythia8::Hist *arg2 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__mul__",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "__mul__" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__mul__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__mul__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Hist * >(argp2);
  result = Pythia8::operator *(arg1,(Pythia8::Hist const &)*arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Hist(static_cast< const Pythia8::Hist& >(result))), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap___div__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  Pythia8::Hist *arg2 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Hist result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__div__",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "__div__" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__div__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__div__" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Hist * >(argp2);
  result = Pythia8::operator /(arg1,(Pythia8::Hist const &)*arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Hist(static_cast< const Pythia8::Hist& >(result))), SWIGTYPE_p_Pythia8__Hist, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HistPlot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  Pythia8::HistPlot *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_HistPlot",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_HistPlot" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::HistPlot *)new Pythia8::HistPlot(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HistPlot, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HistPlot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HistPlot *arg1 = (Pythia8::HistPlot *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HistPlot",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HistPlot, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HistPlot" "', argument " "1"" of type '" "Pythia8::HistPlot *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HistPlot * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HistPlot_frame__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HistPlot *arg1 = (Pythia8::HistPlot *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:HistPlot_frame",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HistPlot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HistPlot_frame" "', argument " "1"" of type '" "Pythia8::HistPlot *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HistPlot * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_frame" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_frame" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_frame" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_frame" "', argument " "5"" of type '" "std::string""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->frame(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HistPlot_frame__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HistPlot *arg1 = (Pythia8::HistPlot *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:HistPlot_frame",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HistPlot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HistPlot_frame" "', argument " "1"" of type '" "Pythia8::HistPlot *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HistPlot * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_frame" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_frame" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_frame" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->frame(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HistPlot_frame__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HistPlot *arg1 = (Pythia8::HistPlot *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:HistPlot_frame",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HistPlot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HistPlot_frame" "', argument " "1"" of type '" "Pythia8::HistPlot *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HistPlot * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_frame" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_frame" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->frame(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HistPlot_frame__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HistPlot *arg1 = (Pythia8::HistPlot *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HistPlot_frame",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HistPlot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HistPlot_frame" "', argument " "1"" of type '" "Pythia8::HistPlot *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HistPlot * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_frame" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->frame(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HistPlot_frame(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HistPlot, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_HistPlot_frame__SWIG_3(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HistPlot, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_HistPlot_frame__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HistPlot, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_HistPlot_frame__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HistPlot, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_HistPlot_frame__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'HistPlot_frame'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::HistPlot::frame(std::string,std::string,std::string,std::string)\n"
    "    Pythia8::HistPlot::frame(std::string,std::string,std::string)\n"
    "    Pythia8::HistPlot::frame(std::string,std::string)\n"
    "    Pythia8::HistPlot::frame(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HistPlot_add__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HistPlot *arg1 = (Pythia8::HistPlot *) 0 ;
  Pythia8::Hist *arg2 = 0 ;
  std::string arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:HistPlot_add",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HistPlot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HistPlot_add" "', argument " "1"" of type '" "Pythia8::HistPlot *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HistPlot * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HistPlot_add" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HistPlot_add" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Hist * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_add" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_add" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->add((Pythia8::Hist const &)*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HistPlot_add__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HistPlot *arg1 = (Pythia8::HistPlot *) 0 ;
  Pythia8::Hist *arg2 = 0 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:HistPlot_add",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HistPlot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HistPlot_add" "', argument " "1"" of type '" "Pythia8::HistPlot *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HistPlot * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HistPlot_add" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HistPlot_add" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Hist * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_add" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->add((Pythia8::Hist const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HistPlot_add__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HistPlot *arg1 = (Pythia8::HistPlot *) 0 ;
  Pythia8::Hist *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HistPlot_add",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HistPlot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HistPlot_add" "', argument " "1"" of type '" "Pythia8::HistPlot *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HistPlot * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HistPlot_add" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HistPlot_add" "', argument " "2"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Hist * >(argp2);
  (arg1)->add((Pythia8::Hist const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HistPlot_add(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HistPlot, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Hist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_HistPlot_add__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HistPlot, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Hist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_HistPlot_add__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HistPlot, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Hist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_HistPlot_add__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'HistPlot_add'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::HistPlot::add(Pythia8::Hist const &,std::string,std::string)\n"
    "    Pythia8::HistPlot::add(Pythia8::Hist const &,std::string)\n"
    "    Pythia8::HistPlot::add(Pythia8::Hist const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HistPlot_plot__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HistPlot *arg1 = (Pythia8::HistPlot *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HistPlot_plot",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HistPlot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HistPlot_plot" "', argument " "1"" of type '" "Pythia8::HistPlot *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HistPlot * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HistPlot_plot" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->plot(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HistPlot_plot__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HistPlot *arg1 = (Pythia8::HistPlot *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HistPlot_plot",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HistPlot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HistPlot_plot" "', argument " "1"" of type '" "Pythia8::HistPlot *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HistPlot * >(argp1);
  (arg1)->plot();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HistPlot_plot(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HistPlot, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_HistPlot_plot__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HistPlot, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_HistPlot_plot__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'HistPlot_plot'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::HistPlot::plot(bool)\n"
    "    Pythia8::HistPlot::plot()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HistPlot_plotFrame__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HistPlot *arg1 = (Pythia8::HistPlot *) 0 ;
  std::string arg2 ;
  Pythia8::Hist *arg3 = 0 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  bool arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:HistPlot_plotFrame",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HistPlot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HistPlot_plotFrame" "', argument " "1"" of type '" "Pythia8::HistPlot *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HistPlot * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HistPlot_plotFrame" "', argument " "3"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HistPlot_plotFrame" "', argument " "3"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Hist * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "5"" of type '" "std::string""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "6"" of type '" "std::string""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "7"" of type '" "std::string""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "8"" of type '" "std::string""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "HistPlot_plotFrame" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  (arg1)->plotFrame(arg2,(Pythia8::Hist const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HistPlot_plotFrame__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HistPlot *arg1 = (Pythia8::HistPlot *) 0 ;
  std::string arg2 ;
  Pythia8::Hist *arg3 = 0 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  std::string arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:HistPlot_plotFrame",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HistPlot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HistPlot_plotFrame" "', argument " "1"" of type '" "Pythia8::HistPlot *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HistPlot * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HistPlot_plotFrame" "', argument " "3"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HistPlot_plotFrame" "', argument " "3"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Hist * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "5"" of type '" "std::string""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "6"" of type '" "std::string""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "7"" of type '" "std::string""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "8"" of type '" "std::string""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->plotFrame(arg2,(Pythia8::Hist const &)*arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HistPlot_plotFrame__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HistPlot *arg1 = (Pythia8::HistPlot *) 0 ;
  std::string arg2 ;
  Pythia8::Hist *arg3 = 0 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  std::string arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:HistPlot_plotFrame",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HistPlot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HistPlot_plotFrame" "', argument " "1"" of type '" "Pythia8::HistPlot *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HistPlot * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HistPlot_plotFrame" "', argument " "3"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HistPlot_plotFrame" "', argument " "3"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Hist * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "5"" of type '" "std::string""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "6"" of type '" "std::string""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "7"" of type '" "std::string""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->plotFrame(arg2,(Pythia8::Hist const &)*arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HistPlot_plotFrame__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HistPlot *arg1 = (Pythia8::HistPlot *) 0 ;
  std::string arg2 ;
  Pythia8::Hist *arg3 = 0 ;
  std::string arg4 ;
  std::string arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:HistPlot_plotFrame",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HistPlot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HistPlot_plotFrame" "', argument " "1"" of type '" "Pythia8::HistPlot *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HistPlot * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HistPlot_plotFrame" "', argument " "3"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HistPlot_plotFrame" "', argument " "3"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Hist * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "5"" of type '" "std::string""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "6"" of type '" "std::string""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->plotFrame(arg2,(Pythia8::Hist const &)*arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HistPlot_plotFrame__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HistPlot *arg1 = (Pythia8::HistPlot *) 0 ;
  std::string arg2 ;
  Pythia8::Hist *arg3 = 0 ;
  std::string arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:HistPlot_plotFrame",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HistPlot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HistPlot_plotFrame" "', argument " "1"" of type '" "Pythia8::HistPlot *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HistPlot * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HistPlot_plotFrame" "', argument " "3"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HistPlot_plotFrame" "', argument " "3"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Hist * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "5"" of type '" "std::string""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->plotFrame(arg2,(Pythia8::Hist const &)*arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HistPlot_plotFrame__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HistPlot *arg1 = (Pythia8::HistPlot *) 0 ;
  std::string arg2 ;
  Pythia8::Hist *arg3 = 0 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:HistPlot_plotFrame",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HistPlot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HistPlot_plotFrame" "', argument " "1"" of type '" "Pythia8::HistPlot *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HistPlot * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HistPlot_plotFrame" "', argument " "3"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HistPlot_plotFrame" "', argument " "3"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Hist * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->plotFrame(arg2,(Pythia8::Hist const &)*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HistPlot_plotFrame__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HistPlot *arg1 = (Pythia8::HistPlot *) 0 ;
  std::string arg2 ;
  Pythia8::Hist *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:HistPlot_plotFrame",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HistPlot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HistPlot_plotFrame" "', argument " "1"" of type '" "Pythia8::HistPlot *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HistPlot * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HistPlot_plotFrame" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Hist,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HistPlot_plotFrame" "', argument " "3"" of type '" "Pythia8::Hist const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HistPlot_plotFrame" "', argument " "3"" of type '" "Pythia8::Hist const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Hist * >(argp3);
  (arg1)->plotFrame(arg2,(Pythia8::Hist const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HistPlot_plotFrame(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 9) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HistPlot, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Hist, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_HistPlot_plotFrame__SWIG_6(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HistPlot, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Hist, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_HistPlot_plotFrame__SWIG_5(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HistPlot, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Hist, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_HistPlot_plotFrame__SWIG_4(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HistPlot, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Hist, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_HistPlot_plotFrame__SWIG_3(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HistPlot, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Hist, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_HistPlot_plotFrame__SWIG_2(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HistPlot, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Hist, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_HistPlot_plotFrame__SWIG_1(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HistPlot, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Hist, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_string(argv[7], (std::string**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_HistPlot_plotFrame__SWIG_0(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'HistPlot_plotFrame'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::HistPlot::plotFrame(std::string,Pythia8::Hist const &,std::string,std::string,std::string,std::string,std::string,bool)\n"
    "    Pythia8::HistPlot::plotFrame(std::string,Pythia8::Hist const &,std::string,std::string,std::string,std::string,std::string)\n"
    "    Pythia8::HistPlot::plotFrame(std::string,Pythia8::Hist const &,std::string,std::string,std::string,std::string)\n"
    "    Pythia8::HistPlot::plotFrame(std::string,Pythia8::Hist const &,std::string,std::string,std::string)\n"
    "    Pythia8::HistPlot::plotFrame(std::string,Pythia8::Hist const &,std::string,std::string)\n"
    "    Pythia8::HistPlot::plotFrame(std::string,Pythia8::Hist const &,std::string)\n"
    "    Pythia8::HistPlot::plotFrame(std::string,Pythia8::Hist const &)\n");
  return 0;
}


SWIGINTERN PyObject *HistPlot_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HistPlot, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN int Swig_var_XMLTag_end_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable XMLTag_end is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_XMLTag_end_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&Pythia8::XMLTag::end), SWIGTYPE_p_std__string__size_type,  0 );
  return pyobj;
}


SWIGINTERN PyObject *_wrap_delete_XMLTag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = (Pythia8::XMLTag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_XMLTag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__XMLTag, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XMLTag" "', argument " "1"" of type '" "Pythia8::XMLTag *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = (Pythia8::XMLTag *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:XMLTag_name_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_name_set" "', argument " "1"" of type '" "Pythia8::XMLTag *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLTag_name_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLTag_name_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->name = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = (Pythia8::XMLTag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:XMLTag_name_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_name_get" "', argument " "1"" of type '" "Pythia8::XMLTag *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  result = (std::string *) & ((arg1)->name);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_attr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = (Pythia8::XMLTag *) 0 ;
  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *arg2 = (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:XMLTag_attr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_attr_set" "', argument " "1"" of type '" "Pythia8::XMLTag *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLTag_attr_set" "', argument " "2"" of type '" "std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > * >(argp2);
  if (arg1) (arg1)->attr = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_attr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = (Pythia8::XMLTag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:XMLTag_attr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_attr_get" "', argument " "1"" of type '" "Pythia8::XMLTag *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  result = (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *)& ((arg1)->attr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_tags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = (Pythia8::XMLTag *) 0 ;
  std::vector< Pythia8::XMLTag *,std::allocator< Pythia8::XMLTag * > > *arg2 = (std::vector< Pythia8::XMLTag *,std::allocator< Pythia8::XMLTag * > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:XMLTag_tags_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_tags_set" "', argument " "1"" of type '" "Pythia8::XMLTag *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_Pythia8__XMLTag_p_std__allocatorT_Pythia8__XMLTag_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLTag_tags_set" "', argument " "2"" of type '" "std::vector< Pythia8::XMLTag *,std::allocator< Pythia8::XMLTag * > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::XMLTag *,std::allocator< Pythia8::XMLTag * > > * >(argp2);
  if (arg1) (arg1)->tags = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_tags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = (Pythia8::XMLTag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::XMLTag *,std::allocator< Pythia8::XMLTag * > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:XMLTag_tags_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_tags_get" "', argument " "1"" of type '" "Pythia8::XMLTag *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  result = (std::vector< Pythia8::XMLTag *,std::allocator< Pythia8::XMLTag * > > *)& ((arg1)->tags);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__XMLTag_p_std__allocatorT_Pythia8__XMLTag_p_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_contents_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = (Pythia8::XMLTag *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:XMLTag_contents_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_contents_set" "', argument " "1"" of type '" "Pythia8::XMLTag *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLTag_contents_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLTag_contents_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->contents = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_contents_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = (Pythia8::XMLTag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:XMLTag_contents_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_contents_get" "', argument " "1"" of type '" "Pythia8::XMLTag *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  result = (std::string *) & ((arg1)->contents);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_getattr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = (Pythia8::XMLTag *) 0 ;
  std::string arg2 ;
  double *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:XMLTag_getattr",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_getattr" "', argument " "1"" of type '" "Pythia8::XMLTag const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLTag_getattr" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLTag_getattr" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLTag_getattr" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  result = (bool)((Pythia8::XMLTag const *)arg1)->getattr(arg2,*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_getattr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = (Pythia8::XMLTag *) 0 ;
  std::string arg2 ;
  bool *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:XMLTag_getattr",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_getattr" "', argument " "1"" of type '" "Pythia8::XMLTag const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLTag_getattr" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLTag_getattr" "', argument " "3"" of type '" "bool &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLTag_getattr" "', argument " "3"" of type '" "bool &""'"); 
  }
  arg3 = reinterpret_cast< bool * >(argp3);
  result = (bool)((Pythia8::XMLTag const *)arg1)->getattr(arg2,*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_getattr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = (Pythia8::XMLTag *) 0 ;
  std::string arg2 ;
  long *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:XMLTag_getattr",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_getattr" "', argument " "1"" of type '" "Pythia8::XMLTag const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLTag_getattr" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_long,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLTag_getattr" "', argument " "3"" of type '" "long &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLTag_getattr" "', argument " "3"" of type '" "long &""'"); 
  }
  arg3 = reinterpret_cast< long * >(argp3);
  result = (bool)((Pythia8::XMLTag const *)arg1)->getattr(arg2,*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_getattr__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = (Pythia8::XMLTag *) 0 ;
  std::string arg2 ;
  int *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:XMLTag_getattr",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_getattr" "', argument " "1"" of type '" "Pythia8::XMLTag const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLTag_getattr" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLTag_getattr" "', argument " "3"" of type '" "int &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLTag_getattr" "', argument " "3"" of type '" "int &""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  result = (bool)((Pythia8::XMLTag const *)arg1)->getattr(arg2,*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_getattr__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = (Pythia8::XMLTag *) 0 ;
  std::string arg2 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:XMLTag_getattr",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag_getattr" "', argument " "1"" of type '" "Pythia8::XMLTag const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLTag_getattr" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XMLTag_getattr" "', argument " "3"" of type '" "std::string &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XMLTag_getattr" "', argument " "3"" of type '" "std::string &""'"); 
  }
  arg3 = reinterpret_cast< std::string * >(argp3);
  result = (bool)((Pythia8::XMLTag const *)arg1)->getattr(arg2,*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_getattr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLTag_getattr__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_bool, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLTag_getattr__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_long, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLTag_getattr__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLTag_getattr__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__string, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_XMLTag_getattr__SWIG_4(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'XMLTag_getattr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::XMLTag::getattr(std::string,double &) const\n"
    "    Pythia8::XMLTag::getattr(std::string,bool &) const\n"
    "    Pythia8::XMLTag::getattr(std::string,long &) const\n"
    "    Pythia8::XMLTag::getattr(std::string,int &) const\n"
    "    Pythia8::XMLTag::getattr(std::string,std::string &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLTag_findXMLTags__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string *arg2 = (std::string *) 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigValueWrapper< std::vector< Pythia8::XMLTag *,std::allocator< Pythia8::XMLTag * > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:XMLTag_findXMLTags",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLTag_findXMLTags" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__string, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XMLTag_findXMLTags" "', argument " "2"" of type '" "std::string *""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  result = Pythia8::XMLTag::findXMLTags(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new std::vector< Pythia8::XMLTag *,std::allocator< Pythia8::XMLTag * > >(static_cast< const std::vector< Pythia8::XMLTag *,std::allocator< Pythia8::XMLTag * > >& >(result))), SWIGTYPE_p_std__vectorT_Pythia8__XMLTag_p_std__allocatorT_Pythia8__XMLTag_p_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_findXMLTags__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::vector< Pythia8::XMLTag *,std::allocator< Pythia8::XMLTag * > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:XMLTag_findXMLTags",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "XMLTag_findXMLTags" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = Pythia8::XMLTag::findXMLTags(arg1);
  resultobj = SWIG_NewPointerObj((new std::vector< Pythia8::XMLTag *,std::allocator< Pythia8::XMLTag * > >(static_cast< const std::vector< Pythia8::XMLTag *,std::allocator< Pythia8::XMLTag * > >& >(result))), SWIGTYPE_p_std__vectorT_Pythia8__XMLTag_p_std__allocatorT_Pythia8__XMLTag_p_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_XMLTag_findXMLTags(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_XMLTag_findXMLTags__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_XMLTag_findXMLTags__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'XMLTag_findXMLTags'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::XMLTag::findXMLTags(std::string,std::string *)\n"
    "    Pythia8::XMLTag::findXMLTags(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_XMLTag___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = (Pythia8::XMLTag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:XMLTag___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__XMLTag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XMLTag___str__" "', argument " "1"" of type '" "Pythia8::XMLTag *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  result = Pythia8_XMLTag___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_XMLTag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_XMLTag")) SWIG_fail;
  result = (Pythia8::XMLTag *)new Pythia8::XMLTag();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__XMLTag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *XMLTag_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__XMLTag, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LHAweights__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweights *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LHAweights")) SWIG_fail;
  result = (Pythia8::LHAweights *)new Pythia8::LHAweights();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAweights, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAweights__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHAweights *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LHAweights",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__XMLTag,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAweights" "', argument " "1"" of type '" "Pythia8::XMLTag const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LHAweights" "', argument " "1"" of type '" "Pythia8::XMLTag const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  result = (Pythia8::LHAweights *)new Pythia8::LHAweights((Pythia8::XMLTag const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAweights, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAweights(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_LHAweights__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LHAweights__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LHAweights'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAweights::LHAweights()\n"
    "    Pythia8::LHAweights::LHAweights(Pythia8::XMLTag const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAweights_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweights *arg1 = (Pythia8::LHAweights *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAweights_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweights, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweights_clear" "', argument " "1"" of type '" "Pythia8::LHAweights *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweights * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweights_weights_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweights *arg1 = (Pythia8::LHAweights *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = (std::vector< double,std::allocator< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAweights_weights_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweights, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweights_weights_set" "', argument " "1"" of type '" "Pythia8::LHAweights *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweights * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAweights_weights_set" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp2);
  if (arg1) (arg1)->weights = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweights_weights_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweights *arg1 = (Pythia8::LHAweights *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAweights_weights_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweights, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweights_weights_get" "', argument " "1"" of type '" "Pythia8::LHAweights *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweights * >(argp1);
  result = (std::vector< double,std::allocator< double > > *)& ((arg1)->weights);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweights_attributes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweights *arg1 = (Pythia8::LHAweights *) 0 ;
  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *arg2 = (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAweights_attributes_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweights, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweights_attributes_set" "', argument " "1"" of type '" "Pythia8::LHAweights *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweights * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAweights_attributes_set" "', argument " "2"" of type '" "std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > * >(argp2);
  if (arg1) (arg1)->attributes = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweights_attributes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweights *arg1 = (Pythia8::LHAweights *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAweights_attributes_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweights, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweights_attributes_get" "', argument " "1"" of type '" "Pythia8::LHAweights *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweights * >(argp1);
  result = (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *)& ((arg1)->attributes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweights_contents_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweights *arg1 = (Pythia8::LHAweights *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAweights_contents_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweights, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweights_contents_set" "', argument " "1"" of type '" "Pythia8::LHAweights *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweights * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAweights_contents_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LHAweights_contents_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->contents = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweights_contents_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweights *arg1 = (Pythia8::LHAweights *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAweights_contents_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweights, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweights_contents_get" "', argument " "1"" of type '" "Pythia8::LHAweights *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweights * >(argp1);
  result = (std::string *) & ((arg1)->contents);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweights_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweights *arg1 = (Pythia8::LHAweights *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAweights_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweights, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweights_size" "', argument " "1"" of type '" "Pythia8::LHAweights *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweights * >(argp1);
  result = (int)(arg1)->size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweights___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweights *arg1 = (Pythia8::LHAweights *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAweights___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweights, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweights___str__" "', argument " "1"" of type '" "Pythia8::LHAweights *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweights * >(argp1);
  result = Pythia8_LHAweights___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LHAweights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweights *arg1 = (Pythia8::LHAweights *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LHAweights",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweights, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LHAweights" "', argument " "1"" of type '" "Pythia8::LHAweights *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweights * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LHAweights_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__LHAweights, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LHAscales__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHAscales *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LHAscales",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LHAscales" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  result = (Pythia8::LHAscales *)new Pythia8::LHAscales(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAscales, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAscales__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAscales *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LHAscales")) SWIG_fail;
  result = (Pythia8::LHAscales *)new Pythia8::LHAscales();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAscales, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAscales__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::LHAscales *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_LHAscales",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__XMLTag,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAscales" "', argument " "1"" of type '" "Pythia8::XMLTag const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LHAscales" "', argument " "1"" of type '" "Pythia8::XMLTag const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LHAscales" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (Pythia8::LHAscales *)new Pythia8::LHAscales((Pythia8::XMLTag const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAscales, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAscales__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHAscales *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LHAscales",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__XMLTag,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAscales" "', argument " "1"" of type '" "Pythia8::XMLTag const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LHAscales" "', argument " "1"" of type '" "Pythia8::XMLTag const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  result = (Pythia8::LHAscales *)new Pythia8::LHAscales((Pythia8::XMLTag const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAscales, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAscales(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_LHAscales__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LHAscales__SWIG_3(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_LHAscales__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_LHAscales__SWIG_2(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LHAscales'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAscales::LHAscales(double)\n"
    "    Pythia8::LHAscales::LHAscales()\n"
    "    Pythia8::LHAscales::LHAscales(Pythia8::XMLTag const &,double)\n"
    "    Pythia8::LHAscales::LHAscales(Pythia8::XMLTag const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAscales_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAscales *arg1 = (Pythia8::LHAscales *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAscales_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAscales, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAscales_clear" "', argument " "1"" of type '" "Pythia8::LHAscales *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAscales * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAscales_muf_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAscales *arg1 = (Pythia8::LHAscales *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAscales_muf_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAscales, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAscales_muf_set" "', argument " "1"" of type '" "Pythia8::LHAscales *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAscales * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAscales_muf_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->muf = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAscales_muf_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAscales *arg1 = (Pythia8::LHAscales *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAscales_muf_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAscales, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAscales_muf_get" "', argument " "1"" of type '" "Pythia8::LHAscales *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAscales * >(argp1);
  result = (double) ((arg1)->muf);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAscales_mur_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAscales *arg1 = (Pythia8::LHAscales *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAscales_mur_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAscales, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAscales_mur_set" "', argument " "1"" of type '" "Pythia8::LHAscales *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAscales * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAscales_mur_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->mur = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAscales_mur_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAscales *arg1 = (Pythia8::LHAscales *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAscales_mur_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAscales, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAscales_mur_get" "', argument " "1"" of type '" "Pythia8::LHAscales *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAscales * >(argp1);
  result = (double) ((arg1)->mur);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAscales_mups_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAscales *arg1 = (Pythia8::LHAscales *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAscales_mups_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAscales, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAscales_mups_set" "', argument " "1"" of type '" "Pythia8::LHAscales *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAscales * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAscales_mups_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->mups = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAscales_mups_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAscales *arg1 = (Pythia8::LHAscales *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAscales_mups_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAscales, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAscales_mups_get" "', argument " "1"" of type '" "Pythia8::LHAscales *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAscales * >(argp1);
  result = (double) ((arg1)->mups);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAscales_attributes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAscales *arg1 = (Pythia8::LHAscales *) 0 ;
  std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > *arg2 = (std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAscales_attributes_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAscales, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAscales_attributes_set" "', argument " "1"" of type '" "Pythia8::LHAscales *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAscales * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAscales_attributes_set" "', argument " "2"" of type '" "std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > * >(argp2);
  if (arg1) (arg1)->attributes = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAscales_attributes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAscales *arg1 = (Pythia8::LHAscales *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAscales_attributes_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAscales, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAscales_attributes_get" "', argument " "1"" of type '" "Pythia8::LHAscales *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAscales * >(argp1);
  result = (std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > *)& ((arg1)->attributes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAscales_SCALUP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAscales *arg1 = (Pythia8::LHAscales *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAscales_SCALUP_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAscales, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAscales_SCALUP_set" "', argument " "1"" of type '" "Pythia8::LHAscales *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAscales * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAscales_SCALUP_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->SCALUP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAscales_SCALUP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAscales *arg1 = (Pythia8::LHAscales *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAscales_SCALUP_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAscales, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAscales_SCALUP_get" "', argument " "1"" of type '" "Pythia8::LHAscales *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAscales * >(argp1);
  result = (double) ((arg1)->SCALUP);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAscales_contents_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAscales *arg1 = (Pythia8::LHAscales *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAscales_contents_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAscales, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAscales_contents_set" "', argument " "1"" of type '" "Pythia8::LHAscales *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAscales * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAscales_contents_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LHAscales_contents_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->contents = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAscales_contents_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAscales *arg1 = (Pythia8::LHAscales *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAscales_contents_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAscales, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAscales_contents_get" "', argument " "1"" of type '" "Pythia8::LHAscales *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAscales * >(argp1);
  result = (std::string *) & ((arg1)->contents);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAscales___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAscales *arg1 = (Pythia8::LHAscales *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAscales___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAscales, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAscales___str__" "', argument " "1"" of type '" "Pythia8::LHAscales *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAscales * >(argp1);
  result = Pythia8_LHAscales___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LHAscales(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAscales *arg1 = (Pythia8::LHAscales *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LHAscales",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAscales, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LHAscales" "', argument " "1"" of type '" "Pythia8::LHAscales *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAscales * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LHAscales_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__LHAscales, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LHAgenerator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAgenerator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LHAgenerator")) SWIG_fail;
  result = (Pythia8::LHAgenerator *)new Pythia8::LHAgenerator();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAgenerator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAgenerator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::LHAgenerator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_LHAgenerator",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__XMLTag,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAgenerator" "', argument " "1"" of type '" "Pythia8::XMLTag const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LHAgenerator" "', argument " "1"" of type '" "Pythia8::XMLTag const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_LHAgenerator" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::LHAgenerator *)new Pythia8::LHAgenerator((Pythia8::XMLTag const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAgenerator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAgenerator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHAgenerator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LHAgenerator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__XMLTag,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAgenerator" "', argument " "1"" of type '" "Pythia8::XMLTag const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LHAgenerator" "', argument " "1"" of type '" "Pythia8::XMLTag const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  result = (Pythia8::LHAgenerator *)new Pythia8::LHAgenerator((Pythia8::XMLTag const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAgenerator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAgenerator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_LHAgenerator__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LHAgenerator__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_LHAgenerator__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LHAgenerator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAgenerator::LHAgenerator()\n"
    "    Pythia8::LHAgenerator::LHAgenerator(Pythia8::XMLTag const &,std::string)\n"
    "    Pythia8::LHAgenerator::LHAgenerator(Pythia8::XMLTag const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAgenerator_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAgenerator *arg1 = (Pythia8::LHAgenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAgenerator_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAgenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAgenerator_clear" "', argument " "1"" of type '" "Pythia8::LHAgenerator *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAgenerator * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAgenerator_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAgenerator *arg1 = (Pythia8::LHAgenerator *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAgenerator_name_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAgenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAgenerator_name_set" "', argument " "1"" of type '" "Pythia8::LHAgenerator *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAgenerator * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAgenerator_name_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LHAgenerator_name_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->name = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAgenerator_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAgenerator *arg1 = (Pythia8::LHAgenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAgenerator_name_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAgenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAgenerator_name_get" "', argument " "1"" of type '" "Pythia8::LHAgenerator *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAgenerator * >(argp1);
  result = (std::string *) & ((arg1)->name);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAgenerator_version_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAgenerator *arg1 = (Pythia8::LHAgenerator *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAgenerator_version_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAgenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAgenerator_version_set" "', argument " "1"" of type '" "Pythia8::LHAgenerator *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAgenerator * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAgenerator_version_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LHAgenerator_version_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->version = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAgenerator_version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAgenerator *arg1 = (Pythia8::LHAgenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAgenerator_version_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAgenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAgenerator_version_get" "', argument " "1"" of type '" "Pythia8::LHAgenerator *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAgenerator * >(argp1);
  result = (std::string *) & ((arg1)->version);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAgenerator_attributes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAgenerator *arg1 = (Pythia8::LHAgenerator *) 0 ;
  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *arg2 = (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAgenerator_attributes_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAgenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAgenerator_attributes_set" "', argument " "1"" of type '" "Pythia8::LHAgenerator *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAgenerator * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAgenerator_attributes_set" "', argument " "2"" of type '" "std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > * >(argp2);
  if (arg1) (arg1)->attributes = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAgenerator_attributes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAgenerator *arg1 = (Pythia8::LHAgenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAgenerator_attributes_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAgenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAgenerator_attributes_get" "', argument " "1"" of type '" "Pythia8::LHAgenerator *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAgenerator * >(argp1);
  result = (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *)& ((arg1)->attributes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAgenerator_contents_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAgenerator *arg1 = (Pythia8::LHAgenerator *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAgenerator_contents_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAgenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAgenerator_contents_set" "', argument " "1"" of type '" "Pythia8::LHAgenerator *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAgenerator * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAgenerator_contents_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LHAgenerator_contents_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->contents = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAgenerator_contents_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAgenerator *arg1 = (Pythia8::LHAgenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAgenerator_contents_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAgenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAgenerator_contents_get" "', argument " "1"" of type '" "Pythia8::LHAgenerator *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAgenerator * >(argp1);
  result = (std::string *) & ((arg1)->contents);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAgenerator___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAgenerator *arg1 = (Pythia8::LHAgenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAgenerator___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAgenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAgenerator___str__" "', argument " "1"" of type '" "Pythia8::LHAgenerator *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAgenerator * >(argp1);
  result = Pythia8_LHAgenerator___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LHAgenerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAgenerator *arg1 = (Pythia8::LHAgenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LHAgenerator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAgenerator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LHAgenerator" "', argument " "1"" of type '" "Pythia8::LHAgenerator *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAgenerator * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LHAgenerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__LHAgenerator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LHAwgt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHAwgt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LHAwgt",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LHAwgt" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  result = (Pythia8::LHAwgt *)new Pythia8::LHAwgt(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAwgt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAwgt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAwgt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LHAwgt")) SWIG_fail;
  result = (Pythia8::LHAwgt *)new Pythia8::LHAwgt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAwgt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAwgt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::LHAwgt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_LHAwgt",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__XMLTag,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAwgt" "', argument " "1"" of type '" "Pythia8::XMLTag const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LHAwgt" "', argument " "1"" of type '" "Pythia8::XMLTag const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LHAwgt" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (Pythia8::LHAwgt *)new Pythia8::LHAwgt((Pythia8::XMLTag const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAwgt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAwgt__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHAwgt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LHAwgt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__XMLTag,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAwgt" "', argument " "1"" of type '" "Pythia8::XMLTag const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LHAwgt" "', argument " "1"" of type '" "Pythia8::XMLTag const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  result = (Pythia8::LHAwgt *)new Pythia8::LHAwgt((Pythia8::XMLTag const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAwgt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAwgt(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_LHAwgt__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LHAwgt__SWIG_3(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_LHAwgt__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_LHAwgt__SWIG_2(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LHAwgt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAwgt::LHAwgt(double)\n"
    "    Pythia8::LHAwgt::LHAwgt()\n"
    "    Pythia8::LHAwgt::LHAwgt(Pythia8::XMLTag const &,double)\n"
    "    Pythia8::LHAwgt::LHAwgt(Pythia8::XMLTag const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAwgt_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAwgt *arg1 = (Pythia8::LHAwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAwgt_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAwgt_clear" "', argument " "1"" of type '" "Pythia8::LHAwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAwgt * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAwgt_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAwgt *arg1 = (Pythia8::LHAwgt *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAwgt_id_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAwgt_id_set" "', argument " "1"" of type '" "Pythia8::LHAwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAwgt * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAwgt_id_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LHAwgt_id_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->id = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAwgt_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAwgt *arg1 = (Pythia8::LHAwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAwgt_id_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAwgt_id_get" "', argument " "1"" of type '" "Pythia8::LHAwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAwgt * >(argp1);
  result = (std::string *) & ((arg1)->id);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAwgt_attributes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAwgt *arg1 = (Pythia8::LHAwgt *) 0 ;
  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *arg2 = (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAwgt_attributes_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAwgt_attributes_set" "', argument " "1"" of type '" "Pythia8::LHAwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAwgt * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAwgt_attributes_set" "', argument " "2"" of type '" "std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > * >(argp2);
  if (arg1) (arg1)->attributes = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAwgt_attributes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAwgt *arg1 = (Pythia8::LHAwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAwgt_attributes_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAwgt_attributes_get" "', argument " "1"" of type '" "Pythia8::LHAwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAwgt * >(argp1);
  result = (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *)& ((arg1)->attributes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAwgt_contents_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAwgt *arg1 = (Pythia8::LHAwgt *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAwgt_contents_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAwgt_contents_set" "', argument " "1"" of type '" "Pythia8::LHAwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAwgt * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAwgt_contents_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->contents = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAwgt_contents_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAwgt *arg1 = (Pythia8::LHAwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAwgt_contents_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAwgt_contents_get" "', argument " "1"" of type '" "Pythia8::LHAwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAwgt * >(argp1);
  result = (double) ((arg1)->contents);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAwgt___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAwgt *arg1 = (Pythia8::LHAwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAwgt___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAwgt___str__" "', argument " "1"" of type '" "Pythia8::LHAwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAwgt * >(argp1);
  result = Pythia8_LHAwgt___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LHAwgt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAwgt *arg1 = (Pythia8::LHAwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LHAwgt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAwgt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LHAwgt" "', argument " "1"" of type '" "Pythia8::LHAwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAwgt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LHAwgt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__LHAwgt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LHAweight__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHAweight *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LHAweight",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_LHAweight" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::LHAweight *)new Pythia8::LHAweight(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAweight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAweight__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweight *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LHAweight")) SWIG_fail;
  result = (Pythia8::LHAweight *)new Pythia8::LHAweight();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAweight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAweight__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::LHAweight *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_LHAweight",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__XMLTag,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAweight" "', argument " "1"" of type '" "Pythia8::XMLTag const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LHAweight" "', argument " "1"" of type '" "Pythia8::XMLTag const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_LHAweight" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::LHAweight *)new Pythia8::LHAweight((Pythia8::XMLTag const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAweight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAweight__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHAweight *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LHAweight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__XMLTag,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAweight" "', argument " "1"" of type '" "Pythia8::XMLTag const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LHAweight" "', argument " "1"" of type '" "Pythia8::XMLTag const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  result = (Pythia8::LHAweight *)new Pythia8::LHAweight((Pythia8::XMLTag const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAweight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAweight(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_LHAweight__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LHAweight__SWIG_3(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LHAweight__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_LHAweight__SWIG_2(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LHAweight'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAweight::LHAweight(std::string)\n"
    "    Pythia8::LHAweight::LHAweight()\n"
    "    Pythia8::LHAweight::LHAweight(Pythia8::XMLTag const &,std::string)\n"
    "    Pythia8::LHAweight::LHAweight(Pythia8::XMLTag const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAweight_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweight *arg1 = (Pythia8::LHAweight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAweight_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweight_clear" "', argument " "1"" of type '" "Pythia8::LHAweight *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweight * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweight_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweight *arg1 = (Pythia8::LHAweight *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAweight_id_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweight_id_set" "', argument " "1"" of type '" "Pythia8::LHAweight *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweight * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAweight_id_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LHAweight_id_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->id = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweight_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweight *arg1 = (Pythia8::LHAweight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAweight_id_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweight_id_get" "', argument " "1"" of type '" "Pythia8::LHAweight *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweight * >(argp1);
  result = (std::string *) & ((arg1)->id);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweight_attributes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweight *arg1 = (Pythia8::LHAweight *) 0 ;
  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *arg2 = (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAweight_attributes_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweight_attributes_set" "', argument " "1"" of type '" "Pythia8::LHAweight *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweight * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAweight_attributes_set" "', argument " "2"" of type '" "std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > * >(argp2);
  if (arg1) (arg1)->attributes = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweight_attributes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweight *arg1 = (Pythia8::LHAweight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAweight_attributes_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweight_attributes_get" "', argument " "1"" of type '" "Pythia8::LHAweight *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweight * >(argp1);
  result = (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *)& ((arg1)->attributes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweight_contents_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweight *arg1 = (Pythia8::LHAweight *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAweight_contents_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweight_contents_set" "', argument " "1"" of type '" "Pythia8::LHAweight *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweight * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAweight_contents_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LHAweight_contents_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->contents = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweight_contents_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweight *arg1 = (Pythia8::LHAweight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAweight_contents_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweight_contents_get" "', argument " "1"" of type '" "Pythia8::LHAweight *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweight * >(argp1);
  result = (std::string *) & ((arg1)->contents);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweight___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweight *arg1 = (Pythia8::LHAweight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAweight___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweight___str__" "', argument " "1"" of type '" "Pythia8::LHAweight *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweight * >(argp1);
  result = Pythia8_LHAweight___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LHAweight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweight *arg1 = (Pythia8::LHAweight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LHAweight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LHAweight" "', argument " "1"" of type '" "Pythia8::LHAweight *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweight * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LHAweight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__LHAweight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LHAweightgroup__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweightgroup *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LHAweightgroup")) SWIG_fail;
  result = (Pythia8::LHAweightgroup *)new Pythia8::LHAweightgroup();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAweightgroup, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAweightgroup__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHAweightgroup *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LHAweightgroup",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__XMLTag,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAweightgroup" "', argument " "1"" of type '" "Pythia8::XMLTag const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LHAweightgroup" "', argument " "1"" of type '" "Pythia8::XMLTag const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  result = (Pythia8::LHAweightgroup *)new Pythia8::LHAweightgroup((Pythia8::XMLTag const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAweightgroup, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAweightgroup(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_LHAweightgroup__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LHAweightgroup__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LHAweightgroup'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAweightgroup::LHAweightgroup()\n"
    "    Pythia8::LHAweightgroup::LHAweightgroup(Pythia8::XMLTag const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAweightgroup_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweightgroup *arg1 = (Pythia8::LHAweightgroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAweightgroup_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweightgroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweightgroup_clear" "', argument " "1"" of type '" "Pythia8::LHAweightgroup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweightgroup * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweightgroup_contents_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweightgroup *arg1 = (Pythia8::LHAweightgroup *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAweightgroup_contents_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweightgroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweightgroup_contents_set" "', argument " "1"" of type '" "Pythia8::LHAweightgroup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweightgroup * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAweightgroup_contents_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LHAweightgroup_contents_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->contents = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweightgroup_contents_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweightgroup *arg1 = (Pythia8::LHAweightgroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAweightgroup_contents_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweightgroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweightgroup_contents_get" "', argument " "1"" of type '" "Pythia8::LHAweightgroup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweightgroup * >(argp1);
  result = (std::string *) & ((arg1)->contents);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweightgroup_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweightgroup *arg1 = (Pythia8::LHAweightgroup *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAweightgroup_name_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweightgroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweightgroup_name_set" "', argument " "1"" of type '" "Pythia8::LHAweightgroup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweightgroup * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAweightgroup_name_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LHAweightgroup_name_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->name = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweightgroup_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweightgroup *arg1 = (Pythia8::LHAweightgroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAweightgroup_name_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweightgroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweightgroup_name_get" "', argument " "1"" of type '" "Pythia8::LHAweightgroup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweightgroup * >(argp1);
  result = (std::string *) & ((arg1)->name);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweightgroup_weights_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweightgroup *arg1 = (Pythia8::LHAweightgroup *) 0 ;
  std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > *arg2 = (std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAweightgroup_weights_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweightgroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweightgroup_weights_set" "', argument " "1"" of type '" "Pythia8::LHAweightgroup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweightgroup * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAweight_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweight_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAweightgroup_weights_set" "', argument " "2"" of type '" "std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > * >(argp2);
  if (arg1) (arg1)->weights = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweightgroup_weights_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweightgroup *arg1 = (Pythia8::LHAweightgroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAweightgroup_weights_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweightgroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweightgroup_weights_get" "', argument " "1"" of type '" "Pythia8::LHAweightgroup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweightgroup * >(argp1);
  result = (std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > *)& ((arg1)->weights);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAweight_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweight_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweightgroup_weightsKeys_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweightgroup *arg1 = (Pythia8::LHAweightgroup *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = (std::vector< std::string,std::allocator< std::string > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAweightgroup_weightsKeys_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweightgroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweightgroup_weightsKeys_set" "', argument " "1"" of type '" "Pythia8::LHAweightgroup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweightgroup * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAweightgroup_weightsKeys_set" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp2);
  if (arg1) (arg1)->weightsKeys = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweightgroup_weightsKeys_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweightgroup *arg1 = (Pythia8::LHAweightgroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAweightgroup_weightsKeys_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweightgroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweightgroup_weightsKeys_get" "', argument " "1"" of type '" "Pythia8::LHAweightgroup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweightgroup * >(argp1);
  result = (std::vector< std::string,std::allocator< std::string > > *)& ((arg1)->weightsKeys);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweightgroup_attributes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweightgroup *arg1 = (Pythia8::LHAweightgroup *) 0 ;
  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *arg2 = (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAweightgroup_attributes_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweightgroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweightgroup_attributes_set" "', argument " "1"" of type '" "Pythia8::LHAweightgroup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweightgroup * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAweightgroup_attributes_set" "', argument " "2"" of type '" "std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > * >(argp2);
  if (arg1) (arg1)->attributes = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweightgroup_attributes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweightgroup *arg1 = (Pythia8::LHAweightgroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAweightgroup_attributes_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweightgroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweightgroup_attributes_get" "', argument " "1"" of type '" "Pythia8::LHAweightgroup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweightgroup * >(argp1);
  result = (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *)& ((arg1)->attributes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweightgroup_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweightgroup *arg1 = (Pythia8::LHAweightgroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAweightgroup_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweightgroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweightgroup_size" "', argument " "1"" of type '" "Pythia8::LHAweightgroup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweightgroup * >(argp1);
  result = (int)(arg1)->size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAweightgroup___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweightgroup *arg1 = (Pythia8::LHAweightgroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAweightgroup___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweightgroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAweightgroup___str__" "', argument " "1"" of type '" "Pythia8::LHAweightgroup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweightgroup * >(argp1);
  result = Pythia8_LHAweightgroup___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LHAweightgroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAweightgroup *arg1 = (Pythia8::LHAweightgroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LHAweightgroup",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAweightgroup, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LHAweightgroup" "', argument " "1"" of type '" "Pythia8::LHAweightgroup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAweightgroup * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LHAweightgroup_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__LHAweightgroup, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LHArwgt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHArwgt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LHArwgt")) SWIG_fail;
  result = (Pythia8::LHArwgt *)new Pythia8::LHArwgt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHArwgt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHArwgt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHArwgt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LHArwgt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__XMLTag,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHArwgt" "', argument " "1"" of type '" "Pythia8::XMLTag const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LHArwgt" "', argument " "1"" of type '" "Pythia8::XMLTag const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  result = (Pythia8::LHArwgt *)new Pythia8::LHArwgt((Pythia8::XMLTag const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHArwgt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHArwgt(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_LHArwgt__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LHArwgt__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LHArwgt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHArwgt::LHArwgt()\n"
    "    Pythia8::LHArwgt::LHArwgt(Pythia8::XMLTag const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHArwgt_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHArwgt *arg1 = (Pythia8::LHArwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHArwgt_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHArwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHArwgt_clear" "', argument " "1"" of type '" "Pythia8::LHArwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHArwgt * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHArwgt_contents_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHArwgt *arg1 = (Pythia8::LHArwgt *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHArwgt_contents_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHArwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHArwgt_contents_set" "', argument " "1"" of type '" "Pythia8::LHArwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHArwgt * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHArwgt_contents_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LHArwgt_contents_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->contents = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHArwgt_contents_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHArwgt *arg1 = (Pythia8::LHArwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHArwgt_contents_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHArwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHArwgt_contents_get" "', argument " "1"" of type '" "Pythia8::LHArwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHArwgt * >(argp1);
  result = (std::string *) & ((arg1)->contents);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHArwgt_wgts_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHArwgt *arg1 = (Pythia8::LHArwgt *) 0 ;
  std::map< std::string,Pythia8::LHAwgt,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAwgt > > > *arg2 = (std::map< std::string,Pythia8::LHAwgt,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAwgt > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHArwgt_wgts_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHArwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHArwgt_wgts_set" "', argument " "1"" of type '" "Pythia8::LHArwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHArwgt * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAwgt_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAwgt_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHArwgt_wgts_set" "', argument " "2"" of type '" "std::map< std::string,Pythia8::LHAwgt,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAwgt > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,Pythia8::LHAwgt,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAwgt > > > * >(argp2);
  if (arg1) (arg1)->wgts = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHArwgt_wgts_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHArwgt *arg1 = (Pythia8::LHArwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::LHAwgt,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAwgt > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHArwgt_wgts_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHArwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHArwgt_wgts_get" "', argument " "1"" of type '" "Pythia8::LHArwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHArwgt * >(argp1);
  result = (std::map< std::string,Pythia8::LHAwgt,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAwgt > > > *)& ((arg1)->wgts);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAwgt_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAwgt_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHArwgt_wgtsKeys_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHArwgt *arg1 = (Pythia8::LHArwgt *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = (std::vector< std::string,std::allocator< std::string > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHArwgt_wgtsKeys_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHArwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHArwgt_wgtsKeys_set" "', argument " "1"" of type '" "Pythia8::LHArwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHArwgt * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHArwgt_wgtsKeys_set" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp2);
  if (arg1) (arg1)->wgtsKeys = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHArwgt_wgtsKeys_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHArwgt *arg1 = (Pythia8::LHArwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHArwgt_wgtsKeys_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHArwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHArwgt_wgtsKeys_get" "', argument " "1"" of type '" "Pythia8::LHArwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHArwgt * >(argp1);
  result = (std::vector< std::string,std::allocator< std::string > > *)& ((arg1)->wgtsKeys);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHArwgt_attributes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHArwgt *arg1 = (Pythia8::LHArwgt *) 0 ;
  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *arg2 = (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHArwgt_attributes_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHArwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHArwgt_attributes_set" "', argument " "1"" of type '" "Pythia8::LHArwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHArwgt * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHArwgt_attributes_set" "', argument " "2"" of type '" "std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > * >(argp2);
  if (arg1) (arg1)->attributes = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHArwgt_attributes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHArwgt *arg1 = (Pythia8::LHArwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHArwgt_attributes_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHArwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHArwgt_attributes_get" "', argument " "1"" of type '" "Pythia8::LHArwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHArwgt * >(argp1);
  result = (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *)& ((arg1)->attributes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHArwgt_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHArwgt *arg1 = (Pythia8::LHArwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHArwgt_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHArwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHArwgt_size" "', argument " "1"" of type '" "Pythia8::LHArwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHArwgt * >(argp1);
  result = (int)(arg1)->size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHArwgt___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHArwgt *arg1 = (Pythia8::LHArwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHArwgt___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHArwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHArwgt___str__" "', argument " "1"" of type '" "Pythia8::LHArwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHArwgt * >(argp1);
  result = Pythia8_LHArwgt___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LHArwgt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHArwgt *arg1 = (Pythia8::LHArwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LHArwgt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHArwgt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LHArwgt" "', argument " "1"" of type '" "Pythia8::LHArwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHArwgt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LHArwgt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__LHArwgt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LHAinitrwgt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAinitrwgt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LHAinitrwgt")) SWIG_fail;
  result = (Pythia8::LHAinitrwgt *)new Pythia8::LHAinitrwgt();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAinitrwgt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAinitrwgt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::XMLTag *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHAinitrwgt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LHAinitrwgt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__XMLTag,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAinitrwgt" "', argument " "1"" of type '" "Pythia8::XMLTag const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LHAinitrwgt" "', argument " "1"" of type '" "Pythia8::XMLTag const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::XMLTag * >(argp1);
  result = (Pythia8::LHAinitrwgt *)new Pythia8::LHAinitrwgt((Pythia8::XMLTag const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAinitrwgt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAinitrwgt(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_LHAinitrwgt__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__XMLTag, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LHAinitrwgt__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LHAinitrwgt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAinitrwgt::LHAinitrwgt()\n"
    "    Pythia8::LHAinitrwgt::LHAinitrwgt(Pythia8::XMLTag const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAinitrwgt_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAinitrwgt *arg1 = (Pythia8::LHAinitrwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAinitrwgt_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAinitrwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAinitrwgt_clear" "', argument " "1"" of type '" "Pythia8::LHAinitrwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAinitrwgt * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAinitrwgt_contents_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAinitrwgt *arg1 = (Pythia8::LHAinitrwgt *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAinitrwgt_contents_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAinitrwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAinitrwgt_contents_set" "', argument " "1"" of type '" "Pythia8::LHAinitrwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAinitrwgt * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAinitrwgt_contents_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LHAinitrwgt_contents_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->contents = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAinitrwgt_contents_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAinitrwgt *arg1 = (Pythia8::LHAinitrwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAinitrwgt_contents_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAinitrwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAinitrwgt_contents_get" "', argument " "1"" of type '" "Pythia8::LHAinitrwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAinitrwgt * >(argp1);
  result = (std::string *) & ((arg1)->contents);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAinitrwgt_weights_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAinitrwgt *arg1 = (Pythia8::LHAinitrwgt *) 0 ;
  std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > *arg2 = (std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAinitrwgt_weights_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAinitrwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAinitrwgt_weights_set" "', argument " "1"" of type '" "Pythia8::LHAinitrwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAinitrwgt * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAweight_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweight_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAinitrwgt_weights_set" "', argument " "2"" of type '" "std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > * >(argp2);
  if (arg1) (arg1)->weights = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAinitrwgt_weights_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAinitrwgt *arg1 = (Pythia8::LHAinitrwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAinitrwgt_weights_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAinitrwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAinitrwgt_weights_get" "', argument " "1"" of type '" "Pythia8::LHAinitrwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAinitrwgt * >(argp1);
  result = (std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > *)& ((arg1)->weights);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAweight_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweight_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAinitrwgt_weightsKeys_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAinitrwgt *arg1 = (Pythia8::LHAinitrwgt *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = (std::vector< std::string,std::allocator< std::string > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAinitrwgt_weightsKeys_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAinitrwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAinitrwgt_weightsKeys_set" "', argument " "1"" of type '" "Pythia8::LHAinitrwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAinitrwgt * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAinitrwgt_weightsKeys_set" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp2);
  if (arg1) (arg1)->weightsKeys = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAinitrwgt_weightsKeys_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAinitrwgt *arg1 = (Pythia8::LHAinitrwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAinitrwgt_weightsKeys_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAinitrwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAinitrwgt_weightsKeys_get" "', argument " "1"" of type '" "Pythia8::LHAinitrwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAinitrwgt * >(argp1);
  result = (std::vector< std::string,std::allocator< std::string > > *)& ((arg1)->weightsKeys);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAinitrwgt_weightgroups_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAinitrwgt *arg1 = (Pythia8::LHAinitrwgt *) 0 ;
  std::map< std::string,Pythia8::LHAweightgroup,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweightgroup > > > *arg2 = (std::map< std::string,Pythia8::LHAweightgroup,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweightgroup > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAinitrwgt_weightgroups_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAinitrwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAinitrwgt_weightgroups_set" "', argument " "1"" of type '" "Pythia8::LHAinitrwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAinitrwgt * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAweightgroup_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweightgroup_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAinitrwgt_weightgroups_set" "', argument " "2"" of type '" "std::map< std::string,Pythia8::LHAweightgroup,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweightgroup > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,Pythia8::LHAweightgroup,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweightgroup > > > * >(argp2);
  if (arg1) (arg1)->weightgroups = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAinitrwgt_weightgroups_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAinitrwgt *arg1 = (Pythia8::LHAinitrwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::LHAweightgroup,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweightgroup > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAinitrwgt_weightgroups_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAinitrwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAinitrwgt_weightgroups_get" "', argument " "1"" of type '" "Pythia8::LHAinitrwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAinitrwgt * >(argp1);
  result = (std::map< std::string,Pythia8::LHAweightgroup,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweightgroup > > > *)& ((arg1)->weightgroups);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAweightgroup_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweightgroup_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAinitrwgt_weightgroupsKeys_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAinitrwgt *arg1 = (Pythia8::LHAinitrwgt *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = (std::vector< std::string,std::allocator< std::string > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAinitrwgt_weightgroupsKeys_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAinitrwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAinitrwgt_weightgroupsKeys_set" "', argument " "1"" of type '" "Pythia8::LHAinitrwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAinitrwgt * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAinitrwgt_weightgroupsKeys_set" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp2);
  if (arg1) (arg1)->weightgroupsKeys = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAinitrwgt_weightgroupsKeys_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAinitrwgt *arg1 = (Pythia8::LHAinitrwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAinitrwgt_weightgroupsKeys_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAinitrwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAinitrwgt_weightgroupsKeys_get" "', argument " "1"" of type '" "Pythia8::LHAinitrwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAinitrwgt * >(argp1);
  result = (std::vector< std::string,std::allocator< std::string > > *)& ((arg1)->weightgroupsKeys);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAinitrwgt_attributes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAinitrwgt *arg1 = (Pythia8::LHAinitrwgt *) 0 ;
  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *arg2 = (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAinitrwgt_attributes_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAinitrwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAinitrwgt_attributes_set" "', argument " "1"" of type '" "Pythia8::LHAinitrwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAinitrwgt * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAinitrwgt_attributes_set" "', argument " "2"" of type '" "std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > * >(argp2);
  if (arg1) (arg1)->attributes = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAinitrwgt_attributes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAinitrwgt *arg1 = (Pythia8::LHAinitrwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAinitrwgt_attributes_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAinitrwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAinitrwgt_attributes_get" "', argument " "1"" of type '" "Pythia8::LHAinitrwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAinitrwgt * >(argp1);
  result = (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *)& ((arg1)->attributes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAinitrwgt_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAinitrwgt *arg1 = (Pythia8::LHAinitrwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAinitrwgt_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAinitrwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAinitrwgt_size" "', argument " "1"" of type '" "Pythia8::LHAinitrwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAinitrwgt * >(argp1);
  result = (int)(arg1)->size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAinitrwgt_sizeWeightGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAinitrwgt *arg1 = (Pythia8::LHAinitrwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAinitrwgt_sizeWeightGroups",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAinitrwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAinitrwgt_sizeWeightGroups" "', argument " "1"" of type '" "Pythia8::LHAinitrwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAinitrwgt * >(argp1);
  result = (int)(arg1)->sizeWeightGroups();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAinitrwgt___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAinitrwgt *arg1 = (Pythia8::LHAinitrwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAinitrwgt___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAinitrwgt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAinitrwgt___str__" "', argument " "1"" of type '" "Pythia8::LHAinitrwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAinitrwgt * >(argp1);
  result = Pythia8_LHAinitrwgt___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LHAinitrwgt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAinitrwgt *arg1 = (Pythia8::LHAinitrwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LHAinitrwgt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAinitrwgt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LHAinitrwgt" "', argument " "1"" of type '" "Pythia8::LHAinitrwgt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAinitrwgt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LHAinitrwgt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__LHAinitrwgt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_HEPRUP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HEPRUP")) SWIG_fail;
  result = (Pythia8::HEPRUP *)new Pythia8::HEPRUP();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HEPRUP, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HEPRUP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HEPRUP",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HEPRUP" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPRUP_resize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_resize" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HEPRUP_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPRUP_resize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_resize" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  (arg1)->resize();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HEPRUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_HEPRUP_resize__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HEPRUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_HEPRUP_resize__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'HEPRUP_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::HEPRUP::resize(int)\n"
    "    Pythia8::HEPRUP::resize()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HEPRUP_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPRUP_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_clear" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_IDBMUP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  pair< long,long > *arg2 = (pair< long,long > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPRUP_IDBMUP_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_IDBMUP_set" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__pairT_long_long_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPRUP_IDBMUP_set" "', argument " "2"" of type '" "pair< long,long > *""'"); 
  }
  arg2 = reinterpret_cast< pair< long,long > * >(argp2);
  if (arg1) (arg1)->IDBMUP = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_IDBMUP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  pair< long,long > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPRUP_IDBMUP_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_IDBMUP_get" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  result = (pair< long,long > *)& ((arg1)->IDBMUP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_long_long_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_EBMUP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  pair< double,double > *arg2 = (pair< double,double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPRUP_EBMUP_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_EBMUP_set" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__pairT_double_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPRUP_EBMUP_set" "', argument " "2"" of type '" "pair< double,double > *""'"); 
  }
  arg2 = reinterpret_cast< pair< double,double > * >(argp2);
  if (arg1) (arg1)->EBMUP = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_EBMUP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  pair< double,double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPRUP_EBMUP_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_EBMUP_get" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  result = (pair< double,double > *)& ((arg1)->EBMUP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_double_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_PDFGUP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  pair< int,int > *arg2 = (pair< int,int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPRUP_PDFGUP_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_PDFGUP_set" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__pairT_int_int_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPRUP_PDFGUP_set" "', argument " "2"" of type '" "pair< int,int > *""'"); 
  }
  arg2 = reinterpret_cast< pair< int,int > * >(argp2);
  if (arg1) (arg1)->PDFGUP = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_PDFGUP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  pair< int,int > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPRUP_PDFGUP_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_PDFGUP_get" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  result = (pair< int,int > *)& ((arg1)->PDFGUP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_int_int_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_PDFSUP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  pair< int,int > *arg2 = (pair< int,int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPRUP_PDFSUP_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_PDFSUP_set" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__pairT_int_int_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPRUP_PDFSUP_set" "', argument " "2"" of type '" "pair< int,int > *""'"); 
  }
  arg2 = reinterpret_cast< pair< int,int > * >(argp2);
  if (arg1) (arg1)->PDFSUP = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_PDFSUP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  pair< int,int > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPRUP_PDFSUP_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_PDFSUP_get" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  result = (pair< int,int > *)& ((arg1)->PDFSUP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_int_int_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_IDWTUP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPRUP_IDWTUP_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_IDWTUP_set" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HEPRUP_IDWTUP_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->IDWTUP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_IDWTUP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPRUP_IDWTUP_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_IDWTUP_get" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  result = (int) ((arg1)->IDWTUP);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_NPRUP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPRUP_NPRUP_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_NPRUP_set" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HEPRUP_NPRUP_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->NPRUP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_NPRUP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPRUP_NPRUP_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_NPRUP_get" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  result = (int) ((arg1)->NPRUP);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_XSECUP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = (std::vector< double,std::allocator< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPRUP_XSECUP_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_XSECUP_set" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPRUP_XSECUP_set" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp2);
  if (arg1) (arg1)->XSECUP = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_XSECUP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPRUP_XSECUP_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_XSECUP_get" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  result = (std::vector< double,std::allocator< double > > *)& ((arg1)->XSECUP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_XERRUP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = (std::vector< double,std::allocator< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPRUP_XERRUP_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_XERRUP_set" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPRUP_XERRUP_set" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp2);
  if (arg1) (arg1)->XERRUP = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_XERRUP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPRUP_XERRUP_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_XERRUP_get" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  result = (std::vector< double,std::allocator< double > > *)& ((arg1)->XERRUP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_XMAXUP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = (std::vector< double,std::allocator< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPRUP_XMAXUP_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_XMAXUP_set" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPRUP_XMAXUP_set" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp2);
  if (arg1) (arg1)->XMAXUP = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_XMAXUP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPRUP_XMAXUP_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_XMAXUP_get" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  result = (std::vector< double,std::allocator< double > > *)& ((arg1)->XMAXUP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_LPRUP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = (std::vector< int,std::allocator< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPRUP_LPRUP_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_LPRUP_set" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPRUP_LPRUP_set" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  if (arg1) (arg1)->LPRUP = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_LPRUP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int,std::allocator< int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPRUP_LPRUP_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_LPRUP_get" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  result = (std::vector< int,std::allocator< int > > *)& ((arg1)->LPRUP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_initrwgt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  Pythia8::LHAinitrwgt *arg2 = (Pythia8::LHAinitrwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPRUP_initrwgt_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_initrwgt_set" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHAinitrwgt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPRUP_initrwgt_set" "', argument " "2"" of type '" "Pythia8::LHAinitrwgt *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHAinitrwgt * >(argp2);
  if (arg1) (arg1)->initrwgt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_initrwgt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHAinitrwgt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPRUP_initrwgt_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_initrwgt_get" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  result = (Pythia8::LHAinitrwgt *)& ((arg1)->initrwgt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAinitrwgt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_generators_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  std::vector< Pythia8::LHAgenerator,std::allocator< Pythia8::LHAgenerator > > *arg2 = (std::vector< Pythia8::LHAgenerator,std::allocator< Pythia8::LHAgenerator > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPRUP_generators_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_generators_set" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_Pythia8__LHAgenerator_std__allocatorT_Pythia8__LHAgenerator_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPRUP_generators_set" "', argument " "2"" of type '" "std::vector< Pythia8::LHAgenerator,std::allocator< Pythia8::LHAgenerator > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::LHAgenerator,std::allocator< Pythia8::LHAgenerator > > * >(argp2);
  if (arg1) (arg1)->generators = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_generators_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::LHAgenerator,std::allocator< Pythia8::LHAgenerator > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPRUP_generators_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_generators_get" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  result = (std::vector< Pythia8::LHAgenerator,std::allocator< Pythia8::LHAgenerator > > *)& ((arg1)->generators);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__LHAgenerator_std__allocatorT_Pythia8__LHAgenerator_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_weightgroups_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  std::map< std::string,Pythia8::LHAweightgroup,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweightgroup > > > *arg2 = (std::map< std::string,Pythia8::LHAweightgroup,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweightgroup > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPRUP_weightgroups_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_weightgroups_set" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAweightgroup_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweightgroup_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPRUP_weightgroups_set" "', argument " "2"" of type '" "std::map< std::string,Pythia8::LHAweightgroup,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweightgroup > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,Pythia8::LHAweightgroup,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweightgroup > > > * >(argp2);
  if (arg1) (arg1)->weightgroups = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_weightgroups_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::LHAweightgroup,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweightgroup > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPRUP_weightgroups_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_weightgroups_get" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  result = (std::map< std::string,Pythia8::LHAweightgroup,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweightgroup > > > *)& ((arg1)->weightgroups);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAweightgroup_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweightgroup_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_weights_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > *arg2 = (std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPRUP_weights_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_weights_set" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAweight_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweight_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPRUP_weights_set" "', argument " "2"" of type '" "std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > * >(argp2);
  if (arg1) (arg1)->weights = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPRUP_weights_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPRUP *arg1 = (Pythia8::HEPRUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPRUP_weights_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPRUP_weights_get" "', argument " "1"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPRUP * >(argp1);
  result = (std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > *)& ((arg1)->weights);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAweight_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweight_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HEPRUP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HEPRUP, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_HEPEUP__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HEPEUP")) SWIG_fail;
  result = (Pythia8::HEPEUP *)new Pythia8::HEPEUP();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HEPEUP, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HEPEUP__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::HEPEUP *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_HEPEUP",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__HEPEUP,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HEPEUP" "', argument " "1"" of type '" "Pythia8::HEPEUP const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HEPEUP" "', argument " "1"" of type '" "Pythia8::HEPEUP const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  result = (Pythia8::HEPEUP *)new Pythia8::HEPEUP((Pythia8::HEPEUP const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HEPEUP, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HEPEUP(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_HEPEUP__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__HEPEUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HEPEUP__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_HEPEUP'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::HEPEUP::HEPEUP()\n"
    "    Pythia8::HEPEUP::HEPEUP(Pythia8::HEPEUP const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HEPEUP_setEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  Pythia8::HEPEUP *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::HEPEUP *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPEUP_setEvent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_setEvent" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__HEPEUP,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPEUP_setEvent" "', argument " "2"" of type '" "Pythia8::HEPEUP const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HEPEUP_setEvent" "', argument " "2"" of type '" "Pythia8::HEPEUP const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::HEPEUP * >(argp2);
  result = (Pythia8::HEPEUP *) &(arg1)->setEvent((Pythia8::HEPEUP const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HEPEUP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HEPEUP",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HEPEUP" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPEUP_reset",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_reset" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  (arg1)->reset();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPEUP_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_clear" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPEUP_resize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_resize" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HEPEUP_resize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_weight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPEUP_weight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_weight" "', argument " "1"" of type '" "Pythia8::HEPEUP const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  result = (double)((Pythia8::HEPEUP const *)arg1)->weight();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPEUP_resize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_resize" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  (arg1)->resize();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HEPEUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_HEPEUP_resize__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HEPEUP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_HEPEUP_resize__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'HEPEUP_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::HEPEUP::resize(int)\n"
    "    Pythia8::HEPEUP::resize()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HEPEUP_NUP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPEUP_NUP_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_NUP_set" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HEPEUP_NUP_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->NUP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_NUP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPEUP_NUP_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_NUP_get" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  result = (int) ((arg1)->NUP);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_IDPRUP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPEUP_IDPRUP_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_IDPRUP_set" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HEPEUP_IDPRUP_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->IDPRUP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_IDPRUP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPEUP_IDPRUP_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_IDPRUP_get" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  result = (int) ((arg1)->IDPRUP);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_XWGTUP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPEUP_XWGTUP_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_XWGTUP_set" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HEPEUP_XWGTUP_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->XWGTUP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_XWGTUP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPEUP_XWGTUP_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_XWGTUP_get" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  result = (double) ((arg1)->XWGTUP);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_XPDWUP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  pair< double,double > *arg2 = (pair< double,double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPEUP_XPDWUP_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_XPDWUP_set" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__pairT_double_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPEUP_XPDWUP_set" "', argument " "2"" of type '" "pair< double,double > *""'"); 
  }
  arg2 = reinterpret_cast< pair< double,double > * >(argp2);
  if (arg1) (arg1)->XPDWUP = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_XPDWUP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  pair< double,double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPEUP_XPDWUP_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_XPDWUP_get" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  result = (pair< double,double > *)& ((arg1)->XPDWUP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_double_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_SCALUP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPEUP_SCALUP_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_SCALUP_set" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HEPEUP_SCALUP_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->SCALUP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_SCALUP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPEUP_SCALUP_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_SCALUP_get" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  result = (double) ((arg1)->SCALUP);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_AQEDUP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPEUP_AQEDUP_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_AQEDUP_set" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HEPEUP_AQEDUP_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->AQEDUP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_AQEDUP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPEUP_AQEDUP_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_AQEDUP_get" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  result = (double) ((arg1)->AQEDUP);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_AQCDUP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPEUP_AQCDUP_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_AQCDUP_set" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HEPEUP_AQCDUP_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->AQCDUP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_AQCDUP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPEUP_AQCDUP_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_AQCDUP_get" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  result = (double) ((arg1)->AQCDUP);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_IDUP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  std::vector< long,std::allocator< long > > *arg2 = (std::vector< long,std::allocator< long > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPEUP_IDUP_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_IDUP_set" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPEUP_IDUP_set" "', argument " "2"" of type '" "std::vector< long,std::allocator< long > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< long,std::allocator< long > > * >(argp2);
  if (arg1) (arg1)->IDUP = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_IDUP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< long,std::allocator< long > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPEUP_IDUP_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_IDUP_get" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  result = (std::vector< long,std::allocator< long > > *)& ((arg1)->IDUP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_ISTUP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = (std::vector< int,std::allocator< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPEUP_ISTUP_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_ISTUP_set" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPEUP_ISTUP_set" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  if (arg1) (arg1)->ISTUP = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_ISTUP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int,std::allocator< int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPEUP_ISTUP_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_ISTUP_get" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  result = (std::vector< int,std::allocator< int > > *)& ((arg1)->ISTUP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_MOTHUP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *arg2 = (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPEUP_MOTHUP_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_MOTHUP_set" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPEUP_MOTHUP_set" "', argument " "2"" of type '" "std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > * >(argp2);
  if (arg1) (arg1)->MOTHUP = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_MOTHUP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPEUP_MOTHUP_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_MOTHUP_get" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  result = (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *)& ((arg1)->MOTHUP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_ICOLUP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *arg2 = (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPEUP_ICOLUP_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_ICOLUP_set" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPEUP_ICOLUP_set" "', argument " "2"" of type '" "std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > * >(argp2);
  if (arg1) (arg1)->ICOLUP = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_ICOLUP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPEUP_ICOLUP_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_ICOLUP_get" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  result = (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *)& ((arg1)->ICOLUP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_PUP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg2 = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPEUP_PUP_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_PUP_set" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPEUP_PUP_set" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > * >(argp2);
  if (arg1) (arg1)->PUP = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_PUP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPEUP_PUP_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_PUP_get" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  result = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)& ((arg1)->PUP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_VTIMUP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = (std::vector< double,std::allocator< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPEUP_VTIMUP_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_VTIMUP_set" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPEUP_VTIMUP_set" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp2);
  if (arg1) (arg1)->VTIMUP = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_VTIMUP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPEUP_VTIMUP_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_VTIMUP_get" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  result = (std::vector< double,std::allocator< double > > *)& ((arg1)->VTIMUP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_SPINUP_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = (std::vector< double,std::allocator< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPEUP_SPINUP_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_SPINUP_set" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPEUP_SPINUP_set" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp2);
  if (arg1) (arg1)->SPINUP = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_SPINUP_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPEUP_SPINUP_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_SPINUP_get" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  result = (std::vector< double,std::allocator< double > > *)& ((arg1)->SPINUP);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_heprup_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  Pythia8::HEPRUP *arg2 = (Pythia8::HEPRUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPEUP_heprup_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_heprup_set" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__HEPRUP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPEUP_heprup_set" "', argument " "2"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::HEPRUP * >(argp2);
  if (arg1) (arg1)->heprup = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_heprup_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::HEPRUP *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPEUP_heprup_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_heprup_get" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  result = (Pythia8::HEPRUP *) ((arg1)->heprup);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_weights_detailed_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > *arg2 = (std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPEUP_weights_detailed_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_weights_detailed_set" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPEUP_weights_detailed_set" "', argument " "2"" of type '" "std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > * >(argp2);
  if (arg1) (arg1)->weights_detailed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_weights_detailed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPEUP_weights_detailed_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_weights_detailed_get" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  result = (std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > *)& ((arg1)->weights_detailed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_weights_compressed_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = (std::vector< double,std::allocator< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPEUP_weights_compressed_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_weights_compressed_set" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPEUP_weights_compressed_set" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp2);
  if (arg1) (arg1)->weights_compressed = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_weights_compressed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPEUP_weights_compressed_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_weights_compressed_get" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  result = (std::vector< double,std::allocator< double > > *)& ((arg1)->weights_compressed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_scalesSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  Pythia8::LHAscales *arg2 = (Pythia8::LHAscales *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPEUP_scalesSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_scalesSave_set" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHAscales, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPEUP_scalesSave_set" "', argument " "2"" of type '" "Pythia8::LHAscales *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHAscales * >(argp2);
  if (arg1) (arg1)->scalesSave = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_scalesSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHAscales *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPEUP_scalesSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_scalesSave_get" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  result = (Pythia8::LHAscales *)& ((arg1)->scalesSave);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAscales, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_weightsSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  Pythia8::LHAweights *arg2 = (Pythia8::LHAweights *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPEUP_weightsSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_weightsSave_set" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHAweights, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPEUP_weightsSave_set" "', argument " "2"" of type '" "Pythia8::LHAweights *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHAweights * >(argp2);
  if (arg1) (arg1)->weightsSave = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_weightsSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHAweights *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPEUP_weightsSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_weightsSave_get" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  result = (Pythia8::LHAweights *)& ((arg1)->weightsSave);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAweights, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_rwgtSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  Pythia8::LHArwgt *arg2 = (Pythia8::LHArwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPEUP_rwgtSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_rwgtSave_set" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHArwgt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPEUP_rwgtSave_set" "', argument " "2"" of type '" "Pythia8::LHArwgt *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHArwgt * >(argp2);
  if (arg1) (arg1)->rwgtSave = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_rwgtSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHArwgt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPEUP_rwgtSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_rwgtSave_get" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  result = (Pythia8::LHArwgt *)& ((arg1)->rwgtSave);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHArwgt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_attributes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *arg2 = (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HEPEUP_attributes_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_attributes_set" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HEPEUP_attributes_set" "', argument " "2"" of type '" "std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > * >(argp2);
  if (arg1) (arg1)->attributes = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HEPEUP_attributes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HEPEUP *arg1 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HEPEUP_attributes_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HEPEUP_attributes_get" "', argument " "1"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HEPEUP * >(argp1);
  result = (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *)& ((arg1)->attributes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HEPEUP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HEPEUP, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Reader__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  Pythia8::Reader *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Reader",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Reader" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::Reader *)new Pythia8::Reader(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Reader, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Reader__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  istream *arg1 = (istream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Reader *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Reader",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Reader" "', argument " "1"" of type '" "istream *""'"); 
  }
  arg1 = reinterpret_cast< istream * >(argp1);
  result = (Pythia8::Reader *)new Pythia8::Reader(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Reader, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Reader(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Reader__SWIG_1(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Reader__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Reader'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Reader::Reader(std::string)\n"
    "    Pythia8::Reader::Reader(istream *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Reader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Reader *arg1 = (Pythia8::Reader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Reader",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Reader, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Reader" "', argument " "1"" of type '" "Pythia8::Reader *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Reader * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reader_setup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Reader *arg1 = (Pythia8::Reader *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Reader_setup",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Reader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reader_setup" "', argument " "1"" of type '" "Pythia8::Reader *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Reader * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Reader_setup" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->setup(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reader_readEvent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Reader *arg1 = (Pythia8::Reader *) 0 ;
  Pythia8::HEPEUP *arg2 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Reader_readEvent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Reader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reader_readEvent" "', argument " "1"" of type '" "Pythia8::Reader *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Reader * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reader_readEvent" "', argument " "2"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::HEPEUP * >(argp2);
  result = (bool)(arg1)->readEvent(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reader_readEvent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Reader *arg1 = (Pythia8::Reader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Reader_readEvent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Reader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reader_readEvent" "', argument " "1"" of type '" "Pythia8::Reader *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Reader * >(argp1);
  result = (bool)(arg1)->readEvent();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reader_readEvent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Reader, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Reader_readEvent__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Reader, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__HEPEUP, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Reader_readEvent__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Reader_readEvent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Reader::readEvent(Pythia8::HEPEUP *)\n"
    "    Pythia8::Reader::readEvent()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Reader_clearEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Reader *arg1 = (Pythia8::Reader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Reader_clearEvent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Reader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reader_clearEvent" "', argument " "1"" of type '" "Pythia8::Reader *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Reader * >(argp1);
  (arg1)->clearEvent();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reader_isGood_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Reader *arg1 = (Pythia8::Reader *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Reader_isGood_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Reader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reader_isGood_set" "', argument " "1"" of type '" "Pythia8::Reader *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Reader * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Reader_isGood_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isGood = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reader_isGood_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Reader *arg1 = (Pythia8::Reader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Reader_isGood_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Reader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reader_isGood_get" "', argument " "1"" of type '" "Pythia8::Reader *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Reader * >(argp1);
  result = (bool) ((arg1)->isGood);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reader_version_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Reader *arg1 = (Pythia8::Reader *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Reader_version_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Reader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reader_version_set" "', argument " "1"" of type '" "Pythia8::Reader *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Reader * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Reader_version_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reader_version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Reader *arg1 = (Pythia8::Reader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Reader_version_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Reader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reader_version_get" "', argument " "1"" of type '" "Pythia8::Reader *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Reader * >(argp1);
  result = (int) ((arg1)->version);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reader_outsideBlock_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Reader *arg1 = (Pythia8::Reader *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Reader_outsideBlock_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Reader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reader_outsideBlock_set" "', argument " "1"" of type '" "Pythia8::Reader *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Reader * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reader_outsideBlock_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Reader_outsideBlock_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->outsideBlock = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reader_outsideBlock_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Reader *arg1 = (Pythia8::Reader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Reader_outsideBlock_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Reader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reader_outsideBlock_get" "', argument " "1"" of type '" "Pythia8::Reader *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Reader * >(argp1);
  result = (std::string *) & ((arg1)->outsideBlock);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reader_headerBlock_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Reader *arg1 = (Pythia8::Reader *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Reader_headerBlock_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Reader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reader_headerBlock_set" "', argument " "1"" of type '" "Pythia8::Reader *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Reader * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reader_headerBlock_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Reader_headerBlock_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->headerBlock = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reader_headerBlock_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Reader *arg1 = (Pythia8::Reader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Reader_headerBlock_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Reader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reader_headerBlock_get" "', argument " "1"" of type '" "Pythia8::Reader *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Reader * >(argp1);
  result = (std::string *) & ((arg1)->headerBlock);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reader_headerComments_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Reader *arg1 = (Pythia8::Reader *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Reader_headerComments_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Reader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reader_headerComments_set" "', argument " "1"" of type '" "Pythia8::Reader *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Reader * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reader_headerComments_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Reader_headerComments_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->headerComments = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reader_headerComments_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Reader *arg1 = (Pythia8::Reader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Reader_headerComments_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Reader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reader_headerComments_get" "', argument " "1"" of type '" "Pythia8::Reader *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Reader * >(argp1);
  result = (std::string *) & ((arg1)->headerComments);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reader_heprup_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Reader *arg1 = (Pythia8::Reader *) 0 ;
  Pythia8::HEPRUP *arg2 = (Pythia8::HEPRUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Reader_heprup_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Reader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reader_heprup_set" "', argument " "1"" of type '" "Pythia8::Reader *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Reader * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reader_heprup_set" "', argument " "2"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::HEPRUP * >(argp2);
  if (arg1) (arg1)->heprup = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reader_heprup_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Reader *arg1 = (Pythia8::Reader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::HEPRUP *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Reader_heprup_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Reader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reader_heprup_get" "', argument " "1"" of type '" "Pythia8::Reader *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Reader * >(argp1);
  result = (Pythia8::HEPRUP *)& ((arg1)->heprup);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reader_initComments_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Reader *arg1 = (Pythia8::Reader *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Reader_initComments_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Reader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reader_initComments_set" "', argument " "1"" of type '" "Pythia8::Reader *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Reader * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reader_initComments_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Reader_initComments_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->initComments = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reader_initComments_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Reader *arg1 = (Pythia8::Reader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Reader_initComments_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Reader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reader_initComments_get" "', argument " "1"" of type '" "Pythia8::Reader *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Reader * >(argp1);
  result = (std::string *) & ((arg1)->initComments);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reader_hepeup_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Reader *arg1 = (Pythia8::Reader *) 0 ;
  Pythia8::HEPEUP *arg2 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Reader_hepeup_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Reader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reader_hepeup_set" "', argument " "1"" of type '" "Pythia8::Reader *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Reader * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reader_hepeup_set" "', argument " "2"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::HEPEUP * >(argp2);
  if (arg1) (arg1)->hepeup = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reader_hepeup_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Reader *arg1 = (Pythia8::Reader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::HEPEUP *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Reader_hepeup_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Reader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reader_hepeup_get" "', argument " "1"" of type '" "Pythia8::Reader *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Reader * >(argp1);
  result = (Pythia8::HEPEUP *)& ((arg1)->hepeup);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reader_eventComments_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Reader *arg1 = (Pythia8::Reader *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Reader_eventComments_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Reader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reader_eventComments_set" "', argument " "1"" of type '" "Pythia8::Reader *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Reader * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reader_eventComments_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Reader_eventComments_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->eventComments = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reader_eventComments_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Reader *arg1 = (Pythia8::Reader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Reader_eventComments_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Reader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reader_eventComments_get" "', argument " "1"" of type '" "Pythia8::Reader *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Reader * >(argp1);
  result = (std::string *) & ((arg1)->eventComments);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reader_weights_detailed_vec_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Reader *arg1 = (Pythia8::Reader *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = (std::vector< double,std::allocator< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Reader_weights_detailed_vec_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Reader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reader_weights_detailed_vec_set" "', argument " "1"" of type '" "Pythia8::Reader *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Reader * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Reader_weights_detailed_vec_set" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp2);
  if (arg1) (arg1)->weights_detailed_vec = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Reader_weights_detailed_vec_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Reader *arg1 = (Pythia8::Reader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Reader_weights_detailed_vec_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Reader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Reader_weights_detailed_vec_get" "', argument " "1"" of type '" "Pythia8::Reader *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Reader * >(argp1);
  result = (std::vector< double,std::allocator< double > > *)& ((arg1)->weights_detailed_vec);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Reader_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Reader, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Writer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Writer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Writer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Writer" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Writer" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  result = (Pythia8::Writer *)new Pythia8::Writer(*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Writer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Writer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  Pythia8::Writer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Writer",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Writer" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::Writer *)new Pythia8::Writer(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Writer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Writer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Writer__SWIG_0(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Writer__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Writer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Writer::Writer(std::ostream &)\n"
    "    Pythia8::Writer::Writer(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Writer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Writer *arg1 = (Pythia8::Writer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Writer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Writer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Writer" "', argument " "1"" of type '" "Pythia8::Writer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Writer * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Writer_headerBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Writer *arg1 = (Pythia8::Writer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::ostream *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Writer_headerBlock",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Writer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Writer_headerBlock" "', argument " "1"" of type '" "Pythia8::Writer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Writer * >(argp1);
  result = (std::ostream *) &(arg1)->headerBlock();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Writer_initComments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Writer *arg1 = (Pythia8::Writer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::ostream *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Writer_initComments",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Writer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Writer_initComments" "', argument " "1"" of type '" "Pythia8::Writer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Writer * >(argp1);
  result = (std::ostream *) &(arg1)->initComments();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Writer_eventComments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Writer *arg1 = (Pythia8::Writer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::ostream *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Writer_eventComments",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Writer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Writer_eventComments" "', argument " "1"" of type '" "Pythia8::Writer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Writer * >(argp1);
  result = (std::ostream *) &(arg1)->eventComments();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Writer_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Writer *arg1 = (Pythia8::Writer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Writer_init",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Writer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Writer_init" "', argument " "1"" of type '" "Pythia8::Writer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Writer * >(argp1);
  (arg1)->init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Writer_writeEvent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Writer *arg1 = (Pythia8::Writer *) 0 ;
  Pythia8::HEPEUP *arg2 = (Pythia8::HEPEUP *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Writer_writeEvent",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Writer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Writer_writeEvent" "', argument " "1"" of type '" "Pythia8::Writer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Writer * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Writer_writeEvent" "', argument " "2"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::HEPEUP * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Writer_writeEvent" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (bool)(arg1)->writeEvent(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Writer_writeEvent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Writer *arg1 = (Pythia8::Writer *) 0 ;
  Pythia8::HEPEUP *arg2 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Writer_writeEvent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Writer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Writer_writeEvent" "', argument " "1"" of type '" "Pythia8::Writer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Writer * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Writer_writeEvent" "', argument " "2"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::HEPEUP * >(argp2);
  result = (bool)(arg1)->writeEvent(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Writer_writeEvent__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Writer *arg1 = (Pythia8::Writer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Writer_writeEvent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Writer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Writer_writeEvent" "', argument " "1"" of type '" "Pythia8::Writer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Writer * >(argp1);
  result = (bool)(arg1)->writeEvent();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Writer_writeEvent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Writer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Writer_writeEvent__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Writer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__HEPEUP, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Writer_writeEvent__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Writer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__HEPEUP, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Writer_writeEvent__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Writer_writeEvent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Writer::writeEvent(Pythia8::HEPEUP *,int)\n"
    "    Pythia8::Writer::writeEvent(Pythia8::HEPEUP *)\n"
    "    Pythia8::Writer::writeEvent()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Writer_getEventString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Writer *arg1 = (Pythia8::Writer *) 0 ;
  Pythia8::HEPEUP *arg2 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Writer_getEventString",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Writer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Writer_getEventString" "', argument " "1"" of type '" "Pythia8::Writer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Writer * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Writer_getEventString" "', argument " "2"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::HEPEUP * >(argp2);
  result = (arg1)->getEventString(arg2);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Writer_getEventString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Writer *arg1 = (Pythia8::Writer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Writer_getEventString",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Writer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Writer_getEventString" "', argument " "1"" of type '" "Pythia8::Writer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Writer * >(argp1);
  result = (arg1)->getEventString();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Writer_getEventString(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Writer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Writer_getEventString__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Writer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__HEPEUP, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Writer_getEventString__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Writer_getEventString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Writer::getEventString(Pythia8::HEPEUP *)\n"
    "    Pythia8::Writer::getEventString()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Writer_heprup_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Writer *arg1 = (Pythia8::Writer *) 0 ;
  Pythia8::HEPRUP *arg2 = (Pythia8::HEPRUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Writer_heprup_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Writer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Writer_heprup_set" "', argument " "1"" of type '" "Pythia8::Writer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Writer * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Writer_heprup_set" "', argument " "2"" of type '" "Pythia8::HEPRUP *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::HEPRUP * >(argp2);
  if (arg1) (arg1)->heprup = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Writer_heprup_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Writer *arg1 = (Pythia8::Writer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::HEPRUP *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Writer_heprup_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Writer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Writer_heprup_get" "', argument " "1"" of type '" "Pythia8::Writer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Writer * >(argp1);
  result = (Pythia8::HEPRUP *)& ((arg1)->heprup);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HEPRUP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Writer_hepeup_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Writer *arg1 = (Pythia8::Writer *) 0 ;
  Pythia8::HEPEUP *arg2 = (Pythia8::HEPEUP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Writer_hepeup_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Writer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Writer_hepeup_set" "', argument " "1"" of type '" "Pythia8::Writer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Writer * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Writer_hepeup_set" "', argument " "2"" of type '" "Pythia8::HEPEUP *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::HEPEUP * >(argp2);
  if (arg1) (arg1)->hepeup = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Writer_hepeup_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Writer *arg1 = (Pythia8::Writer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::HEPEUP *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Writer_hepeup_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Writer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Writer_hepeup_get" "', argument " "1"" of type '" "Pythia8::Writer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Writer * >(argp1);
  result = (Pythia8::HEPEUP *)& ((arg1)->hepeup);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HEPEUP, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Writer_version_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Writer *arg1 = (Pythia8::Writer *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Writer_version_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Writer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Writer_version_set" "', argument " "1"" of type '" "Pythia8::Writer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Writer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Writer_version_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->version = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Writer_version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Writer *arg1 = (Pythia8::Writer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Writer_version_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Writer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Writer_version_get" "', argument " "1"" of type '" "Pythia8::Writer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Writer * >(argp1);
  result = (int) ((arg1)->version);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Writer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Writer, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PartonSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystem *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PartonSystem")) SWIG_fail;
  result = (Pythia8::PartonSystem *)new Pythia8::PartonSystem();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PartonSystem, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystem_iInA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystem *arg1 = (Pythia8::PartonSystem *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PartonSystem_iInA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystem_iInA_set" "', argument " "1"" of type '" "Pythia8::PartonSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonSystem_iInA_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iInA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystem_iInA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystem *arg1 = (Pythia8::PartonSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PartonSystem_iInA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystem_iInA_get" "', argument " "1"" of type '" "Pythia8::PartonSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystem * >(argp1);
  result = (int) ((arg1)->iInA);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystem_iInB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystem *arg1 = (Pythia8::PartonSystem *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PartonSystem_iInB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystem_iInB_set" "', argument " "1"" of type '" "Pythia8::PartonSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonSystem_iInB_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iInB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystem_iInB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystem *arg1 = (Pythia8::PartonSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PartonSystem_iInB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystem_iInB_get" "', argument " "1"" of type '" "Pythia8::PartonSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystem * >(argp1);
  result = (int) ((arg1)->iInB);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystem_iOut_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystem *arg1 = (Pythia8::PartonSystem *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = (std::vector< int,std::allocator< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PartonSystem_iOut_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystem_iOut_set" "', argument " "1"" of type '" "Pythia8::PartonSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystem * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PartonSystem_iOut_set" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  if (arg1) (arg1)->iOut = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystem_iOut_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystem *arg1 = (Pythia8::PartonSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int,std::allocator< int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PartonSystem_iOut_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystem_iOut_get" "', argument " "1"" of type '" "Pythia8::PartonSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystem * >(argp1);
  result = (std::vector< int,std::allocator< int > > *)& ((arg1)->iOut);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystem_sHat_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystem *arg1 = (Pythia8::PartonSystem *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PartonSystem_sHat_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystem_sHat_set" "', argument " "1"" of type '" "Pythia8::PartonSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystem * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonSystem_sHat_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->sHat = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystem_sHat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystem *arg1 = (Pythia8::PartonSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PartonSystem_sHat_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystem_sHat_get" "', argument " "1"" of type '" "Pythia8::PartonSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystem * >(argp1);
  result = (double) ((arg1)->sHat);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystem_pTHat_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystem *arg1 = (Pythia8::PartonSystem *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PartonSystem_pTHat_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystem_pTHat_set" "', argument " "1"" of type '" "Pythia8::PartonSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystem * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonSystem_pTHat_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pTHat = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystem_pTHat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystem *arg1 = (Pythia8::PartonSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PartonSystem_pTHat_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystem_pTHat_get" "', argument " "1"" of type '" "Pythia8::PartonSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystem * >(argp1);
  result = (double) ((arg1)->pTHat);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PartonSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystem *arg1 = (Pythia8::PartonSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PartonSystem",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystem, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PartonSystem" "', argument " "1"" of type '" "Pythia8::PartonSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystem * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PartonSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__PartonSystem, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PartonSystems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PartonSystems")) SWIG_fail;
  result = (Pythia8::PartonSystems *)new Pythia8::PartonSystems();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PartonSystems, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PartonSystems_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems_clear" "', argument " "1"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems_addSys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PartonSystems_addSys",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems_addSys" "', argument " "1"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  result = (int)(arg1)->addSys();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems_sizeSys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PartonSystems_sizeSys",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems_sizeSys" "', argument " "1"" of type '" "Pythia8::PartonSystems const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  result = (int)((Pythia8::PartonSystems const *)arg1)->sizeSys();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems_setInA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PartonSystems_setInA",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems_setInA" "', argument " "1"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonSystems_setInA" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PartonSystems_setInA" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->setInA(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems_setInB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PartonSystems_setInB",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems_setInB" "', argument " "1"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonSystems_setInB" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PartonSystems_setInB" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->setInB(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems_addOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PartonSystems_addOut",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems_addOut" "', argument " "1"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonSystems_addOut" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PartonSystems_addOut" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->addOut(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems_popBackOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PartonSystems_popBackOut",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems_popBackOut" "', argument " "1"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonSystems_popBackOut" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->popBackOut(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems_setOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:PartonSystems_setOut",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems_setOut" "', argument " "1"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonSystems_setOut" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PartonSystems_setOut" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PartonSystems_setOut" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->setOut(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems_replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:PartonSystems_replace",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems_replace" "', argument " "1"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonSystems_replace" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PartonSystems_replace" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PartonSystems_replace" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->replace(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems_setSHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PartonSystems_setSHat",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems_setSHat" "', argument " "1"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonSystems_setSHat" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PartonSystems_setSHat" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->setSHat(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems_setPTHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PartonSystems_setPTHat",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems_setPTHat" "', argument " "1"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonSystems_setPTHat" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PartonSystems_setPTHat" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->setPTHat(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems_setSizeSys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PartonSystems_setSizeSys",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems_setSizeSys" "', argument " "1"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonSystems_setSizeSys" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setSizeSys(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems_hasInAB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PartonSystems_hasInAB",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems_hasInAB" "', argument " "1"" of type '" "Pythia8::PartonSystems const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonSystems_hasInAB" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)((Pythia8::PartonSystems const *)arg1)->hasInAB(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems_getInA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PartonSystems_getInA",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems_getInA" "', argument " "1"" of type '" "Pythia8::PartonSystems const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonSystems_getInA" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::PartonSystems const *)arg1)->getInA(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems_getInB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PartonSystems_getInB",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems_getInB" "', argument " "1"" of type '" "Pythia8::PartonSystems const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonSystems_getInB" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::PartonSystems const *)arg1)->getInB(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems_sizeOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PartonSystems_sizeOut",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems_sizeOut" "', argument " "1"" of type '" "Pythia8::PartonSystems const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonSystems_sizeOut" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::PartonSystems const *)arg1)->sizeOut(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems_getOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PartonSystems_getOut",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems_getOut" "', argument " "1"" of type '" "Pythia8::PartonSystems const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonSystems_getOut" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PartonSystems_getOut" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)((Pythia8::PartonSystems const *)arg1)->getOut(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems_sizeAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PartonSystems_sizeAll",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems_sizeAll" "', argument " "1"" of type '" "Pythia8::PartonSystems const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonSystems_sizeAll" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::PartonSystems const *)arg1)->sizeAll(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems_getAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PartonSystems_getAll",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems_getAll" "', argument " "1"" of type '" "Pythia8::PartonSystems const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonSystems_getAll" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PartonSystems_getAll" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)((Pythia8::PartonSystems const *)arg1)->getAll(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems_getSHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PartonSystems_getSHat",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems_getSHat" "', argument " "1"" of type '" "Pythia8::PartonSystems const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonSystems_getSHat" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::PartonSystems const *)arg1)->getSHat(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems_getPTHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PartonSystems_getPTHat",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems_getPTHat" "', argument " "1"" of type '" "Pythia8::PartonSystems const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonSystems_getPTHat" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::PartonSystems const *)arg1)->getPTHat(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems_getSystemOf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  int arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PartonSystems_getSystemOf",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems_getSystemOf" "', argument " "1"" of type '" "Pythia8::PartonSystems const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonSystems_getSystemOf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PartonSystems_getSystemOf" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (int)((Pythia8::PartonSystems const *)arg1)->getSystemOf(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems_getSystemOf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PartonSystems_getSystemOf",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems_getSystemOf" "', argument " "1"" of type '" "Pythia8::PartonSystems const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonSystems_getSystemOf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::PartonSystems const *)arg1)->getSystemOf(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems_getSystemOf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PartonSystems, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PartonSystems_getSystemOf__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PartonSystems, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_PartonSystems_getSystemOf__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PartonSystems_getSystemOf'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PartonSystems::getSystemOf(int,bool) const\n"
    "    Pythia8::PartonSystems::getSystemOf(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PartonSystems_getIndexOfOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PartonSystems_getIndexOfOut",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems_getIndexOfOut" "', argument " "1"" of type '" "Pythia8::PartonSystems const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonSystems_getIndexOfOut" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PartonSystems_getIndexOfOut" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)((Pythia8::PartonSystems const *)arg1)->getIndexOfOut(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems_popBack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PartonSystems_popBack",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems_popBack" "', argument " "1"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  (arg1)->popBack();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonSystems___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PartonSystems___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonSystems___str__" "', argument " "1"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  result = Pythia8_PartonSystems___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PartonSystems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonSystems *arg1 = (Pythia8::PartonSystems *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PartonSystems",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonSystems, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PartonSystems" "', argument " "1"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonSystems * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PartonSystems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__PartonSystems, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ProgressLog__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  long arg1 ;
  int arg2 ;
  long val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::ProgressLog *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_ProgressLog",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_long(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProgressLog" "', argument " "1"" of type '" "long""'");
  } 
  arg1 = static_cast< long >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProgressLog" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::ProgressLog *)new Pythia8::ProgressLog(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ProgressLog, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProgressLog__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  long arg1 ;
  long val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ProgressLog *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ProgressLog",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_long(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProgressLog" "', argument " "1"" of type '" "long""'");
  } 
  arg1 = static_cast< long >(val1);
  result = (Pythia8::ProgressLog *)new Pythia8::ProgressLog(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ProgressLog, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProgressLog(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_long(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ProgressLog__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_long(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ProgressLog__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ProgressLog'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ProgressLog::ProgressLog(long,int)\n"
    "    Pythia8::ProgressLog::ProgressLog(long)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ProgressLog___call____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProgressLog *arg1 = (Pythia8::ProgressLog *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProgressLog___call__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProgressLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProgressLog___call__" "', argument " "1"" of type '" "Pythia8::ProgressLog *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProgressLog * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProgressLog___call__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->operator ()(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProgressLog___call____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProgressLog *arg1 = (Pythia8::ProgressLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProgressLog___call__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProgressLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProgressLog___call__" "', argument " "1"" of type '" "Pythia8::ProgressLog *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProgressLog * >(argp1);
  (arg1)->operator ()();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProgressLog___call__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ProgressLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ProgressLog___call____SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ProgressLog, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ProgressLog___call____SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ProgressLog___call__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ProgressLog::operator ()(int)\n"
    "    Pythia8::ProgressLog::operator ()()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ProgressLog_tick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProgressLog *arg1 = (Pythia8::ProgressLog *) 0 ;
  long arg2 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ProgressLog_tick",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProgressLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProgressLog_tick" "', argument " "1"" of type '" "Pythia8::ProgressLog *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProgressLog * >(argp1);
  ecode2 = SWIG_AsVal_long(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProgressLog_tick" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ProgressLog_tick" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  (arg1)->tick(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProgressLog_fclock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProgressLog *arg1 = (Pythia8::ProgressLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProgressLog_fclock",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProgressLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProgressLog_fclock" "', argument " "1"" of type '" "Pythia8::ProgressLog *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProgressLog * >(argp1);
  result = (double)(arg1)->fclock();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProgressLog_statusTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProgressLog *arg1 = (Pythia8::ProgressLog *) 0 ;
  long arg2 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ProgressLog_statusTime",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProgressLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProgressLog_statusTime" "', argument " "1"" of type '" "Pythia8::ProgressLog const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProgressLog * >(argp1);
  ecode2 = SWIG_AsVal_long(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProgressLog_statusTime" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ProgressLog_statusTime" "', argument " "3"" of type '" "long""'");
  } 
  arg3 = static_cast< long >(val3);
  result = (bool)((Pythia8::ProgressLog const *)arg1)->statusTime(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProgressLog_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProgressLog *arg1 = (Pythia8::ProgressLog *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProgressLog_init",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProgressLog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProgressLog_init" "', argument " "1"" of type '" "Pythia8::ProgressLog *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProgressLog * >(argp1);
  ecode2 = SWIG_AsVal_long(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProgressLog_init" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ProgressLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProgressLog *arg1 = (Pythia8::ProgressLog *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ProgressLog",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProgressLog, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ProgressLog" "', argument " "1"" of type '" "Pythia8::ProgressLog *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProgressLog * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ProgressLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ProgressLog, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DummyForStreams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DummyForStreams *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DummyForStreams")) SWIG_fail;
  result = (Pythia8::DummyForStreams *)new Pythia8::DummyForStreams();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__DummyForStreams, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DummyForStreams_xtox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DummyForStreams *arg1 = (Pythia8::DummyForStreams *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:DummyForStreams_xtox",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DummyForStreams, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DummyForStreams_xtox" "', argument " "1"" of type '" "Pythia8::DummyForStreams *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DummyForStreams * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DummyForStreams_xtox" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->xtox(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DummyForStreams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DummyForStreams *arg1 = (Pythia8::DummyForStreams *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DummyForStreams",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DummyForStreams, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DummyForStreams" "', argument " "1"" of type '" "Pythia8::DummyForStreams *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DummyForStreams * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DummyForStreams_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__DummyForStreams, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LHgenericBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHgenericBlock *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LHgenericBlock")) SWIG_fail;
  result = (Pythia8::LHgenericBlock *)new Pythia8::LHgenericBlock();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHgenericBlock, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LHgenericBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHgenericBlock *arg1 = (Pythia8::LHgenericBlock *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LHgenericBlock",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHgenericBlock, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LHgenericBlock" "', argument " "1"" of type '" "Pythia8::LHgenericBlock *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHgenericBlock * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LHgenericBlock_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__LHgenericBlock, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LHdecayChannel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHdecayChannel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LHdecayChannel")) SWIG_fail;
  result = (Pythia8::LHdecayChannel *)new Pythia8::LHdecayChannel();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHdecayChannel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHdecayChannel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  int arg2 ;
  std::vector< int,std::allocator< int > > arg3 ;
  std::string arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::LHdecayChannel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_LHdecayChannel",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LHdecayChannel" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LHdecayChannel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_LHdecayChannel" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_LHdecayChannel" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::LHdecayChannel *)new Pythia8::LHdecayChannel(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHdecayChannel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHdecayChannel__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  int arg2 ;
  std::vector< int,std::allocator< int > > arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::LHdecayChannel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_LHdecayChannel",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LHdecayChannel" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LHdecayChannel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_LHdecayChannel" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::LHdecayChannel *)new Pythia8::LHdecayChannel(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHdecayChannel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHdecayChannel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_LHdecayChannel__SWIG_0(self, args);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< int,std::allocator< int > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_LHdecayChannel__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< int,std::allocator< int > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_LHdecayChannel__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LHdecayChannel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHdecayChannel::LHdecayChannel()\n"
    "    Pythia8::LHdecayChannel::LHdecayChannel(double,int,std::vector< int,std::allocator< int > >,std::string)\n"
    "    Pythia8::LHdecayChannel::LHdecayChannel(double,int,std::vector< int,std::allocator< int > >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHdecayChannel_setChannel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHdecayChannel *arg1 = (Pythia8::LHdecayChannel *) 0 ;
  double arg2 ;
  int arg3 ;
  std::vector< int,std::allocator< int > > arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:LHdecayChannel_setChannel",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHdecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHdecayChannel_setChannel" "', argument " "1"" of type '" "Pythia8::LHdecayChannel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHdecayChannel * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHdecayChannel_setChannel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHdecayChannel_setChannel" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LHdecayChannel_setChannel" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LHdecayChannel_setChannel" "', argument " "5"" of type '" "std::string""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->setChannel(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHdecayChannel_setChannel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHdecayChannel *arg1 = (Pythia8::LHdecayChannel *) 0 ;
  double arg2 ;
  int arg3 ;
  std::vector< int,std::allocator< int > > arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:LHdecayChannel_setChannel",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHdecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHdecayChannel_setChannel" "', argument " "1"" of type '" "Pythia8::LHdecayChannel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHdecayChannel * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHdecayChannel_setChannel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHdecayChannel_setChannel" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LHdecayChannel_setChannel" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->setChannel(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHdecayChannel_setChannel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHdecayChannel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< int,std::allocator< int > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_LHdecayChannel_setChannel__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHdecayChannel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< int,std::allocator< int > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_LHdecayChannel_setChannel__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LHdecayChannel_setChannel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHdecayChannel::setChannel(double,int,std::vector< int,std::allocator< int > >,std::string)\n"
    "    Pythia8::LHdecayChannel::setChannel(double,int,std::vector< int,std::allocator< int > >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHdecayChannel_setBrat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHdecayChannel *arg1 = (Pythia8::LHdecayChannel *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHdecayChannel_setBrat",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHdecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHdecayChannel_setBrat" "', argument " "1"" of type '" "Pythia8::LHdecayChannel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHdecayChannel * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHdecayChannel_setBrat" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setBrat(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHdecayChannel_setIdDa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHdecayChannel *arg1 = (Pythia8::LHdecayChannel *) 0 ;
  std::vector< int,std::allocator< int > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHdecayChannel_setIdDa",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHdecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHdecayChannel_setIdDa" "', argument " "1"" of type '" "Pythia8::LHdecayChannel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHdecayChannel * >(argp1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LHdecayChannel_setIdDa" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->setIdDa(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHdecayChannel_getBrat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHdecayChannel *arg1 = (Pythia8::LHdecayChannel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHdecayChannel_getBrat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHdecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHdecayChannel_getBrat" "', argument " "1"" of type '" "Pythia8::LHdecayChannel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHdecayChannel * >(argp1);
  result = (double)(arg1)->getBrat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHdecayChannel_getNDa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHdecayChannel *arg1 = (Pythia8::LHdecayChannel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHdecayChannel_getNDa",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHdecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHdecayChannel_getNDa" "', argument " "1"" of type '" "Pythia8::LHdecayChannel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHdecayChannel * >(argp1);
  result = (int)(arg1)->getNDa();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHdecayChannel_getIdDa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHdecayChannel *arg1 = (Pythia8::LHdecayChannel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int,std::allocator< int > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHdecayChannel_getIdDa",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHdecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHdecayChannel_getIdDa" "', argument " "1"" of type '" "Pythia8::LHdecayChannel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHdecayChannel * >(argp1);
  result = (arg1)->getIdDa();
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHdecayChannel_getComment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHdecayChannel *arg1 = (Pythia8::LHdecayChannel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHdecayChannel_getComment",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHdecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHdecayChannel_getComment" "', argument " "1"" of type '" "Pythia8::LHdecayChannel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHdecayChannel * >(argp1);
  result = (arg1)->getComment();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LHdecayChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHdecayChannel *arg1 = (Pythia8::LHdecayChannel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LHdecayChannel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHdecayChannel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LHdecayChannel" "', argument " "1"" of type '" "Pythia8::LHdecayChannel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHdecayChannel * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LHdecayChannel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__LHdecayChannel, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LHdecayTable__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHdecayTable *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LHdecayTable")) SWIG_fail;
  result = (Pythia8::LHdecayTable *)new Pythia8::LHdecayTable();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHdecayTable, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHdecayTable__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHdecayTable *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LHdecayTable",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LHdecayTable" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::LHdecayTable *)new Pythia8::LHdecayTable(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHdecayTable, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHdecayTable__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::LHdecayTable *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_LHdecayTable",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LHdecayTable" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LHdecayTable" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (Pythia8::LHdecayTable *)new Pythia8::LHdecayTable(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHdecayTable, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHdecayTable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_LHdecayTable__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_LHdecayTable__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_LHdecayTable__SWIG_2(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LHdecayTable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHdecayTable::LHdecayTable()\n"
    "    Pythia8::LHdecayTable::LHdecayTable(int)\n"
    "    Pythia8::LHdecayTable::LHdecayTable(int,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHdecayTable_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHdecayTable *arg1 = (Pythia8::LHdecayTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHdecayTable_getId",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHdecayTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHdecayTable_getId" "', argument " "1"" of type '" "Pythia8::LHdecayTable *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHdecayTable * >(argp1);
  result = (int)(arg1)->getId();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHdecayTable_getWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHdecayTable *arg1 = (Pythia8::LHdecayTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHdecayTable_getWidth",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHdecayTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHdecayTable_getWidth" "', argument " "1"" of type '" "Pythia8::LHdecayTable *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHdecayTable * >(argp1);
  result = (double)(arg1)->getWidth();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHdecayTable_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHdecayTable *arg1 = (Pythia8::LHdecayTable *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHdecayTable_setId",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHdecayTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHdecayTable_setId" "', argument " "1"" of type '" "Pythia8::LHdecayTable *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHdecayTable * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHdecayTable_setId" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setId(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHdecayTable_setWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHdecayTable *arg1 = (Pythia8::LHdecayTable *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHdecayTable_setWidth",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHdecayTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHdecayTable_setWidth" "', argument " "1"" of type '" "Pythia8::LHdecayTable *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHdecayTable * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHdecayTable_setWidth" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setWidth(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHdecayTable_reset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHdecayTable *arg1 = (Pythia8::LHdecayTable *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHdecayTable_reset",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHdecayTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHdecayTable_reset" "', argument " "1"" of type '" "Pythia8::LHdecayTable *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHdecayTable * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHdecayTable_reset" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->reset(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHdecayTable_reset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHdecayTable *arg1 = (Pythia8::LHdecayTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHdecayTable_reset",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHdecayTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHdecayTable_reset" "', argument " "1"" of type '" "Pythia8::LHdecayTable *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHdecayTable * >(argp1);
  (arg1)->reset();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHdecayTable_reset(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHdecayTable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LHdecayTable_reset__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHdecayTable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LHdecayTable_reset__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LHdecayTable_reset'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHdecayTable::reset(double)\n"
    "    Pythia8::LHdecayTable::reset()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHdecayTable_addChannel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHdecayTable *arg1 = (Pythia8::LHdecayTable *) 0 ;
  Pythia8::LHdecayChannel arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHdecayTable_addChannel",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHdecayTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHdecayTable_addChannel" "', argument " "1"" of type '" "Pythia8::LHdecayTable *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHdecayTable * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__LHdecayChannel,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHdecayTable_addChannel" "', argument " "2"" of type '" "Pythia8::LHdecayChannel""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LHdecayTable_addChannel" "', argument " "2"" of type '" "Pythia8::LHdecayChannel""'");
    } else {
      Pythia8::LHdecayChannel * temp = reinterpret_cast< Pythia8::LHdecayChannel * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->addChannel(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHdecayTable_addChannel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHdecayTable *arg1 = (Pythia8::LHdecayTable *) 0 ;
  double arg2 ;
  int arg3 ;
  std::vector< int,std::allocator< int > > arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:LHdecayTable_addChannel",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHdecayTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHdecayTable_addChannel" "', argument " "1"" of type '" "Pythia8::LHdecayTable *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHdecayTable * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHdecayTable_addChannel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHdecayTable_addChannel" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LHdecayTable_addChannel" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LHdecayTable_addChannel" "', argument " "5"" of type '" "std::string""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->addChannel(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHdecayTable_addChannel__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHdecayTable *arg1 = (Pythia8::LHdecayTable *) 0 ;
  double arg2 ;
  int arg3 ;
  std::vector< int,std::allocator< int > > arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:LHdecayTable_addChannel",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHdecayTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHdecayTable_addChannel" "', argument " "1"" of type '" "Pythia8::LHdecayTable *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHdecayTable * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHdecayTable_addChannel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHdecayTable_addChannel" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LHdecayTable_addChannel" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->addChannel(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHdecayTable_addChannel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHdecayTable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__LHdecayChannel, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_LHdecayTable_addChannel__SWIG_0(self, args);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHdecayTable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< int,std::allocator< int > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_LHdecayTable_addChannel__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHdecayTable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< int,std::allocator< int > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_LHdecayTable_addChannel__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LHdecayTable_addChannel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHdecayTable::addChannel(Pythia8::LHdecayChannel)\n"
    "    Pythia8::LHdecayTable::addChannel(double,int,std::vector< int,std::allocator< int > >,std::string)\n"
    "    Pythia8::LHdecayTable::addChannel(double,int,std::vector< int,std::allocator< int > >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHdecayTable_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHdecayTable *arg1 = (Pythia8::LHdecayTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHdecayTable_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHdecayTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHdecayTable_size" "', argument " "1"" of type '" "Pythia8::LHdecayTable *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHdecayTable * >(argp1);
  result = (int)(arg1)->size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHdecayTable_getBrat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHdecayTable *arg1 = (Pythia8::LHdecayTable *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHdecayTable_getBrat",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHdecayTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHdecayTable_getBrat" "', argument " "1"" of type '" "Pythia8::LHdecayTable *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHdecayTable * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHdecayTable_getBrat" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->getBrat(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHdecayTable_getIdDa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHdecayTable *arg1 = (Pythia8::LHdecayTable *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< int,std::allocator< int > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHdecayTable_getIdDa",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHdecayTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHdecayTable_getIdDa" "', argument " "1"" of type '" "Pythia8::LHdecayTable *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHdecayTable * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHdecayTable_getIdDa" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (arg1)->getIdDa(arg2);
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHdecayTable_getChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHdecayTable *arg1 = (Pythia8::LHdecayTable *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::LHdecayChannel result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHdecayTable_getChannel",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHdecayTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHdecayTable_getChannel" "', argument " "1"" of type '" "Pythia8::LHdecayTable *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHdecayTable * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHdecayTable_getChannel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (arg1)->getChannel(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::LHdecayChannel(static_cast< const Pythia8::LHdecayChannel& >(result))), SWIGTYPE_p_Pythia8__LHdecayChannel, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LHdecayTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHdecayTable *arg1 = (Pythia8::LHdecayTable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LHdecayTable",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHdecayTable, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LHdecayTable" "', argument " "1"" of type '" "Pythia8::LHdecayTable *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHdecayTable * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LHdecayTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__LHdecayTable, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SusyLesHouches__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::SusyLesHouches *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SusyLesHouches",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SusyLesHouches" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::SusyLesHouches *)new Pythia8::SusyLesHouches(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SusyLesHouches, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SusyLesHouches__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SusyLesHouches")) SWIG_fail;
  result = (Pythia8::SusyLesHouches *)new Pythia8::SusyLesHouches();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SusyLesHouches, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SusyLesHouches__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  int arg2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::SusyLesHouches *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_SusyLesHouches",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SusyLesHouches" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SusyLesHouches" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::SusyLesHouches *)new Pythia8::SusyLesHouches(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SusyLesHouches, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SusyLesHouches__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  Pythia8::SusyLesHouches *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SusyLesHouches",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SusyLesHouches" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::SusyLesHouches *)new Pythia8::SusyLesHouches(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SusyLesHouches, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SusyLesHouches(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_SusyLesHouches__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SusyLesHouches__SWIG_0(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SusyLesHouches__SWIG_3(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SusyLesHouches__SWIG_2(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SusyLesHouches'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SusyLesHouches::SusyLesHouches(int)\n"
    "    Pythia8::SusyLesHouches::SusyLesHouches()\n"
    "    Pythia8::SusyLesHouches::SusyLesHouches(std::string,int)\n"
    "    Pythia8::SusyLesHouches::SusyLesHouches(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_readFile__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  std::string arg2 ;
  int arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SusyLesHouches_readFile",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_readFile" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SusyLesHouches_readFile" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SusyLesHouches_readFile" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SusyLesHouches_readFile" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (int)(arg1)->readFile(arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_readFile__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  std::string arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SusyLesHouches_readFile",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_readFile" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SusyLesHouches_readFile" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SusyLesHouches_readFile" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->readFile(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_readFile__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_readFile",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_readFile" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SusyLesHouches_readFile" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (int)(arg1)->readFile(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_readFile__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_readFile",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_readFile" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (int)(arg1)->readFile();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_readFile__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  std::istream *arg2 = 0 ;
  int arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SusyLesHouches_readFile",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_readFile" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_readFile" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SusyLesHouches_readFile" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SusyLesHouches_readFile" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SusyLesHouches_readFile" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (int)(arg1)->readFile(*arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_readFile__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  std::istream *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SusyLesHouches_readFile",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_readFile" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_readFile" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SusyLesHouches_readFile" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SusyLesHouches_readFile" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->readFile(*arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_readFile__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  std::istream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_readFile",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_readFile" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_readFile" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SusyLesHouches_readFile" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  result = (int)(arg1)->readFile(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_readFile(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SusyLesHouches, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SusyLesHouches_readFile__SWIG_3(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SusyLesHouches, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SusyLesHouches_readFile__SWIG_6(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SusyLesHouches, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SusyLesHouches_readFile__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SusyLesHouches, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SusyLesHouches_readFile__SWIG_5(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SusyLesHouches, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SusyLesHouches_readFile__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SusyLesHouches, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SusyLesHouches_readFile__SWIG_4(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SusyLesHouches, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SusyLesHouches_readFile__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SusyLesHouches_readFile'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SusyLesHouches::readFile(std::string,int,bool)\n"
    "    Pythia8::SusyLesHouches::readFile(std::string,int)\n"
    "    Pythia8::SusyLesHouches::readFile(std::string)\n"
    "    Pythia8::SusyLesHouches::readFile()\n"
    "    Pythia8::SusyLesHouches::readFile(std::istream &,int,bool)\n"
    "    Pythia8::SusyLesHouches::readFile(std::istream &,int)\n"
    "    Pythia8::SusyLesHouches::readFile(std::istream &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_listHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_listHeader",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_listHeader" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  (arg1)->listHeader();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_listFooter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_listFooter",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_listFooter" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  (arg1)->listFooter();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_listSpectrum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_listSpectrum",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_listSpectrum" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SusyLesHouches_listSpectrum" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->listSpectrum(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_listSpectrum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_listSpectrum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_listSpectrum" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  (arg1)->listSpectrum();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_listSpectrum(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SusyLesHouches, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SusyLesHouches_listSpectrum__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SusyLesHouches, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SusyLesHouches_listSpectrum__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SusyLesHouches_listSpectrum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SusyLesHouches::listSpectrum(int)\n"
    "    Pythia8::SusyLesHouches::listSpectrum()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_checkSpectrum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_checkSpectrum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_checkSpectrum" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (int)(arg1)->checkSpectrum();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_slhaFile_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_slhaFile_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_slhaFile_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_slhaFile_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SusyLesHouches_slhaFile_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->slhaFile = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_slhaFile_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_slhaFile_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_slhaFile_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (std::string *) & ((arg1)->slhaFile);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_modsel_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< int > *arg2 = (Pythia8::LHblock< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_modsel_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_modsel_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_modsel_set" "', argument " "2"" of type '" "Pythia8::LHblock< int > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< int > * >(argp2);
  if (arg1) (arg1)->modsel = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_modsel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< int > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_modsel_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_modsel_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< int > *)& ((arg1)->modsel);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_int_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_modsel21_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< int > *arg2 = (Pythia8::LHblock< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_modsel21_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_modsel21_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_modsel21_set" "', argument " "2"" of type '" "Pythia8::LHblock< int > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< int > * >(argp2);
  if (arg1) (arg1)->modsel21 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_modsel21_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< int > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_modsel21_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_modsel21_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< int > *)& ((arg1)->modsel21);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_int_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_modsel12_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< double > *arg2 = (Pythia8::LHblock< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_modsel12_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_modsel12_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_modsel12_set" "', argument " "2"" of type '" "Pythia8::LHblock< double > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< double > * >(argp2);
  if (arg1) (arg1)->modsel12 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_modsel12_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_modsel12_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_modsel12_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< double > *)& ((arg1)->modsel12);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_minpar_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< double > *arg2 = (Pythia8::LHblock< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_minpar_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_minpar_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_minpar_set" "', argument " "2"" of type '" "Pythia8::LHblock< double > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< double > * >(argp2);
  if (arg1) (arg1)->minpar = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_minpar_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_minpar_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_minpar_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< double > *)& ((arg1)->minpar);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_extpar_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< double > *arg2 = (Pythia8::LHblock< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_extpar_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_extpar_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_extpar_set" "', argument " "2"" of type '" "Pythia8::LHblock< double > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< double > * >(argp2);
  if (arg1) (arg1)->extpar = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_extpar_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_extpar_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_extpar_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< double > *)& ((arg1)->extpar);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_sminputs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< double > *arg2 = (Pythia8::LHblock< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_sminputs_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_sminputs_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_sminputs_set" "', argument " "2"" of type '" "Pythia8::LHblock< double > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< double > * >(argp2);
  if (arg1) (arg1)->sminputs = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_sminputs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_sminputs_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_sminputs_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< double > *)& ((arg1)->sminputs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_spinfo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< std::string > *arg2 = (Pythia8::LHblock< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_spinfo_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_spinfo_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_spinfo_set" "', argument " "2"" of type '" "Pythia8::LHblock< std::string > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< std::string > * >(argp2);
  if (arg1) (arg1)->spinfo = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_spinfo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< std::string > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_spinfo_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_spinfo_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< std::string > *)& ((arg1)->spinfo);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_std__string_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_spinfo3_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< std::string > *arg2 = (Pythia8::LHblock< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_spinfo3_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_spinfo3_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_spinfo3_set" "', argument " "2"" of type '" "Pythia8::LHblock< std::string > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< std::string > * >(argp2);
  if (arg1) (arg1)->spinfo3 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_spinfo3_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< std::string > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_spinfo3_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_spinfo3_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< std::string > *)& ((arg1)->spinfo3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_std__string_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_spinfo4_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< std::string > *arg2 = (Pythia8::LHblock< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_spinfo4_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_spinfo4_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_spinfo4_set" "', argument " "2"" of type '" "Pythia8::LHblock< std::string > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< std::string > * >(argp2);
  if (arg1) (arg1)->spinfo4 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_spinfo4_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< std::string > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_spinfo4_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_spinfo4_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< std::string > *)& ((arg1)->spinfo4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_std__string_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_dcinfo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< std::string > *arg2 = (Pythia8::LHblock< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_dcinfo_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_dcinfo_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_dcinfo_set" "', argument " "2"" of type '" "Pythia8::LHblock< std::string > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< std::string > * >(argp2);
  if (arg1) (arg1)->dcinfo = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_dcinfo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< std::string > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_dcinfo_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_dcinfo_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< std::string > *)& ((arg1)->dcinfo);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_std__string_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_dcinfo3_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< std::string > *arg2 = (Pythia8::LHblock< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_dcinfo3_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_dcinfo3_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_dcinfo3_set" "', argument " "2"" of type '" "Pythia8::LHblock< std::string > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< std::string > * >(argp2);
  if (arg1) (arg1)->dcinfo3 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_dcinfo3_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< std::string > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_dcinfo3_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_dcinfo3_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< std::string > *)& ((arg1)->dcinfo3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_std__string_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_dcinfo4_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< std::string > *arg2 = (Pythia8::LHblock< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_dcinfo4_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_dcinfo4_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_dcinfo4_set" "', argument " "2"" of type '" "Pythia8::LHblock< std::string > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< std::string > * >(argp2);
  if (arg1) (arg1)->dcinfo4 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_dcinfo4_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< std::string > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_dcinfo4_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_dcinfo4_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< std::string > *)& ((arg1)->dcinfo4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_std__string_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_mass_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< double > *arg2 = (Pythia8::LHblock< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_mass_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_mass_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_mass_set" "', argument " "2"" of type '" "Pythia8::LHblock< double > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< double > * >(argp2);
  if (arg1) (arg1)->mass = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_mass_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_mass_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_mass_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< double > *)& ((arg1)->mass);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_nmix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 4 > *arg2 = (Pythia8::LHmatrixBlock< 4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_nmix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_nmix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_nmix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 4 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 4 > * >(argp2);
  if (arg1) (arg1)->nmix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_nmix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 4 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_nmix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_nmix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 4 > *)& ((arg1)->nmix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_4_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_umix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 2 > *arg2 = (Pythia8::LHmatrixBlock< 2 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_umix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_umix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_2_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_umix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 2 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 2 > * >(argp2);
  if (arg1) (arg1)->umix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_umix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 2 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_umix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_umix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 2 > *)& ((arg1)->umix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_2_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_vmix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 2 > *arg2 = (Pythia8::LHmatrixBlock< 2 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_vmix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_vmix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_2_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_vmix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 2 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 2 > * >(argp2);
  if (arg1) (arg1)->vmix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_vmix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 2 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_vmix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_vmix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 2 > *)& ((arg1)->vmix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_2_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_stopmix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 2 > *arg2 = (Pythia8::LHmatrixBlock< 2 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_stopmix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_stopmix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_2_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_stopmix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 2 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 2 > * >(argp2);
  if (arg1) (arg1)->stopmix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_stopmix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 2 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_stopmix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_stopmix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 2 > *)& ((arg1)->stopmix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_2_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_sbotmix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 2 > *arg2 = (Pythia8::LHmatrixBlock< 2 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_sbotmix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_sbotmix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_2_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_sbotmix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 2 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 2 > * >(argp2);
  if (arg1) (arg1)->sbotmix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_sbotmix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 2 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_sbotmix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_sbotmix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 2 > *)& ((arg1)->sbotmix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_2_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_staumix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 2 > *arg2 = (Pythia8::LHmatrixBlock< 2 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_staumix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_staumix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_2_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_staumix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 2 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 2 > * >(argp2);
  if (arg1) (arg1)->staumix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_staumix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 2 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_staumix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_staumix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 2 > *)& ((arg1)->staumix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_2_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_alpha_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< double > *arg2 = (Pythia8::LHblock< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_alpha_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_alpha_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_alpha_set" "', argument " "2"" of type '" "Pythia8::LHblock< double > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< double > * >(argp2);
  if (arg1) (arg1)->alpha = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_alpha_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_alpha_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_alpha_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< double > *)& ((arg1)->alpha);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_hmix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< double > *arg2 = (Pythia8::LHblock< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_hmix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_hmix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_hmix_set" "', argument " "2"" of type '" "Pythia8::LHblock< double > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< double > * >(argp2);
  if (arg1) (arg1)->hmix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_hmix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_hmix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_hmix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< double > *)& ((arg1)->hmix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_gauge_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< double > *arg2 = (Pythia8::LHblock< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_gauge_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_gauge_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_gauge_set" "', argument " "2"" of type '" "Pythia8::LHblock< double > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< double > * >(argp2);
  if (arg1) (arg1)->gauge = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_gauge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_gauge_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_gauge_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< double > *)& ((arg1)->gauge);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_msoft_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< double > *arg2 = (Pythia8::LHblock< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_msoft_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_msoft_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_msoft_set" "', argument " "2"" of type '" "Pythia8::LHblock< double > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< double > * >(argp2);
  if (arg1) (arg1)->msoft = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_msoft_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_msoft_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_msoft_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< double > *)& ((arg1)->msoft);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_au_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_au_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_au_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_au_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->au = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_au_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_au_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_au_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->au);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_ad_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_ad_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_ad_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_ad_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->ad = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_ad_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_ad_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_ad_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->ad);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_ae_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_ae_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_ae_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_ae_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->ae = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_ae_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_ae_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_ae_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->ae);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_yu_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_yu_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_yu_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_yu_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->yu = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_yu_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_yu_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_yu_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->yu);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_yd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_yd_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_yd_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_yd_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->yd = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_yd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_yd_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_yd_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->yd);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_ye_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_ye_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_ye_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_ye_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->ye = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_ye_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_ye_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_ye_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->ye);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_decays_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  std::vector< Pythia8::LHdecayTable,std::allocator< Pythia8::LHdecayTable > > *arg2 = (std::vector< Pythia8::LHdecayTable,std::allocator< Pythia8::LHdecayTable > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_decays_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_decays_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_Pythia8__LHdecayTable_std__allocatorT_Pythia8__LHdecayTable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_decays_set" "', argument " "2"" of type '" "std::vector< Pythia8::LHdecayTable,std::allocator< Pythia8::LHdecayTable > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::LHdecayTable,std::allocator< Pythia8::LHdecayTable > > * >(argp2);
  if (arg1) (arg1)->decays = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_decays_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::LHdecayTable,std::allocator< Pythia8::LHdecayTable > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_decays_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_decays_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (std::vector< Pythia8::LHdecayTable,std::allocator< Pythia8::LHdecayTable > > *)& ((arg1)->decays);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__LHdecayTable_std__allocatorT_Pythia8__LHdecayTable_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_decayIndices_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > > *arg2 = (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_decayIndices_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_decayIndices_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_decayIndices_set" "', argument " "2"" of type '" "std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > > * >(argp2);
  if (arg1) (arg1)->decayIndices = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_decayIndices_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_decayIndices_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_decayIndices_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > > *)& ((arg1)->decayIndices);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_qnumbers_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  std::vector< Pythia8::LHblock< int >,std::allocator< Pythia8::LHblock< int > > > *arg2 = (std::vector< Pythia8::LHblock< int >,std::allocator< Pythia8::LHblock< int > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_qnumbers_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_qnumbers_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_Pythia8__LHblockT_int_t_std__allocatorT_Pythia8__LHblockT_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_qnumbers_set" "', argument " "2"" of type '" "std::vector< Pythia8::LHblock< int >,std::allocator< Pythia8::LHblock< int > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::LHblock< int >,std::allocator< Pythia8::LHblock< int > > > * >(argp2);
  if (arg1) (arg1)->qnumbers = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_qnumbers_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::LHblock< int >,std::allocator< Pythia8::LHblock< int > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_qnumbers_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_qnumbers_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (std::vector< Pythia8::LHblock< int >,std::allocator< Pythia8::LHblock< int > > > *)& ((arg1)->qnumbers);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__LHblockT_int_t_std__allocatorT_Pythia8__LHblockT_int_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_qnumbersName_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = (std::vector< std::string,std::allocator< std::string > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_qnumbersName_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_qnumbersName_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_qnumbersName_set" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp2);
  if (arg1) (arg1)->qnumbersName = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_qnumbersName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_qnumbersName_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_qnumbersName_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (std::vector< std::string,std::allocator< std::string > > *)& ((arg1)->qnumbersName);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_qnumbersAntiName_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = (std::vector< std::string,std::allocator< std::string > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_qnumbersAntiName_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_qnumbersAntiName_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_qnumbersAntiName_set" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp2);
  if (arg1) (arg1)->qnumbersAntiName = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_qnumbersAntiName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_qnumbersAntiName_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_qnumbersAntiName_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (std::vector< std::string,std::allocator< std::string > > *)& ((arg1)->qnumbersAntiName);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_qextpar_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< double > *arg2 = (Pythia8::LHblock< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_qextpar_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_qextpar_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_qextpar_set" "', argument " "2"" of type '" "Pythia8::LHblock< double > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< double > * >(argp2);
  if (arg1) (arg1)->qextpar = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_qextpar_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_qextpar_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_qextpar_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< double > *)& ((arg1)->qextpar);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_vckmin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< double > *arg2 = (Pythia8::LHblock< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_vckmin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_vckmin_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_vckmin_set" "', argument " "2"" of type '" "Pythia8::LHblock< double > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< double > * >(argp2);
  if (arg1) (arg1)->vckmin = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_vckmin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_vckmin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_vckmin_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< double > *)& ((arg1)->vckmin);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_upmnsin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< double > *arg2 = (Pythia8::LHblock< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_upmnsin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_upmnsin_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_upmnsin_set" "', argument " "2"" of type '" "Pythia8::LHblock< double > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< double > * >(argp2);
  if (arg1) (arg1)->upmnsin = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_upmnsin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_upmnsin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_upmnsin_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< double > *)& ((arg1)->upmnsin);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_msq2in_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_msq2in_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_msq2in_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_msq2in_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->msq2in = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_msq2in_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_msq2in_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_msq2in_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->msq2in);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_msu2in_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_msu2in_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_msu2in_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_msu2in_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->msu2in = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_msu2in_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_msu2in_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_msu2in_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->msu2in);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_msd2in_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_msd2in_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_msd2in_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_msd2in_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->msd2in = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_msd2in_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_msd2in_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_msd2in_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->msd2in);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_msl2in_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_msl2in_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_msl2in_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_msl2in_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->msl2in = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_msl2in_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_msl2in_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_msl2in_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->msl2in);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_mse2in_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_mse2in_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_mse2in_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_mse2in_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->mse2in = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_mse2in_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_mse2in_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_mse2in_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->mse2in);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_tuin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_tuin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_tuin_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_tuin_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->tuin = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_tuin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_tuin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_tuin_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->tuin);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_tdin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_tdin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_tdin_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_tdin_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->tdin = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_tdin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_tdin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_tdin_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->tdin);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_tein_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_tein_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_tein_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_tein_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->tein = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_tein_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_tein_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_tein_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->tein);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_vckm_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_vckm_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_vckm_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_vckm_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->vckm = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_vckm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_vckm_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_vckm_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->vckm);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_upmns_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_upmns_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_upmns_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_upmns_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->upmns = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_upmns_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_upmns_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_upmns_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->upmns);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_msq2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_msq2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_msq2_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_msq2_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->msq2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_msq2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_msq2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_msq2_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->msq2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_msu2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_msu2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_msu2_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_msu2_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->msu2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_msu2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_msu2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_msu2_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->msu2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_msd2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_msd2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_msd2_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_msd2_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->msd2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_msd2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_msd2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_msd2_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->msd2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_msl2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_msl2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_msl2_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_msl2_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->msl2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_msl2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_msl2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_msl2_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->msl2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_mse2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_mse2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_mse2_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_mse2_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->mse2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_mse2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_mse2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_mse2_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->mse2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_tu_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_tu_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_tu_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_tu_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->tu = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_tu_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_tu_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_tu_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->tu);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_td_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_td_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_td_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_td_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->td = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_td_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_td_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_td_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->td);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_te_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_te_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_te_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_te_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->te = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_te_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_te_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_te_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->te);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_usqmix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 6 > *arg2 = (Pythia8::LHmatrixBlock< 6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_usqmix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_usqmix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_usqmix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 6 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 6 > * >(argp2);
  if (arg1) (arg1)->usqmix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_usqmix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 6 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_usqmix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_usqmix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 6 > *)& ((arg1)->usqmix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_6_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_dsqmix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 6 > *arg2 = (Pythia8::LHmatrixBlock< 6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_dsqmix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_dsqmix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_dsqmix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 6 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 6 > * >(argp2);
  if (arg1) (arg1)->dsqmix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_dsqmix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 6 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_dsqmix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_dsqmix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 6 > *)& ((arg1)->dsqmix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_6_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_selmix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 6 > *arg2 = (Pythia8::LHmatrixBlock< 6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_selmix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_selmix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_selmix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 6 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 6 > * >(argp2);
  if (arg1) (arg1)->selmix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_selmix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 6 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_selmix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_selmix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 6 > *)& ((arg1)->selmix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_6_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_snumix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_snumix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_snumix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_snumix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->snumix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_snumix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_snumix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_snumix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->snumix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_snsmix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_snsmix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_snsmix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_snsmix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->snsmix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_snsmix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_snsmix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_snsmix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->snsmix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_snamix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_snamix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_snamix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_snamix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->snamix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_snamix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_snamix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_snamix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->snamix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvlamllein_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHtensor3Block< 3 > *arg2 = (Pythia8::LHtensor3Block< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvlamllein_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvlamllein_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvlamllein_set" "', argument " "2"" of type '" "Pythia8::LHtensor3Block< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHtensor3Block< 3 > * >(argp2);
  if (arg1) (arg1)->rvlamllein = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvlamllein_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHtensor3Block< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvlamllein_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvlamllein_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHtensor3Block< 3 > *)& ((arg1)->rvlamllein);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvlamlqdin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHtensor3Block< 3 > *arg2 = (Pythia8::LHtensor3Block< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvlamlqdin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvlamlqdin_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvlamlqdin_set" "', argument " "2"" of type '" "Pythia8::LHtensor3Block< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHtensor3Block< 3 > * >(argp2);
  if (arg1) (arg1)->rvlamlqdin = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvlamlqdin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHtensor3Block< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvlamlqdin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvlamlqdin_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHtensor3Block< 3 > *)& ((arg1)->rvlamlqdin);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvlamuddin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHtensor3Block< 3 > *arg2 = (Pythia8::LHtensor3Block< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvlamuddin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvlamuddin_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvlamuddin_set" "', argument " "2"" of type '" "Pythia8::LHtensor3Block< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHtensor3Block< 3 > * >(argp2);
  if (arg1) (arg1)->rvlamuddin = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvlamuddin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHtensor3Block< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvlamuddin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvlamuddin_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHtensor3Block< 3 > *)& ((arg1)->rvlamuddin);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvtllein_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHtensor3Block< 3 > *arg2 = (Pythia8::LHtensor3Block< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvtllein_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvtllein_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvtllein_set" "', argument " "2"" of type '" "Pythia8::LHtensor3Block< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHtensor3Block< 3 > * >(argp2);
  if (arg1) (arg1)->rvtllein = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvtllein_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHtensor3Block< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvtllein_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvtllein_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHtensor3Block< 3 > *)& ((arg1)->rvtllein);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvtlqdin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHtensor3Block< 3 > *arg2 = (Pythia8::LHtensor3Block< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvtlqdin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvtlqdin_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvtlqdin_set" "', argument " "2"" of type '" "Pythia8::LHtensor3Block< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHtensor3Block< 3 > * >(argp2);
  if (arg1) (arg1)->rvtlqdin = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvtlqdin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHtensor3Block< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvtlqdin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvtlqdin_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHtensor3Block< 3 > *)& ((arg1)->rvtlqdin);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvtuddin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHtensor3Block< 3 > *arg2 = (Pythia8::LHtensor3Block< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvtuddin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvtuddin_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvtuddin_set" "', argument " "2"" of type '" "Pythia8::LHtensor3Block< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHtensor3Block< 3 > * >(argp2);
  if (arg1) (arg1)->rvtuddin = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvtuddin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHtensor3Block< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvtuddin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvtuddin_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHtensor3Block< 3 > *)& ((arg1)->rvtuddin);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvkappain_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< double > *arg2 = (Pythia8::LHblock< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvkappain_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvkappain_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvkappain_set" "', argument " "2"" of type '" "Pythia8::LHblock< double > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< double > * >(argp2);
  if (arg1) (arg1)->rvkappain = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvkappain_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvkappain_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvkappain_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< double > *)& ((arg1)->rvkappain);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvdin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< double > *arg2 = (Pythia8::LHblock< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvdin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvdin_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvdin_set" "', argument " "2"" of type '" "Pythia8::LHblock< double > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< double > * >(argp2);
  if (arg1) (arg1)->rvdin = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvdin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvdin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvdin_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< double > *)& ((arg1)->rvdin);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvm2lh1in_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< double > *arg2 = (Pythia8::LHblock< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvm2lh1in_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvm2lh1in_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvm2lh1in_set" "', argument " "2"" of type '" "Pythia8::LHblock< double > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< double > * >(argp2);
  if (arg1) (arg1)->rvm2lh1in = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvm2lh1in_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvm2lh1in_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvm2lh1in_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< double > *)& ((arg1)->rvm2lh1in);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvsnvevin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< double > *arg2 = (Pythia8::LHblock< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvsnvevin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvsnvevin_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvsnvevin_set" "', argument " "2"" of type '" "Pythia8::LHblock< double > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< double > * >(argp2);
  if (arg1) (arg1)->rvsnvevin = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvsnvevin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvsnvevin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvsnvevin_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< double > *)& ((arg1)->rvsnvevin);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvlamlle_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHtensor3Block< 3 > *arg2 = (Pythia8::LHtensor3Block< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvlamlle_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvlamlle_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvlamlle_set" "', argument " "2"" of type '" "Pythia8::LHtensor3Block< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHtensor3Block< 3 > * >(argp2);
  if (arg1) (arg1)->rvlamlle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvlamlle_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHtensor3Block< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvlamlle_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvlamlle_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHtensor3Block< 3 > *)& ((arg1)->rvlamlle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvlamlqd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHtensor3Block< 3 > *arg2 = (Pythia8::LHtensor3Block< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvlamlqd_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvlamlqd_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvlamlqd_set" "', argument " "2"" of type '" "Pythia8::LHtensor3Block< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHtensor3Block< 3 > * >(argp2);
  if (arg1) (arg1)->rvlamlqd = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvlamlqd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHtensor3Block< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvlamlqd_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvlamlqd_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHtensor3Block< 3 > *)& ((arg1)->rvlamlqd);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvlamudd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHtensor3Block< 3 > *arg2 = (Pythia8::LHtensor3Block< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvlamudd_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvlamudd_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvlamudd_set" "', argument " "2"" of type '" "Pythia8::LHtensor3Block< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHtensor3Block< 3 > * >(argp2);
  if (arg1) (arg1)->rvlamudd = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvlamudd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHtensor3Block< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvlamudd_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvlamudd_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHtensor3Block< 3 > *)& ((arg1)->rvlamudd);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvtlle_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHtensor3Block< 3 > *arg2 = (Pythia8::LHtensor3Block< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvtlle_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvtlle_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvtlle_set" "', argument " "2"" of type '" "Pythia8::LHtensor3Block< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHtensor3Block< 3 > * >(argp2);
  if (arg1) (arg1)->rvtlle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvtlle_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHtensor3Block< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvtlle_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvtlle_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHtensor3Block< 3 > *)& ((arg1)->rvtlle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvtlqd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHtensor3Block< 3 > *arg2 = (Pythia8::LHtensor3Block< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvtlqd_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvtlqd_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvtlqd_set" "', argument " "2"" of type '" "Pythia8::LHtensor3Block< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHtensor3Block< 3 > * >(argp2);
  if (arg1) (arg1)->rvtlqd = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvtlqd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHtensor3Block< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvtlqd_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvtlqd_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHtensor3Block< 3 > *)& ((arg1)->rvtlqd);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvtudd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHtensor3Block< 3 > *arg2 = (Pythia8::LHtensor3Block< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvtudd_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvtudd_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvtudd_set" "', argument " "2"" of type '" "Pythia8::LHtensor3Block< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHtensor3Block< 3 > * >(argp2);
  if (arg1) (arg1)->rvtudd = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvtudd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHtensor3Block< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvtudd_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvtudd_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHtensor3Block< 3 > *)& ((arg1)->rvtudd);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHtensor3BlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvkappa_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< double > *arg2 = (Pythia8::LHblock< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvkappa_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvkappa_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvkappa_set" "', argument " "2"" of type '" "Pythia8::LHblock< double > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< double > * >(argp2);
  if (arg1) (arg1)->rvkappa = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvkappa_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvkappa_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvkappa_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< double > *)& ((arg1)->rvkappa);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< double > *arg2 = (Pythia8::LHblock< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvd_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvd_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvd_set" "', argument " "2"" of type '" "Pythia8::LHblock< double > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< double > * >(argp2);
  if (arg1) (arg1)->rvd = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvd_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvd_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< double > *)& ((arg1)->rvd);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvm2lh1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< double > *arg2 = (Pythia8::LHblock< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvm2lh1_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvm2lh1_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvm2lh1_set" "', argument " "2"" of type '" "Pythia8::LHblock< double > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< double > * >(argp2);
  if (arg1) (arg1)->rvm2lh1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvm2lh1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvm2lh1_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvm2lh1_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< double > *)& ((arg1)->rvm2lh1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvsnvev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< double > *arg2 = (Pythia8::LHblock< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvsnvev_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvsnvev_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvsnvev_set" "', argument " "2"" of type '" "Pythia8::LHblock< double > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< double > * >(argp2);
  if (arg1) (arg1)->rvsnvev = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvsnvev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvsnvev_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvsnvev_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< double > *)& ((arg1)->rvsnvev);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvnmix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 7 > *arg2 = (Pythia8::LHmatrixBlock< 7 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvnmix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvnmix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_7_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvnmix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 7 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 7 > * >(argp2);
  if (arg1) (arg1)->rvnmix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvnmix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 7 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvnmix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvnmix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 7 > *)& ((arg1)->rvnmix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_7_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvumix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 5 > *arg2 = (Pythia8::LHmatrixBlock< 5 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvumix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvumix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_5_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvumix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 5 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 5 > * >(argp2);
  if (arg1) (arg1)->rvumix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvumix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 5 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvumix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvumix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 5 > *)& ((arg1)->rvumix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_5_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvvmix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 5 > *arg2 = (Pythia8::LHmatrixBlock< 5 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvvmix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvvmix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_5_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvvmix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 5 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 5 > * >(argp2);
  if (arg1) (arg1)->rvvmix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvvmix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 5 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvvmix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvvmix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 5 > *)& ((arg1)->rvvmix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_5_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvhmix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 5 > *arg2 = (Pythia8::LHmatrixBlock< 5 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvhmix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvhmix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_5_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvhmix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 5 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 5 > * >(argp2);
  if (arg1) (arg1)->rvhmix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvhmix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 5 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvhmix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvhmix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 5 > *)& ((arg1)->rvhmix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_5_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvamix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 5 > *arg2 = (Pythia8::LHmatrixBlock< 5 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvamix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvamix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_5_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvamix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 5 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 5 > * >(argp2);
  if (arg1) (arg1)->rvamix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvamix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 5 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvamix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvamix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 5 > *)& ((arg1)->rvamix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_5_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvlmix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 8 > *arg2 = (Pythia8::LHmatrixBlock< 8 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_rvlmix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvlmix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_8_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_rvlmix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 8 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 8 > * >(argp2);
  if (arg1) (arg1)->rvlmix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_rvlmix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 8 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_rvlmix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_rvlmix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 8 > *)& ((arg1)->rvlmix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_8_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imminpar_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< double > *arg2 = (Pythia8::LHblock< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_imminpar_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imminpar_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_imminpar_set" "', argument " "2"" of type '" "Pythia8::LHblock< double > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< double > * >(argp2);
  if (arg1) (arg1)->imminpar = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imminpar_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_imminpar_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imminpar_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< double > *)& ((arg1)->imminpar);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imextpar_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< double > *arg2 = (Pythia8::LHblock< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_imextpar_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imextpar_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_imextpar_set" "', argument " "2"" of type '" "Pythia8::LHblock< double > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< double > * >(argp2);
  if (arg1) (arg1)->imextpar = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imextpar_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_imextpar_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imextpar_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< double > *)& ((arg1)->imextpar);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_cvhmix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 4 > *arg2 = (Pythia8::LHmatrixBlock< 4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_cvhmix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_cvhmix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_cvhmix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 4 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 4 > * >(argp2);
  if (arg1) (arg1)->cvhmix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_cvhmix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 4 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_cvhmix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_cvhmix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 4 > *)& ((arg1)->cvhmix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_4_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imcvhmix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 4 > *arg2 = (Pythia8::LHmatrixBlock< 4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_imcvhmix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imcvhmix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_imcvhmix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 4 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 4 > * >(argp2);
  if (arg1) (arg1)->imcvhmix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imcvhmix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 4 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_imcvhmix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imcvhmix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 4 > *)& ((arg1)->imcvhmix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_4_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imau_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_imau_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imau_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_imau_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->imau = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imau_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_imau_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imau_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->imau);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imad_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_imad_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imad_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_imad_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->imad = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imad_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_imad_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imad_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->imad);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imae_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_imae_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imae_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_imae_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->imae = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imae_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_imae_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imae_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->imae);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imhmix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< double > *arg2 = (Pythia8::LHblock< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_imhmix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imhmix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_imhmix_set" "', argument " "2"" of type '" "Pythia8::LHblock< double > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< double > * >(argp2);
  if (arg1) (arg1)->imhmix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imhmix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_imhmix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imhmix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< double > *)& ((arg1)->imhmix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_immsoft_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< double > *arg2 = (Pythia8::LHblock< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_immsoft_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_immsoft_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_immsoft_set" "', argument " "2"" of type '" "Pythia8::LHblock< double > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< double > * >(argp2);
  if (arg1) (arg1)->immsoft = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_immsoft_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_immsoft_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_immsoft_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< double > *)& ((arg1)->immsoft);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_immsq2in_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_immsq2in_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_immsq2in_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_immsq2in_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->immsq2in = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_immsq2in_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_immsq2in_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_immsq2in_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->immsq2in);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_immsu2in_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_immsu2in_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_immsu2in_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_immsu2in_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->immsu2in = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_immsu2in_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_immsu2in_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_immsu2in_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->immsu2in);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_immsd2in_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_immsd2in_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_immsd2in_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_immsd2in_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->immsd2in = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_immsd2in_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_immsd2in_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_immsd2in_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->immsd2in);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_immsl2in_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_immsl2in_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_immsl2in_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_immsl2in_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->immsl2in = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_immsl2in_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_immsl2in_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_immsl2in_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->immsl2in);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_immse2in_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_immse2in_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_immse2in_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_immse2in_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->immse2in = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_immse2in_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_immse2in_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_immse2in_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->immse2in);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imtuin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_imtuin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imtuin_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_imtuin_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->imtuin = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imtuin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_imtuin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imtuin_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->imtuin);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imtdin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_imtdin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imtdin_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_imtdin_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->imtdin = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imtdin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_imtdin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imtdin_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->imtdin);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imtein_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_imtein_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imtein_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_imtein_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->imtein = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imtein_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_imtein_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imtein_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->imtein);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imvckm_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_imvckm_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imvckm_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_imvckm_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->imvckm = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imvckm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_imvckm_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imvckm_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->imvckm);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imupmns_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_imupmns_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imupmns_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_imupmns_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->imupmns = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imupmns_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_imupmns_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imupmns_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->imupmns);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_immsq2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_immsq2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_immsq2_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_immsq2_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->immsq2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_immsq2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_immsq2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_immsq2_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->immsq2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_immsu2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_immsu2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_immsu2_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_immsu2_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->immsu2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_immsu2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_immsu2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_immsu2_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->immsu2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_immsd2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_immsd2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_immsd2_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_immsd2_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->immsd2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_immsd2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_immsd2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_immsd2_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->immsd2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_immsl2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_immsl2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_immsl2_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_immsl2_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->immsl2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_immsl2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_immsl2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_immsl2_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->immsl2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_immse2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_immse2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_immse2_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_immse2_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->immse2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_immse2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_immse2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_immse2_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->immse2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imtu_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_imtu_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imtu_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_imtu_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->imtu = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imtu_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_imtu_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imtu_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->imtu);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imtd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_imtd_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imtd_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_imtd_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->imtd = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imtd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_imtd_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imtd_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->imtd);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imte_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_imte_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imte_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_imte_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->imte = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imte_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_imte_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imte_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->imte);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imusqmix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 6 > *arg2 = (Pythia8::LHmatrixBlock< 6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_imusqmix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imusqmix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_imusqmix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 6 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 6 > * >(argp2);
  if (arg1) (arg1)->imusqmix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imusqmix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 6 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_imusqmix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imusqmix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 6 > *)& ((arg1)->imusqmix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_6_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imdsqmix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 6 > *arg2 = (Pythia8::LHmatrixBlock< 6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_imdsqmix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imdsqmix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_imdsqmix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 6 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 6 > * >(argp2);
  if (arg1) (arg1)->imdsqmix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imdsqmix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 6 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_imdsqmix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imdsqmix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 6 > *)& ((arg1)->imdsqmix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_6_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imselmix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 6 > *arg2 = (Pythia8::LHmatrixBlock< 6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_imselmix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imselmix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_imselmix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 6 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 6 > * >(argp2);
  if (arg1) (arg1)->imselmix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imselmix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 6 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_imselmix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imselmix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 6 > *)& ((arg1)->imselmix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_6_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imsnumix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_imsnumix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imsnumix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_imsnumix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->imsnumix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imsnumix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_imsnumix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imsnumix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->imsnumix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imnmix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 4 > *arg2 = (Pythia8::LHmatrixBlock< 4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_imnmix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imnmix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_imnmix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 4 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 4 > * >(argp2);
  if (arg1) (arg1)->imnmix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imnmix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 4 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_imnmix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imnmix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 4 > *)& ((arg1)->imnmix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_4_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imumix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 4 > *arg2 = (Pythia8::LHmatrixBlock< 4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_imumix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imumix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_imumix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 4 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 4 > * >(argp2);
  if (arg1) (arg1)->imumix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imumix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 4 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_imumix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imumix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 4 > *)& ((arg1)->imumix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_4_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imvmix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 4 > *arg2 = (Pythia8::LHmatrixBlock< 4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_imvmix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imvmix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_imvmix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 4 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 4 > * >(argp2);
  if (arg1) (arg1)->imvmix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imvmix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 4 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_imvmix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imvmix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 4 > *)& ((arg1)->imvmix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_4_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_nmssmrun_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHblock< double > *arg2 = (Pythia8::LHblock< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_nmssmrun_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_nmssmrun_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_nmssmrun_set" "', argument " "2"" of type '" "Pythia8::LHblock< double > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHblock< double > * >(argp2);
  if (arg1) (arg1)->nmssmrun = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_nmssmrun_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHblock< double > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_nmssmrun_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_nmssmrun_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHblock< double > *)& ((arg1)->nmssmrun);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHblockT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_nmhmix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_nmhmix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_nmhmix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_nmhmix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->nmhmix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_nmhmix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_nmhmix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_nmhmix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->nmhmix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_nmamix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 3 > *arg2 = (Pythia8::LHmatrixBlock< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_nmamix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_nmamix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_nmamix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 3 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 3 > * >(argp2);
  if (arg1) (arg1)->nmamix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_nmamix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 3 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_nmamix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_nmamix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 3 > *)& ((arg1)->nmamix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_3_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_nmnmix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 5 > *arg2 = (Pythia8::LHmatrixBlock< 5 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_nmnmix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_nmnmix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_5_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_nmnmix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 5 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 5 > * >(argp2);
  if (arg1) (arg1)->nmnmix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_nmnmix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 5 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_nmnmix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_nmnmix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 5 > *)& ((arg1)->nmnmix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_5_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imnmnmix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::LHmatrixBlock< 5 > *arg2 = (Pythia8::LHmatrixBlock< 5 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_imnmnmix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imnmnmix_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHmatrixBlockT_5_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_imnmnmix_set" "', argument " "2"" of type '" "Pythia8::LHmatrixBlock< 5 > *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHmatrixBlock< 5 > * >(argp2);
  if (arg1) (arg1)->imnmnmix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_imnmnmix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHmatrixBlock< 5 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_imnmnmix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_imnmnmix_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (Pythia8::LHmatrixBlock< 5 > *)& ((arg1)->imnmnmix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHmatrixBlockT_5_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_genericBlocks_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  std::map< std::string,Pythia8::LHgenericBlock,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHgenericBlock > > > *arg2 = (std::map< std::string,Pythia8::LHgenericBlock,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHgenericBlock > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_genericBlocks_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_genericBlocks_set" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_std__string_Pythia8__LHgenericBlock_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHgenericBlock_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SusyLesHouches_genericBlocks_set" "', argument " "2"" of type '" "std::map< std::string,Pythia8::LHgenericBlock,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHgenericBlock > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,Pythia8::LHgenericBlock,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHgenericBlock > > > * >(argp2);
  if (arg1) (arg1)->genericBlocks = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_genericBlocks_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::LHgenericBlock,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHgenericBlock > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_genericBlocks_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_genericBlocks_get" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (std::map< std::string,Pythia8::LHgenericBlock,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHgenericBlock > > > *)& ((arg1)->genericBlocks);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__LHgenericBlock_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHgenericBlock_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_verbose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SusyLesHouches_verbose",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_verbose" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  result = (int)(arg1)->verbose();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_verbose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SusyLesHouches_verbose",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_verbose" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SusyLesHouches_verbose" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->verbose(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_verbose(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SusyLesHouches, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SusyLesHouches_verbose__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SusyLesHouches, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SusyLesHouches_verbose__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SusyLesHouches_verbose'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SusyLesHouches::verbose()\n"
    "    Pythia8::SusyLesHouches::verbose(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_message__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  int arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SusyLesHouches_message",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_message" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SusyLesHouches_message" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SusyLesHouches_message" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SusyLesHouches_message" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SusyLesHouches_message" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  (arg1)->message(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_message__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  int arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SusyLesHouches_message",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SusyLesHouches_message" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SusyLesHouches_message" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SusyLesHouches_message" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SusyLesHouches_message" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->message(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SusyLesHouches_message(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SusyLesHouches, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SusyLesHouches_message__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SusyLesHouches, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SusyLesHouches_message__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SusyLesHouches_message'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SusyLesHouches::message(int,std::string,std::string,int)\n"
    "    Pythia8::SusyLesHouches::message(int,std::string,std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SusyLesHouches(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SusyLesHouches *arg1 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SusyLesHouches",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SusyLesHouches, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SusyLesHouches" "', argument " "1"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SusyLesHouches_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SusyLesHouches, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_WeakShowerMEs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::WeakShowerMEs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_WeakShowerMEs")) SWIG_fail;
  result = (Pythia8::WeakShowerMEs *)new Pythia8::WeakShowerMEs();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__WeakShowerMEs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeakShowerMEs_getMEqg2qg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::WeakShowerMEs *arg1 = (Pythia8::WeakShowerMEs *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:WeakShowerMEs_getMEqg2qg",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__WeakShowerMEs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeakShowerMEs_getMEqg2qg" "', argument " "1"" of type '" "Pythia8::WeakShowerMEs *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::WeakShowerMEs * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeakShowerMEs_getMEqg2qg" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "WeakShowerMEs_getMEqg2qg" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "WeakShowerMEs_getMEqg2qg" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->getMEqg2qg(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeakShowerMEs_getMEqq2qq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::WeakShowerMEs *arg1 = (Pythia8::WeakShowerMEs *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:WeakShowerMEs_getMEqq2qq",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__WeakShowerMEs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeakShowerMEs_getMEqq2qq" "', argument " "1"" of type '" "Pythia8::WeakShowerMEs *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::WeakShowerMEs * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeakShowerMEs_getMEqq2qq" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "WeakShowerMEs_getMEqq2qq" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "WeakShowerMEs_getMEqq2qq" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "WeakShowerMEs_getMEqq2qq" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (double)(arg1)->getMEqq2qq(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeakShowerMEs_getMEgg2gg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::WeakShowerMEs *arg1 = (Pythia8::WeakShowerMEs *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:WeakShowerMEs_getMEgg2gg",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__WeakShowerMEs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeakShowerMEs_getMEgg2gg" "', argument " "1"" of type '" "Pythia8::WeakShowerMEs *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::WeakShowerMEs * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeakShowerMEs_getMEgg2gg" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "WeakShowerMEs_getMEgg2gg" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "WeakShowerMEs_getMEgg2gg" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->getMEgg2gg(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeakShowerMEs_getMEgg2qqbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::WeakShowerMEs *arg1 = (Pythia8::WeakShowerMEs *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:WeakShowerMEs_getMEgg2qqbar",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__WeakShowerMEs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeakShowerMEs_getMEgg2qqbar" "', argument " "1"" of type '" "Pythia8::WeakShowerMEs *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::WeakShowerMEs * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeakShowerMEs_getMEgg2qqbar" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "WeakShowerMEs_getMEgg2qqbar" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "WeakShowerMEs_getMEgg2qqbar" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->getMEgg2qqbar(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeakShowerMEs_getMEqqbar2gg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::WeakShowerMEs *arg1 = (Pythia8::WeakShowerMEs *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:WeakShowerMEs_getMEqqbar2gg",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__WeakShowerMEs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeakShowerMEs_getMEqqbar2gg" "', argument " "1"" of type '" "Pythia8::WeakShowerMEs *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::WeakShowerMEs * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeakShowerMEs_getMEqqbar2gg" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "WeakShowerMEs_getMEqqbar2gg" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "WeakShowerMEs_getMEqqbar2gg" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->getMEqqbar2gg(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeakShowerMEs_getMEqqbar2qqbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::WeakShowerMEs *arg1 = (Pythia8::WeakShowerMEs *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:WeakShowerMEs_getMEqqbar2qqbar",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__WeakShowerMEs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeakShowerMEs_getMEqqbar2qqbar" "', argument " "1"" of type '" "Pythia8::WeakShowerMEs *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::WeakShowerMEs * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeakShowerMEs_getMEqqbar2qqbar" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "WeakShowerMEs_getMEqqbar2qqbar" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "WeakShowerMEs_getMEqqbar2qqbar" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "WeakShowerMEs_getMEqqbar2qqbar" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (double)(arg1)->getMEqqbar2qqbar(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeakShowerMEs_getMEqg2qgZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::WeakShowerMEs *arg1 = (Pythia8::WeakShowerMEs *) 0 ;
  Pythia8::Vec4 arg2 ;
  Pythia8::Vec4 arg3 ;
  Pythia8::Vec4 arg4 ;
  Pythia8::Vec4 arg5 ;
  Pythia8::Vec4 arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:WeakShowerMEs_getMEqg2qgZ",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__WeakShowerMEs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeakShowerMEs_getMEqg2qgZ" "', argument " "1"" of type '" "Pythia8::WeakShowerMEs *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::WeakShowerMEs * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeakShowerMEs_getMEqg2qgZ" "', argument " "2"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeakShowerMEs_getMEqg2qgZ" "', argument " "2"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "WeakShowerMEs_getMEqg2qgZ" "', argument " "3"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeakShowerMEs_getMEqg2qgZ" "', argument " "3"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "WeakShowerMEs_getMEqg2qgZ" "', argument " "4"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeakShowerMEs_getMEqg2qgZ" "', argument " "4"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "WeakShowerMEs_getMEqg2qgZ" "', argument " "5"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeakShowerMEs_getMEqg2qgZ" "', argument " "5"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "WeakShowerMEs_getMEqg2qgZ" "', argument " "6"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeakShowerMEs_getMEqg2qgZ" "', argument " "6"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  result = (double)(arg1)->getMEqg2qgZ(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WeakShowerMEs_getMEqq2qqZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::WeakShowerMEs *arg1 = (Pythia8::WeakShowerMEs *) 0 ;
  Pythia8::Vec4 arg2 ;
  Pythia8::Vec4 arg3 ;
  Pythia8::Vec4 arg4 ;
  Pythia8::Vec4 arg5 ;
  Pythia8::Vec4 arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:WeakShowerMEs_getMEqq2qqZ",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__WeakShowerMEs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeakShowerMEs_getMEqq2qqZ" "', argument " "1"" of type '" "Pythia8::WeakShowerMEs *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::WeakShowerMEs * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeakShowerMEs_getMEqq2qqZ" "', argument " "2"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeakShowerMEs_getMEqq2qqZ" "', argument " "2"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "WeakShowerMEs_getMEqq2qqZ" "', argument " "3"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeakShowerMEs_getMEqq2qqZ" "', argument " "3"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "WeakShowerMEs_getMEqq2qqZ" "', argument " "4"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeakShowerMEs_getMEqq2qqZ" "', argument " "4"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "WeakShowerMEs_getMEqq2qqZ" "', argument " "5"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeakShowerMEs_getMEqq2qqZ" "', argument " "5"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "WeakShowerMEs_getMEqq2qqZ" "', argument " "6"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeakShowerMEs_getMEqq2qqZ" "', argument " "6"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  result = (double)(arg1)->getMEqq2qqZ(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_WeakShowerMEs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::WeakShowerMEs *arg1 = (Pythia8::WeakShowerMEs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_WeakShowerMEs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__WeakShowerMEs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WeakShowerMEs" "', argument " "1"" of type '" "Pythia8::WeakShowerMEs *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::WeakShowerMEs * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *WeakShowerMEs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__WeakShowerMEs, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Info")) SWIG_fail;
  result = (Pythia8::Info *)new Pythia8::Info();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Info, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_idA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_idA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_idA" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (int)((Pythia8::Info const *)arg1)->idA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_idB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_idB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_idB" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (int)((Pythia8::Info const *)arg1)->idB();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_pzA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_pzA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_pzA" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->pzA();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_pzB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_pzB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_pzB" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->pzB();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_eA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_eA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_eA" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->eA();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_eB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_eB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_eB" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->eB();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_mA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_mA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_mA" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->mA();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_mB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_mB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_mB" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->mB();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_eCM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_eCM",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_eCM" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->eCM();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_s(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_s",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_s" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->s();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_tooLowPTmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_tooLowPTmin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_tooLowPTmin" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (bool)((Pythia8::Info const *)arg1)->tooLowPTmin();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_name" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = ((Pythia8::Info const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_code" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (int)((Pythia8::Info const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_nFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_nFinal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_nFinal" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (int)((Pythia8::Info const *)arg1)->nFinal();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_isResolved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_isResolved",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_isResolved" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (bool)((Pythia8::Info const *)arg1)->isResolved();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_isDiffractiveA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_isDiffractiveA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_isDiffractiveA" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (bool)((Pythia8::Info const *)arg1)->isDiffractiveA();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_isDiffractiveB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_isDiffractiveB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_isDiffractiveB" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (bool)((Pythia8::Info const *)arg1)->isDiffractiveB();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_isDiffractiveC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_isDiffractiveC",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_isDiffractiveC" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (bool)((Pythia8::Info const *)arg1)->isDiffractiveC();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_isNonDiffractive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_isNonDiffractive",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_isNonDiffractive" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (bool)((Pythia8::Info const *)arg1)->isNonDiffractive();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_isMinBias(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_isMinBias",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_isMinBias" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (bool)((Pythia8::Info const *)arg1)->isMinBias();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_isLHA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_isLHA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_isLHA" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (bool)((Pythia8::Info const *)arg1)->isLHA();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_atEndOfFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_atEndOfFile",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_atEndOfFile" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (bool)((Pythia8::Info const *)arg1)->atEndOfFile();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_hasSub__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_hasSub",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_hasSub" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_hasSub" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)((Pythia8::Info const *)arg1)->hasSub(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_hasSub__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_hasSub",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_hasSub" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (bool)((Pythia8::Info const *)arg1)->hasSub();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_hasSub(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_hasSub__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_hasSub__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_hasSub'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::hasSub(int) const\n"
    "    Pythia8::Info::hasSub() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_nameSub__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_nameSub",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_nameSub" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_nameSub" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((Pythia8::Info const *)arg1)->nameSub(arg2);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_nameSub__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_nameSub",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_nameSub" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = ((Pythia8::Info const *)arg1)->nameSub();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_nameSub(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_nameSub__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_nameSub__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_nameSub'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::nameSub(int) const\n"
    "    Pythia8::Info::nameSub() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_codeSub__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_codeSub",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_codeSub" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_codeSub" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::Info const *)arg1)->codeSub(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_codeSub__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_codeSub",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_codeSub" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (int)((Pythia8::Info const *)arg1)->codeSub();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_codeSub(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_codeSub__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_codeSub__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_codeSub'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::codeSub(int) const\n"
    "    Pythia8::Info::codeSub() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_nFinalSub__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_nFinalSub",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_nFinalSub" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_nFinalSub" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::Info const *)arg1)->nFinalSub(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_nFinalSub__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_nFinalSub",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_nFinalSub" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (int)((Pythia8::Info const *)arg1)->nFinalSub();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_nFinalSub(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_nFinalSub__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_nFinalSub__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_nFinalSub'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::nFinalSub(int) const\n"
    "    Pythia8::Info::nFinalSub() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_id1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_id1",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_id1" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_id1" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::Info const *)arg1)->id1(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_id1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_id1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_id1" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (int)((Pythia8::Info const *)arg1)->id1();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_id1(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_id1__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_id1__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_id1'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::id1(int) const\n"
    "    Pythia8::Info::id1() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_id2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_id2",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_id2" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_id2" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::Info const *)arg1)->id2(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_id2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_id2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_id2" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (int)((Pythia8::Info const *)arg1)->id2();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_id2(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_id2__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_id2__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_id2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::id2(int) const\n"
    "    Pythia8::Info::id2() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_x1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_x1",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_x1" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_x1" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->x1(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_x1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_x1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_x1" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->x1();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_x1(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_x1__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_x1__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_x1'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::x1(int) const\n"
    "    Pythia8::Info::x1() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_x2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_x2",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_x2" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_x2" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->x2(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_x2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_x2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_x2" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->x2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_x2(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_x2__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_x2__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_x2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::x2(int) const\n"
    "    Pythia8::Info::x2() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_y__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_y",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_y" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_y" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->y(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_y__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_y",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_y" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->y();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_y(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_y__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_y__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_y'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::y(int) const\n"
    "    Pythia8::Info::y() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_tau__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_tau",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_tau" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_tau" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->tau(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_tau__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_tau",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_tau" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->tau();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_tau(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_tau__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_tau__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_tau'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::tau(int) const\n"
    "    Pythia8::Info::tau() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_id1pdf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_id1pdf",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_id1pdf" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_id1pdf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::Info const *)arg1)->id1pdf(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_id1pdf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_id1pdf",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_id1pdf" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (int)((Pythia8::Info const *)arg1)->id1pdf();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_id1pdf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_id1pdf__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_id1pdf__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_id1pdf'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::id1pdf(int) const\n"
    "    Pythia8::Info::id1pdf() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_id2pdf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_id2pdf",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_id2pdf" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_id2pdf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::Info const *)arg1)->id2pdf(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_id2pdf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_id2pdf",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_id2pdf" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (int)((Pythia8::Info const *)arg1)->id2pdf();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_id2pdf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_id2pdf__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_id2pdf__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_id2pdf'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::id2pdf(int) const\n"
    "    Pythia8::Info::id2pdf() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_x1pdf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_x1pdf",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_x1pdf" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_x1pdf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->x1pdf(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_x1pdf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_x1pdf",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_x1pdf" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->x1pdf();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_x1pdf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_x1pdf__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_x1pdf__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_x1pdf'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::x1pdf(int) const\n"
    "    Pythia8::Info::x1pdf() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_x2pdf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_x2pdf",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_x2pdf" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_x2pdf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->x2pdf(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_x2pdf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_x2pdf",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_x2pdf" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->x2pdf();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_x2pdf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_x2pdf__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_x2pdf__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_x2pdf'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::x2pdf(int) const\n"
    "    Pythia8::Info::x2pdf() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_pdf1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_pdf1",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_pdf1" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_pdf1" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->pdf1(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_pdf1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_pdf1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_pdf1" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->pdf1();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_pdf1(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_pdf1__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_pdf1__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_pdf1'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::pdf1(int) const\n"
    "    Pythia8::Info::pdf1() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_pdf2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_pdf2",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_pdf2" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_pdf2" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->pdf2(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_pdf2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_pdf2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_pdf2" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->pdf2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_pdf2(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_pdf2__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_pdf2__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_pdf2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::pdf2(int) const\n"
    "    Pythia8::Info::pdf2() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_QFac__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_QFac",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_QFac" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_QFac" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->QFac(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_QFac__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_QFac",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_QFac" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->QFac();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_QFac(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_QFac__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_QFac__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_QFac'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::QFac(int) const\n"
    "    Pythia8::Info::QFac() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_Q2Fac__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_Q2Fac",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_Q2Fac" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_Q2Fac" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->Q2Fac(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_Q2Fac__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_Q2Fac",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_Q2Fac" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->Q2Fac();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_Q2Fac(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_Q2Fac__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_Q2Fac__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_Q2Fac'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::Q2Fac(int) const\n"
    "    Pythia8::Info::Q2Fac() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_isValence1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_isValence1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_isValence1" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (bool)((Pythia8::Info const *)arg1)->isValence1();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_isValence2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_isValence2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_isValence2" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (bool)((Pythia8::Info const *)arg1)->isValence2();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_alphaS__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_alphaS",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_alphaS" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_alphaS" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->alphaS(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_alphaS__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_alphaS",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_alphaS" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->alphaS();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_alphaS(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_alphaS__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_alphaS__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_alphaS'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::alphaS(int) const\n"
    "    Pythia8::Info::alphaS() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_alphaEM__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_alphaEM",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_alphaEM" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_alphaEM" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->alphaEM(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_alphaEM__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_alphaEM",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_alphaEM" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->alphaEM();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_alphaEM(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_alphaEM__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_alphaEM__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_alphaEM'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::alphaEM(int) const\n"
    "    Pythia8::Info::alphaEM() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_QRen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_QRen",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_QRen" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_QRen" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->QRen(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_QRen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_QRen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_QRen" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->QRen();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_QRen(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_QRen__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_QRen__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_QRen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::QRen(int) const\n"
    "    Pythia8::Info::QRen() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_Q2Ren__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_Q2Ren",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_Q2Ren" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_Q2Ren" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->Q2Ren(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_Q2Ren__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_Q2Ren",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_Q2Ren" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->Q2Ren();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_Q2Ren(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_Q2Ren__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_Q2Ren__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_Q2Ren'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::Q2Ren(int) const\n"
    "    Pythia8::Info::Q2Ren() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_scalup__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_scalup",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_scalup" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_scalup" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->scalup(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_scalup__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_scalup",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_scalup" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->scalup();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_scalup(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_scalup__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_scalup__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_scalup'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::scalup(int) const\n"
    "    Pythia8::Info::scalup() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_xGammaA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_xGammaA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_xGammaA" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->xGammaA();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_xGammaB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_xGammaB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_xGammaB" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->xGammaB();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_Q2GammaA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_Q2GammaA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_Q2GammaA" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->Q2GammaA();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_Q2GammaB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_Q2GammaB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_Q2GammaB" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->Q2GammaB();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_eCMsub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_eCMsub",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_eCMsub" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->eCMsub();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_thetaScatLepA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_thetaScatLepA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_thetaScatLepA" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->thetaScatLepA();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_thetaScatLepB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_thetaScatLepB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_thetaScatLepB" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->thetaScatLepB();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_sHatNew(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_sHatNew",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_sHatNew" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->sHatNew();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_photonMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_photonMode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_photonMode" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (int)((Pythia8::Info const *)arg1)->photonMode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_isVMDstateA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_isVMDstateA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_isVMDstateA" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (bool)((Pythia8::Info const *)arg1)->isVMDstateA();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_isVMDstateB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_isVMDstateB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_isVMDstateB" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (bool)((Pythia8::Info const *)arg1)->isVMDstateB();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_idVMDA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_idVMDA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_idVMDA" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (int)((Pythia8::Info const *)arg1)->idVMDA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_idVMDB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_idVMDB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_idVMDB" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (int)((Pythia8::Info const *)arg1)->idVMDB();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_mVMDA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_mVMDA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_mVMDA" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->mVMDA();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_mVMDB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_mVMDB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_mVMDB" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->mVMDB();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_scaleVMDA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_scaleVMDA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_scaleVMDA" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->scaleVMDA();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_scaleVMDB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_scaleVMDB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_scaleVMDB" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->scaleVMDB();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_mHat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_mHat",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_mHat" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_mHat" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->mHat(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_mHat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_mHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_mHat" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->mHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_mHat(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_mHat__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_mHat__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_mHat'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::mHat(int) const\n"
    "    Pythia8::Info::mHat() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_sHat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_sHat",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_sHat" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_sHat" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->sHat(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_sHat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_sHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_sHat" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->sHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_sHat(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_sHat__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_sHat__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_sHat'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::sHat(int) const\n"
    "    Pythia8::Info::sHat() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_tHat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_tHat",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_tHat" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_tHat" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->tHat(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_tHat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_tHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_tHat" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->tHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_tHat(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_tHat__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_tHat__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_tHat'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::tHat(int) const\n"
    "    Pythia8::Info::tHat() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_uHat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_uHat",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_uHat" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_uHat" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->uHat(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_uHat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_uHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_uHat" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->uHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_uHat(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_uHat__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_uHat__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_uHat'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::uHat(int) const\n"
    "    Pythia8::Info::uHat() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_pTHat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_pTHat",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_pTHat" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_pTHat" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->pTHat(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_pTHat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_pTHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_pTHat" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->pTHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_pTHat(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_pTHat__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_pTHat__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_pTHat'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::pTHat(int) const\n"
    "    Pythia8::Info::pTHat() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_pT2Hat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_pT2Hat",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_pT2Hat" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_pT2Hat" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->pT2Hat(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_pT2Hat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_pT2Hat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_pT2Hat" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->pT2Hat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_pT2Hat(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_pT2Hat__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_pT2Hat__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_pT2Hat'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::pT2Hat(int) const\n"
    "    Pythia8::Info::pT2Hat() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_m3Hat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_m3Hat",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_m3Hat" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_m3Hat" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->m3Hat(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_m3Hat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_m3Hat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_m3Hat" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->m3Hat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_m3Hat(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_m3Hat__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_m3Hat__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_m3Hat'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::m3Hat(int) const\n"
    "    Pythia8::Info::m3Hat() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_m4Hat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_m4Hat",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_m4Hat" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_m4Hat" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->m4Hat(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_m4Hat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_m4Hat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_m4Hat" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->m4Hat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_m4Hat(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_m4Hat__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_m4Hat__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_m4Hat'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::m4Hat(int) const\n"
    "    Pythia8::Info::m4Hat() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_thetaHat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_thetaHat",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_thetaHat" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_thetaHat" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->thetaHat(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_thetaHat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_thetaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_thetaHat" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->thetaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_thetaHat(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_thetaHat__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_thetaHat__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_thetaHat'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::thetaHat(int) const\n"
    "    Pythia8::Info::thetaHat() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_phiHat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_phiHat",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_phiHat" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_phiHat" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->phiHat(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_phiHat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_phiHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_phiHat" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->phiHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_phiHat(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_phiHat__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_phiHat__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_phiHat'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::phiHat(int) const\n"
    "    Pythia8::Info::phiHat() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_weight__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_weight",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_weight" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_weight" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->weight(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_weight__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_weight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_weight" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->weight();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_weight(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_weight__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_weight__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_weight'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::weight(int) const\n"
    "    Pythia8::Info::weight() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_weightSum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_weightSum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_weightSum" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->weightSum();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_lhaStrategy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_lhaStrategy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_lhaStrategy" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->lhaStrategy();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_nWeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_nWeights",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_nWeights" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (int)(arg1)->nWeights();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_weightLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_weightLabel",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_weightLabel" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_weightLabel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (arg1)->weightLabel(arg2);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_initUncertainties__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = (std::vector< std::string,std::allocator< std::string > > *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Info_initUncertainties",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_initUncertainties" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Info_initUncertainties" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Info_initUncertainties" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->initUncertainties(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_initUncertainties__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = (std::vector< std::string,std::allocator< std::string > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_initUncertainties",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_initUncertainties" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Info_initUncertainties" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp2);
  (arg1)->initUncertainties(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_initUncertainties(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Info_initUncertainties__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Info_initUncertainties__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_initUncertainties'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::initUncertainties(std::vector< std::string,std::allocator< std::string > > *,bool)\n"
    "    Pythia8::Info::initUncertainties(std::vector< std::string,std::allocator< std::string > > *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_nVariationGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_nVariationGroups",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_nVariationGroups" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (int)(arg1)->nVariationGroups();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getGroupName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_getGroupName",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getGroupName" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_getGroupName" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (arg1)->getGroupName(arg2);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getGroupWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_getGroupWeight",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getGroupWeight" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_getGroupWeight" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->getGroupWeight(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getInitialName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_getInitialName",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getInitialName" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_getInitialName" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (arg1)->getInitialName(arg2);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_varPDFplus_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::map< int,double,std::less< int >,std::allocator< std::pair< int const,double > > > *arg2 = (std::map< int,double,std::less< int >,std::allocator< std::pair< int const,double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_varPDFplus_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_varPDFplus_set" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_int_double_std__lessT_int_t_std__allocatorT_std__pairT_int_const_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Info_varPDFplus_set" "', argument " "2"" of type '" "std::map< int,double,std::less< int >,std::allocator< std::pair< int const,double > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< int,double,std::less< int >,std::allocator< std::pair< int const,double > > > * >(argp2);
  if (arg1) (arg1)->varPDFplus = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_varPDFplus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< int,double,std::less< int >,std::allocator< std::pair< int const,double > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_varPDFplus_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_varPDFplus_get" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (std::map< int,double,std::less< int >,std::allocator< std::pair< int const,double > > > *)& ((arg1)->varPDFplus);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_int_double_std__lessT_int_t_std__allocatorT_std__pairT_int_const_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_varPDFminus_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::map< int,double,std::less< int >,std::allocator< std::pair< int const,double > > > *arg2 = (std::map< int,double,std::less< int >,std::allocator< std::pair< int const,double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_varPDFminus_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_varPDFminus_set" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_int_double_std__lessT_int_t_std__allocatorT_std__pairT_int_const_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Info_varPDFminus_set" "', argument " "2"" of type '" "std::map< int,double,std::less< int >,std::allocator< std::pair< int const,double > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< int,double,std::less< int >,std::allocator< std::pair< int const,double > > > * >(argp2);
  if (arg1) (arg1)->varPDFminus = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_varPDFminus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< int,double,std::less< int >,std::allocator< std::pair< int const,double > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_varPDFminus_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_varPDFminus_get" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (std::map< int,double,std::less< int >,std::allocator< std::pair< int const,double > > > *)& ((arg1)->varPDFminus);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_int_double_std__lessT_int_t_std__allocatorT_std__pairT_int_const_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_varPDFmember_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::map< int,double,std::less< int >,std::allocator< std::pair< int const,double > > > *arg2 = (std::map< int,double,std::less< int >,std::allocator< std::pair< int const,double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_varPDFmember_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_varPDFmember_set" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_int_double_std__lessT_int_t_std__allocatorT_std__pairT_int_const_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Info_varPDFmember_set" "', argument " "2"" of type '" "std::map< int,double,std::less< int >,std::allocator< std::pair< int const,double > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< int,double,std::less< int >,std::allocator< std::pair< int const,double > > > * >(argp2);
  if (arg1) (arg1)->varPDFmember = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_varPDFmember_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< int,double,std::less< int >,std::allocator< std::pair< int const,double > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_varPDFmember_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_varPDFmember_get" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (std::map< int,double,std::less< int >,std::allocator< std::pair< int const,double > > > *)& ((arg1)->varPDFmember);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_int_double_std__lessT_int_t_std__allocatorT_std__pairT_int_const_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_nISR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_nISR",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_nISR" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (int)((Pythia8::Info const *)arg1)->nISR();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_nFSRinProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_nFSRinProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_nFSRinProc" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (int)((Pythia8::Info const *)arg1)->nFSRinProc();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_nFSRinRes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_nFSRinRes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_nFSRinRes" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (int)((Pythia8::Info const *)arg1)->nFSRinRes();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_pTmaxMPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_pTmaxMPI",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_pTmaxMPI" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->pTmaxMPI();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_pTmaxISR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_pTmaxISR",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_pTmaxISR" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->pTmaxISR();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_pTmaxFSR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_pTmaxFSR",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_pTmaxFSR" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->pTmaxFSR();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_pTnow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_pTnow",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_pTnow" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->pTnow();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_a0MPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_a0MPI",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_a0MPI" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->a0MPI();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_bMPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_bMPI",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_bMPI" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->bMPI();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_enhanceMPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_enhanceMPI",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_enhanceMPI" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->enhanceMPI();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_enhanceMPIavg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_enhanceMPIavg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_enhanceMPIavg" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->enhanceMPIavg();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_eMPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_eMPI",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_eMPI" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_eMPI" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->eMPI(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_bMPIold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_bMPIold",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_bMPIold" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->bMPIold();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_enhanceMPIold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_enhanceMPIold",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_enhanceMPIold" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->enhanceMPIold();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_enhanceMPIoldavg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_enhanceMPIoldavg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_enhanceMPIoldavg" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->enhanceMPIoldavg();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_nMPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_nMPI",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_nMPI" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (int)((Pythia8::Info const *)arg1)->nMPI();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_codeMPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_codeMPI",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_codeMPI" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_codeMPI" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::Info const *)arg1)->codeMPI(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_pTMPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_pTMPI",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_pTMPI" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_pTMPI" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Info const *)arg1)->pTMPI(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_iAMPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_iAMPI",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_iAMPI" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_iAMPI" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::Info const *)arg1)->iAMPI(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_iBMPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_iBMPI",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_iBMPI" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_iBMPI" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::Info const *)arg1)->iBMPI(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_codesHard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int,std::allocator< int > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_codesHard",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_codesHard" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (arg1)->codesHard();
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_nameProc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_nameProc",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_nameProc" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_nameProc" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (arg1)->nameProc(arg2);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_nameProc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_nameProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_nameProc" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (arg1)->nameProc();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_nameProc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_nameProc__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_nameProc__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_nameProc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::nameProc(int)\n"
    "    Pythia8::Info::nameProc()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_nTried__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  long result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_nTried",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_nTried" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_nTried" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (long)(arg1)->nTried(arg2);
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_nTried__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  long result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_nTried",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_nTried" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (long)(arg1)->nTried();
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_nTried(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_nTried__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_nTried__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_nTried'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::nTried(int)\n"
    "    Pythia8::Info::nTried()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_nSelected__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  long result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_nSelected",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_nSelected" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_nSelected" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (long)(arg1)->nSelected(arg2);
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_nSelected__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  long result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_nSelected",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_nSelected" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (long)(arg1)->nSelected();
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_nSelected(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_nSelected__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_nSelected__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_nSelected'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::nSelected(int)\n"
    "    Pythia8::Info::nSelected()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_nAccepted__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  long result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_nAccepted",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_nAccepted" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_nAccepted" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (long)(arg1)->nAccepted(arg2);
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_nAccepted__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  long result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_nAccepted",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_nAccepted" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (long)(arg1)->nAccepted();
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_nAccepted(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_nAccepted__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_nAccepted__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_nAccepted'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::nAccepted(int)\n"
    "    Pythia8::Info::nAccepted()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_sigmaGen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_sigmaGen",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_sigmaGen" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_sigmaGen" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->sigmaGen(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_sigmaGen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_sigmaGen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_sigmaGen" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)(arg1)->sigmaGen();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_sigmaGen(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_sigmaGen__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_sigmaGen__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_sigmaGen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::sigmaGen(int)\n"
    "    Pythia8::Info::sigmaGen()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_sigmaErr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_sigmaErr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_sigmaErr" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_sigmaErr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->sigmaErr(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_sigmaErr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_sigmaErr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_sigmaErr" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)(arg1)->sigmaErr();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_sigmaErr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_sigmaErr__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_sigmaErr__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_sigmaErr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::sigmaErr(int)\n"
    "    Pythia8::Info::sigmaErr()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_getCounter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_getCounter",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getCounter" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_getCounter" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::Info const *)arg1)->getCounter(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_setCounter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Info_setCounter",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_setCounter" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_setCounter" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Info_setCounter" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->setCounter(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_setCounter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_setCounter",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_setCounter" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_setCounter" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setCounter(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_setCounter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_setCounter__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Info_setCounter__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_setCounter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::setCounter(int,int)\n"
    "    Pythia8::Info::setCounter(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_addCounter__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Info_addCounter",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_addCounter" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_addCounter" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Info_addCounter" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->addCounter(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_addCounter__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_addCounter",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_addCounter" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_addCounter" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->addCounter(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_addCounter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_addCounter__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Info_addCounter__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_addCounter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::addCounter(int,int)\n"
    "    Pythia8::Info::addCounter(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_errorReset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_errorReset",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_errorReset" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  (arg1)->errorReset();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_errorMsg__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Info_errorMsg",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_errorMsg" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Info_errorMsg" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Info_errorMsg" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Info_errorMsg" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->errorMsg(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_errorMsg__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Info_errorMsg",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_errorMsg" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Info_errorMsg" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Info_errorMsg" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->errorMsg(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_errorMsg__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_errorMsg",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_errorMsg" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Info_errorMsg" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->errorMsg(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_errorMsg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Info_errorMsg__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Info_errorMsg__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Info_errorMsg__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_errorMsg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::errorMsg(std::string,std::string,bool)\n"
    "    Pythia8::Info::errorMsg(std::string,std::string)\n"
    "    Pythia8::Info::errorMsg(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_errorTotalNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_errorTotalNumber",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_errorTotalNumber" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (int)(arg1)->errorTotalNumber();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_errorStatistics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_errorStatistics",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_errorStatistics" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  (arg1)->errorStatistics();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_setTooLowPTmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_setTooLowPTmin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_setTooLowPTmin" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_setTooLowPTmin" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setTooLowPTmin(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_setValence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Info_setValence",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_setValence" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_setValence" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Info_setValence" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setValence(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_hasHistory__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_hasHistory",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_hasHistory" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_hasHistory" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->hasHistory(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_hasHistory__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_hasHistory",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_hasHistory" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (bool)(arg1)->hasHistory();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_hasHistory(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_hasHistory__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_hasHistory__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_hasHistory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::hasHistory(bool)\n"
    "    Pythia8::Info::hasHistory()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_zNowISR__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_zNowISR",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_zNowISR" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_zNowISR" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->zNowISR(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_zNowISR__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_zNowISR",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_zNowISR" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)(arg1)->zNowISR();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_zNowISR(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_zNowISR__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_zNowISR__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_zNowISR'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::zNowISR(double)\n"
    "    Pythia8::Info::zNowISR()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_pT2NowISR__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_pT2NowISR",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_pT2NowISR" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_pT2NowISR" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->pT2NowISR(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_pT2NowISR__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_pT2NowISR",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_pT2NowISR" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)(arg1)->pT2NowISR();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_pT2NowISR(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_pT2NowISR__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_pT2NowISR__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_pT2NowISR'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::pT2NowISR(double)\n"
    "    Pythia8::Info::pT2NowISR()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_updateWeight__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  double arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Info_updateWeight",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_updateWeight" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_updateWeight" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Info_updateWeight" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->updateWeight(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_updateWeight__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_updateWeight",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_updateWeight" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_updateWeight" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->updateWeight(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_updateWeight(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_updateWeight__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Info_updateWeight__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_updateWeight'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::updateWeight(double,int)\n"
    "    Pythia8::Info::updateWeight(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_getWeightCKKWL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_getWeightCKKWL",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getWeightCKKWL" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->getWeightCKKWL();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_setWeightCKKWL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_setWeightCKKWL",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_setWeightCKKWL" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_setWeightCKKWL" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setWeightCKKWL(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_mergingWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_mergingWeight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_mergingWeight" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->mergingWeight();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_mergingWeightNLO(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_mergingWeightNLO",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_mergingWeightNLO" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->mergingWeightNLO();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getWeightFIRST(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_getWeightFIRST",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getWeightFIRST" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->getWeightFIRST();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_setWeightFIRST(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_setWeightFIRST",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_setWeightFIRST" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_setWeightFIRST" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setWeightFIRST(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_header(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_header",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_header" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Info_header" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Info_header" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->header((std::string const &)*arg2);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_headerKeys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_headerKeys",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_headerKeys" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (arg1)->headerKeys();
  resultobj = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_nProcessesLHEF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_nProcessesLHEF",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_nProcessesLHEF" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (int)(arg1)->nProcessesLHEF();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_sigmaLHEF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_sigmaLHEF",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_sigmaLHEF" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_sigmaLHEF" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->sigmaLHEF(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_LHEFversionSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_LHEFversionSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_LHEFversionSave_set" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_LHEFversionSave_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->LHEFversionSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_LHEFversionSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_LHEFversionSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_LHEFversionSave_get" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (int) ((arg1)->LHEFversionSave);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_sigmaLHEFSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = (std::vector< double,std::allocator< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_sigmaLHEFSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_sigmaLHEFSave_set" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Info_sigmaLHEFSave_set" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp2);
  if (arg1) (arg1)->sigmaLHEFSave = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_sigmaLHEFSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_sigmaLHEFSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_sigmaLHEFSave_get" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (std::vector< double,std::allocator< double > > *)& ((arg1)->sigmaLHEFSave);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_initrwgt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  Pythia8::LHAinitrwgt *arg2 = (Pythia8::LHAinitrwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_initrwgt_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_initrwgt_set" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHAinitrwgt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Info_initrwgt_set" "', argument " "2"" of type '" "Pythia8::LHAinitrwgt *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHAinitrwgt * >(argp2);
  if (arg1) (arg1)->initrwgt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_initrwgt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHAinitrwgt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_initrwgt_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_initrwgt_get" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (Pythia8::LHAinitrwgt *) ((arg1)->initrwgt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAinitrwgt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_generators_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::vector< Pythia8::LHAgenerator,std::allocator< Pythia8::LHAgenerator > > *arg2 = (std::vector< Pythia8::LHAgenerator,std::allocator< Pythia8::LHAgenerator > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_generators_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_generators_set" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_Pythia8__LHAgenerator_std__allocatorT_Pythia8__LHAgenerator_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Info_generators_set" "', argument " "2"" of type '" "std::vector< Pythia8::LHAgenerator,std::allocator< Pythia8::LHAgenerator > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::LHAgenerator,std::allocator< Pythia8::LHAgenerator > > * >(argp2);
  if (arg1) (arg1)->generators = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_generators_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::LHAgenerator,std::allocator< Pythia8::LHAgenerator > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_generators_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_generators_get" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (std::vector< Pythia8::LHAgenerator,std::allocator< Pythia8::LHAgenerator > > *) ((arg1)->generators);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__LHAgenerator_std__allocatorT_Pythia8__LHAgenerator_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_weightgroups_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::map< std::string,Pythia8::LHAweightgroup,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweightgroup > > > *arg2 = (std::map< std::string,Pythia8::LHAweightgroup,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweightgroup > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_weightgroups_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_weightgroups_set" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAweightgroup_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweightgroup_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Info_weightgroups_set" "', argument " "2"" of type '" "std::map< std::string,Pythia8::LHAweightgroup,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweightgroup > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,Pythia8::LHAweightgroup,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweightgroup > > > * >(argp2);
  if (arg1) (arg1)->weightgroups = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_weightgroups_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::LHAweightgroup,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweightgroup > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_weightgroups_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_weightgroups_get" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (std::map< std::string,Pythia8::LHAweightgroup,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweightgroup > > > *) ((arg1)->weightgroups);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAweightgroup_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweightgroup_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_init_weights_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > *arg2 = (std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_init_weights_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_init_weights_set" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAweight_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweight_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Info_init_weights_set" "', argument " "2"" of type '" "std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > * >(argp2);
  if (arg1) (arg1)->init_weights = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_init_weights_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_init_weights_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_init_weights_get" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > *) ((arg1)->init_weights);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAweight_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweight_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_eventAttributes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *arg2 = (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_eventAttributes_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_eventAttributes_set" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Info_eventAttributes_set" "', argument " "2"" of type '" "std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > * >(argp2);
  if (arg1) (arg1)->eventAttributes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_eventAttributes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_eventAttributes_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_eventAttributes_get" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *) ((arg1)->eventAttributes);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_weights_detailed_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > *arg2 = (std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_weights_detailed_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_weights_detailed_set" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Info_weights_detailed_set" "', argument " "2"" of type '" "std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > * >(argp2);
  if (arg1) (arg1)->weights_detailed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_weights_detailed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_weights_detailed_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_weights_detailed_get" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > *) ((arg1)->weights_detailed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_weights_compressed_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = (std::vector< double,std::allocator< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_weights_compressed_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_weights_compressed_set" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Info_weights_compressed_set" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp2);
  if (arg1) (arg1)->weights_compressed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_weights_compressed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_weights_compressed_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_weights_compressed_get" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (std::vector< double,std::allocator< double > > *) ((arg1)->weights_compressed);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_scales_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  Pythia8::LHAscales *arg2 = (Pythia8::LHAscales *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_scales_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_scales_set" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHAscales, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Info_scales_set" "', argument " "2"" of type '" "Pythia8::LHAscales *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHAscales * >(argp2);
  if (arg1) (arg1)->scales = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_scales_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHAscales *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_scales_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_scales_get" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (Pythia8::LHAscales *) ((arg1)->scales);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAscales, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_weights_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  Pythia8::LHAweights *arg2 = (Pythia8::LHAweights *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_weights_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_weights_set" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHAweights, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Info_weights_set" "', argument " "2"" of type '" "Pythia8::LHAweights *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHAweights * >(argp2);
  if (arg1) (arg1)->weights = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_weights_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHAweights *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_weights_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_weights_get" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (Pythia8::LHAweights *) ((arg1)->weights);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAweights, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_rwgt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  Pythia8::LHArwgt *arg2 = (Pythia8::LHArwgt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_rwgt_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_rwgt_set" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHArwgt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Info_rwgt_set" "', argument " "2"" of type '" "Pythia8::LHArwgt *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHArwgt * >(argp2);
  if (arg1) (arg1)->rwgt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_rwgt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHArwgt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_rwgt_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_rwgt_get" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (Pythia8::LHArwgt *) ((arg1)->rwgt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHArwgt, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_eventWeightLHEF_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_eventWeightLHEF_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_eventWeightLHEF_set" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_eventWeightLHEF_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->eventWeightLHEF = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_eventWeightLHEF_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_eventWeightLHEF_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_eventWeightLHEF_get" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double) ((arg1)->eventWeightLHEF);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_setLHEF3InitInfo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_setLHEF3InitInfo",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_setLHEF3InitInfo" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  (arg1)->setLHEF3InitInfo();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_setLHEF3InitInfo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  int arg2 ;
  Pythia8::LHAinitrwgt *arg3 = (Pythia8::LHAinitrwgt *) 0 ;
  std::vector< Pythia8::LHAgenerator,std::allocator< Pythia8::LHAgenerator > > *arg4 = (std::vector< Pythia8::LHAgenerator,std::allocator< Pythia8::LHAgenerator > > *) 0 ;
  std::map< std::string,Pythia8::LHAweightgroup,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweightgroup > > > *arg5 = (std::map< std::string,Pythia8::LHAweightgroup,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweightgroup > > > *) 0 ;
  std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > *arg6 = (std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > *) 0 ;
  std::string arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Info_setLHEF3InitInfo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_setLHEF3InitInfo" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_setLHEF3InitInfo" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__LHAinitrwgt, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Info_setLHEF3InitInfo" "', argument " "3"" of type '" "Pythia8::LHAinitrwgt *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::LHAinitrwgt * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_std__vectorT_Pythia8__LHAgenerator_std__allocatorT_Pythia8__LHAgenerator_t_t, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Info_setLHEF3InitInfo" "', argument " "4"" of type '" "std::vector< Pythia8::LHAgenerator,std::allocator< Pythia8::LHAgenerator > > *""'"); 
  }
  arg4 = reinterpret_cast< std::vector< Pythia8::LHAgenerator,std::allocator< Pythia8::LHAgenerator > > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAweightgroup_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweightgroup_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Info_setLHEF3InitInfo" "', argument " "5"" of type '" "std::map< std::string,Pythia8::LHAweightgroup,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweightgroup > > > *""'"); 
  }
  arg5 = reinterpret_cast< std::map< std::string,Pythia8::LHAweightgroup,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweightgroup > > > * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAweight_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweight_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Info_setLHEF3InitInfo" "', argument " "6"" of type '" "std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > *""'"); 
  }
  arg6 = reinterpret_cast< std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > * >(argp6);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Info_setLHEF3InitInfo" "', argument " "7"" of type '" "std::string""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->setLHEF3InitInfo(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_setLHEF3InitInfo(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_setLHEF3InitInfo__SWIG_0(self, args);
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__LHAinitrwgt, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__vectorT_Pythia8__LHAgenerator_std__allocatorT_Pythia8__LHAgenerator_t_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAweightgroup_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweightgroup_t_t_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_std__mapT_std__string_Pythia8__LHAweight_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweight_t_t_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_Info_setLHEF3InitInfo__SWIG_1(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_setLHEF3InitInfo'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::setLHEF3InitInfo()\n"
    "    Pythia8::Info::setLHEF3InitInfo(int,Pythia8::LHAinitrwgt *,std::vector< Pythia8::LHAgenerator,std::allocator< Pythia8::LHAgenerator > > *,std::map< std::string,Pythia8::LHAweightgroup,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweightgroup > > > *,std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > *,std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_setLHEF3EventInfo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_setLHEF3EventInfo",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_setLHEF3EventInfo" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  (arg1)->setLHEF3EventInfo();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_setLHEF3EventInfo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *arg2 = (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *) 0 ;
  std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > *arg3 = (std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > *) 0 ;
  std::vector< double,std::allocator< double > > *arg4 = (std::vector< double,std::allocator< double > > *) 0 ;
  Pythia8::LHAscales *arg5 = (Pythia8::LHAscales *) 0 ;
  Pythia8::LHAweights *arg6 = (Pythia8::LHAweights *) 0 ;
  Pythia8::LHArwgt *arg7 = (Pythia8::LHArwgt *) 0 ;
  std::vector< double,std::allocator< double > > arg8 ;
  std::string arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Info_setLHEF3EventInfo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_setLHEF3EventInfo" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Info_setLHEF3EventInfo" "', argument " "2"" of type '" "std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Info_setLHEF3EventInfo" "', argument " "3"" of type '" "std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > *""'"); 
  }
  arg3 = reinterpret_cast< std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Info_setLHEF3EventInfo" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > *""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__LHAscales, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Info_setLHEF3EventInfo" "', argument " "5"" of type '" "Pythia8::LHAscales *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::LHAscales * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__LHAweights, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Info_setLHEF3EventInfo" "', argument " "6"" of type '" "Pythia8::LHAweights *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::LHAweights * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__LHArwgt, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Info_setLHEF3EventInfo" "', argument " "7"" of type '" "Pythia8::LHArwgt *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::LHArwgt * >(argp7);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj7, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Info_setLHEF3EventInfo" "', argument " "8"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg8 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj8, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Info_setLHEF3EventInfo" "', argument " "9"" of type '" "std::string""'"); 
    }
    arg9 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Info_setLHEF3EventInfo" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  (arg1)->setLHEF3EventInfo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_setLHEF3EventInfo(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 10) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_setLHEF3EventInfo__SWIG_0(self, args);
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__LHAscales, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__LHAweights, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__LHArwgt, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = swig::asptr(argv[7], (std::vector< double,std::allocator< double > >**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    int res = SWIG_AsPtr_std_string(argv[8], (std::string**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Info_setLHEF3EventInfo__SWIG_1(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_setLHEF3EventInfo'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::setLHEF3EventInfo()\n"
    "    Pythia8::Info::setLHEF3EventInfo(std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *,std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > *,std::vector< double,std::allocator< double > > *,Pythia8::LHAscales *,Pythia8::LHAweights *,Pythia8::LHArwgt *,std::vector< double,std::allocator< double > >,std::string,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_getEventAttribute__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Info_getEventAttribute",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getEventAttribute" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Info_getEventAttribute" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Info_getEventAttribute" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (arg1)->getEventAttribute(arg2,arg3);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getEventAttribute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_getEventAttribute",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getEventAttribute" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Info_getEventAttribute" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->getEventAttribute(arg2);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getEventAttribute(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Info_getEventAttribute__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Info_getEventAttribute__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_getEventAttribute'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::getEventAttribute(std::string,bool)\n"
    "    Pythia8::Info::getEventAttribute(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_LHEFversion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_LHEFversion",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_LHEFversion" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (int)(arg1)->LHEFversion();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getInitrwgtSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  unsigned int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_getInitrwgtSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getInitrwgtSize" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (unsigned int)(arg1)->getInitrwgtSize();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getGeneratorSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  unsigned int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_getGeneratorSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getGeneratorSize" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (unsigned int)(arg1)->getGeneratorSize();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getGeneratorValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_getGeneratorValue",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getGeneratorValue" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_getGeneratorValue" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (arg1)->getGeneratorValue(arg2);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getGeneratorValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_getGeneratorValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getGeneratorValue" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (arg1)->getGeneratorValue();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getGeneratorValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_getGeneratorValue__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_getGeneratorValue__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_getGeneratorValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::getGeneratorValue(unsigned int)\n"
    "    Pythia8::Info::getGeneratorValue()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_getGeneratorAttribute__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  unsigned int arg2 ;
  std::string arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Info_getGeneratorAttribute",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getGeneratorAttribute" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_getGeneratorAttribute" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Info_getGeneratorAttribute" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Info_getGeneratorAttribute" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (arg1)->getGeneratorAttribute(arg2,arg3,arg4);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getGeneratorAttribute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  unsigned int arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Info_getGeneratorAttribute",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getGeneratorAttribute" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_getGeneratorAttribute" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Info_getGeneratorAttribute" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->getGeneratorAttribute(arg2,arg3);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getGeneratorAttribute(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Info_getGeneratorAttribute__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Info_getGeneratorAttribute__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_getGeneratorAttribute'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::getGeneratorAttribute(unsigned int,std::string,bool)\n"
    "    Pythia8::Info::getGeneratorAttribute(unsigned int,std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_getWeightsDetailedSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  unsigned int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_getWeightsDetailedSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getWeightsDetailedSize" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (unsigned int)(arg1)->getWeightsDetailedSize();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getWeightsDetailedValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_getWeightsDetailedValue",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getWeightsDetailedValue" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Info_getWeightsDetailedValue" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->getWeightsDetailedValue(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getWeightsDetailedAttribute__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Info_getWeightsDetailedAttribute",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getWeightsDetailedAttribute" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Info_getWeightsDetailedAttribute" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Info_getWeightsDetailedAttribute" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Info_getWeightsDetailedAttribute" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (arg1)->getWeightsDetailedAttribute(arg2,arg3,arg4);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getWeightsDetailedAttribute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Info_getWeightsDetailedAttribute",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getWeightsDetailedAttribute" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Info_getWeightsDetailedAttribute" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Info_getWeightsDetailedAttribute" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->getWeightsDetailedAttribute(arg2,arg3);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getWeightsDetailedAttribute(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Info_getWeightsDetailedAttribute__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Info_getWeightsDetailedAttribute__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_getWeightsDetailedAttribute'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::getWeightsDetailedAttribute(std::string,std::string,bool)\n"
    "    Pythia8::Info::getWeightsDetailedAttribute(std::string,std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_getWeightsCompressedSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  unsigned int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_getWeightsCompressedSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getWeightsCompressedSize" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (unsigned int)(arg1)->getWeightsCompressedSize();
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getWeightsCompressedValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_getWeightsCompressedValue",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getWeightsCompressedValue" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_getWeightsCompressedValue" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (double)(arg1)->getWeightsCompressedValue(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getWeightsCompressedAttribute__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Info_getWeightsCompressedAttribute",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getWeightsCompressedAttribute" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Info_getWeightsCompressedAttribute" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Info_getWeightsCompressedAttribute" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (arg1)->getWeightsCompressedAttribute(arg2,arg3);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getWeightsCompressedAttribute__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_getWeightsCompressedAttribute",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getWeightsCompressedAttribute" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Info_getWeightsCompressedAttribute" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->getWeightsCompressedAttribute(arg2);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getWeightsCompressedAttribute(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Info_getWeightsCompressedAttribute__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Info_getWeightsCompressedAttribute__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_getWeightsCompressedAttribute'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::getWeightsCompressedAttribute(std::string,bool)\n"
    "    Pythia8::Info::getWeightsCompressedAttribute(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_getScalesValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_getScalesValue",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getScalesValue" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_getScalesValue" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (arg1)->getScalesValue(arg2);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getScalesValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_getScalesValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getScalesValue" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (arg1)->getScalesValue();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getScalesValue(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Info_getScalesValue__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Info_getScalesValue__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Info_getScalesValue'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Info::getScalesValue(bool)\n"
    "    Pythia8::Info::getScalesValue()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Info_getScalesAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_getScalesAttribute",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getScalesAttribute" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Info_getScalesAttribute" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->getScalesAttribute(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getHeaderBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_getHeaderBlock",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getHeaderBlock" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (arg1)->getHeaderBlock();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getEventComments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_getEventComments",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getEventComments" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (arg1)->getEventComments();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_setHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Info_setHeader",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_setHeader" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Info_setHeader" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Info_setHeader" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Info_setHeader" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Info_setHeader" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->setHeader((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_setAbortPartonLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_setAbortPartonLevel",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_setAbortPartonLevel" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Info_setAbortPartonLevel" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setAbortPartonLevel(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getAbortPartonLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_getAbortPartonLevel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getAbortPartonLevel" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (bool)(arg1)->getAbortPartonLevel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_hasUnresolvedBeams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_hasUnresolvedBeams",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_hasUnresolvedBeams" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (bool)((Pythia8::Info const *)arg1)->hasUnresolvedBeams();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_hasPomPsystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_hasPomPsystem",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_hasPomPsystem" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (bool)((Pythia8::Info const *)arg1)->hasPomPsystem();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_isHardDiffractive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_isHardDiffractive",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_isHardDiffractive" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (bool)((Pythia8::Info const *)arg1)->isHardDiffractive();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_isHardDiffractiveA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_isHardDiffractiveA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_isHardDiffractiveA" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (bool)((Pythia8::Info const *)arg1)->isHardDiffractiveA();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_isHardDiffractiveB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_isHardDiffractiveB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_isHardDiffractiveB" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (bool)((Pythia8::Info const *)arg1)->isHardDiffractiveB();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_xPomeronA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_xPomeronA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_xPomeronA" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->xPomeronA();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_xPomeronB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_xPomeronB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_xPomeronB" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->xPomeronB();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_tPomeronA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_tPomeronA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_tPomeronA" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->tPomeronA();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_tPomeronB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_tPomeronB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_tPomeronB" "', argument " "1"" of type '" "Pythia8::Info const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (double)((Pythia8::Info const *)arg1)->tPomeronB();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getWeakModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int,std::allocator< int > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_getWeakModes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getWeakModes" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (arg1)->getWeakModes();
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getWeakDipoles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_getWeakDipoles",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getWeakDipoles" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (arg1)->getWeakDipoles();
  resultobj = swig::from(static_cast< std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getWeakMomenta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_getWeakMomenta",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getWeakMomenta" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (arg1)->getWeakMomenta();
  resultobj = SWIG_NewPointerObj((new std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >(static_cast< const std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >& >(result))), SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_getWeak2to2lines(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int,std::allocator< int > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_getWeak2to2lines",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_getWeak2to2lines" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (arg1)->getWeak2to2lines();
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_setWeakModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::vector< int,std::allocator< int > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_setWeakModes",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_setWeakModes" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Info_setWeakModes" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->setWeakModes(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_setWeakDipoles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_setWeakDipoles",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_setWeakDipoles" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  {
    std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *ptr = (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Info_setWeakDipoles" "', argument " "2"" of type '" "std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->setWeakDipoles(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_setWeakMomenta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_setWeakMomenta",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_setWeakMomenta" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Info_setWeakMomenta" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Info_setWeakMomenta" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >""'");
    } else {
      std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > * temp = reinterpret_cast< std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->setWeakMomenta(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_setWeak2to2lines(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::vector< int,std::allocator< int > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_setWeak2to2lines",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_setWeak2to2lines" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Info_setWeak2to2lines" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->setWeak2to2lines(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_hiinfo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  Pythia8::HIInfo *arg2 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Info_hiinfo_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_hiinfo_set" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__HIInfo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Info_hiinfo_set" "', argument " "2"" of type '" "Pythia8::HIInfo *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::HIInfo * >(argp2);
  if (arg1) (arg1)->hiinfo = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info_hiinfo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::HIInfo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info_hiinfo_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info_hiinfo_get" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (Pythia8::HIInfo *) ((arg1)->hiinfo);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Info___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Info___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Info___str__" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = Pythia8_Info___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Info",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Info" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Info_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Info, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Flag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  bool arg2 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Flag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Flag",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Flag" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Flag" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (Pythia8::Flag *)new Pythia8::Flag(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Flag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Flag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  Pythia8::Flag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Flag",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Flag" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::Flag *)new Pythia8::Flag(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Flag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Flag__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Flag *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Flag")) SWIG_fail;
  result = (Pythia8::Flag *)new Pythia8::Flag();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Flag, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Flag(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Flag__SWIG_2(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Flag__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Flag__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Flag'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Flag::Flag(std::string,bool)\n"
    "    Pythia8::Flag::Flag(std::string)\n"
    "    Pythia8::Flag::Flag()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Flag_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Flag *arg1 = (Pythia8::Flag *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Flag_name_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Flag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Flag_name_set" "', argument " "1"" of type '" "Pythia8::Flag *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Flag * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Flag_name_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Flag_name_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->name = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Flag_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Flag *arg1 = (Pythia8::Flag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Flag_name_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Flag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Flag_name_get" "', argument " "1"" of type '" "Pythia8::Flag *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Flag * >(argp1);
  result = (std::string *) & ((arg1)->name);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Flag_valNow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Flag *arg1 = (Pythia8::Flag *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Flag_valNow_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Flag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Flag_valNow_set" "', argument " "1"" of type '" "Pythia8::Flag *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Flag * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Flag_valNow_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->valNow = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Flag_valNow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Flag *arg1 = (Pythia8::Flag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Flag_valNow_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Flag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Flag_valNow_get" "', argument " "1"" of type '" "Pythia8::Flag *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Flag * >(argp1);
  result = (bool) ((arg1)->valNow);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Flag_valDefault_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Flag *arg1 = (Pythia8::Flag *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Flag_valDefault_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Flag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Flag_valDefault_set" "', argument " "1"" of type '" "Pythia8::Flag *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Flag * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Flag_valDefault_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->valDefault = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Flag_valDefault_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Flag *arg1 = (Pythia8::Flag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Flag_valDefault_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Flag, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Flag_valDefault_get" "', argument " "1"" of type '" "Pythia8::Flag *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Flag * >(argp1);
  result = (bool) ((arg1)->valDefault);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Flag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Flag *arg1 = (Pythia8::Flag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Flag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Flag, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Flag" "', argument " "1"" of type '" "Pythia8::Flag *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Flag * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Flag_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Flag, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Mode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  int arg2 ;
  bool arg3 ;
  bool arg4 ;
  int arg5 ;
  int arg6 ;
  bool arg7 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Pythia8::Mode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_Mode",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Mode" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mode" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mode" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mode" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mode" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mode" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  result = (Pythia8::Mode *)new Pythia8::Mode(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Mode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  int arg2 ;
  bool arg3 ;
  bool arg4 ;
  int arg5 ;
  int arg6 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::Mode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_Mode",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Mode" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mode" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mode" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mode" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mode" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (Pythia8::Mode *)new Pythia8::Mode(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Mode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  int arg2 ;
  bool arg3 ;
  bool arg4 ;
  int arg5 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::Mode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Mode",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Mode" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mode" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mode" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mode" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (Pythia8::Mode *)new Pythia8::Mode(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Mode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mode__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  int arg2 ;
  bool arg3 ;
  bool arg4 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::Mode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Mode",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Mode" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mode" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mode" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (Pythia8::Mode *)new Pythia8::Mode(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Mode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mode__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  int arg2 ;
  bool arg3 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Mode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Mode",&obj0,&obj1,&obj2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Mode" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mode" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (Pythia8::Mode *)new Pythia8::Mode(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Mode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mode__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  int arg2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Mode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Mode",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Mode" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::Mode *)new Pythia8::Mode(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Mode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mode__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  Pythia8::Mode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Mode",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Mode" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::Mode *)new Pythia8::Mode(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Mode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mode__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Mode *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Mode")) SWIG_fail;
  result = (Pythia8::Mode *)new Pythia8::Mode();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Mode, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Mode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Mode__SWIG_7(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Mode__SWIG_6(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Mode__SWIG_5(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Mode__SWIG_4(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Mode__SWIG_3(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Mode__SWIG_2(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_Mode__SWIG_1(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_Mode__SWIG_0(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Mode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Mode::Mode(std::string,int,bool,bool,int,int,bool)\n"
    "    Pythia8::Mode::Mode(std::string,int,bool,bool,int,int)\n"
    "    Pythia8::Mode::Mode(std::string,int,bool,bool,int)\n"
    "    Pythia8::Mode::Mode(std::string,int,bool,bool)\n"
    "    Pythia8::Mode::Mode(std::string,int,bool)\n"
    "    Pythia8::Mode::Mode(std::string,int)\n"
    "    Pythia8::Mode::Mode(std::string)\n"
    "    Pythia8::Mode::Mode()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Mode_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Mode *arg1 = (Pythia8::Mode *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Mode_name_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Mode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mode_name_set" "', argument " "1"" of type '" "Pythia8::Mode *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Mode * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mode_name_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mode_name_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->name = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Mode_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Mode *arg1 = (Pythia8::Mode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Mode_name_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Mode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mode_name_get" "', argument " "1"" of type '" "Pythia8::Mode *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Mode * >(argp1);
  result = (std::string *) & ((arg1)->name);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Mode_valNow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Mode *arg1 = (Pythia8::Mode *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Mode_valNow_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Mode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mode_valNow_set" "', argument " "1"" of type '" "Pythia8::Mode *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Mode * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mode_valNow_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->valNow = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Mode_valNow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Mode *arg1 = (Pythia8::Mode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Mode_valNow_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Mode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mode_valNow_get" "', argument " "1"" of type '" "Pythia8::Mode *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Mode * >(argp1);
  result = (int) ((arg1)->valNow);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Mode_valDefault_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Mode *arg1 = (Pythia8::Mode *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Mode_valDefault_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Mode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mode_valDefault_set" "', argument " "1"" of type '" "Pythia8::Mode *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Mode * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mode_valDefault_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->valDefault = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Mode_valDefault_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Mode *arg1 = (Pythia8::Mode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Mode_valDefault_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Mode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mode_valDefault_get" "', argument " "1"" of type '" "Pythia8::Mode *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Mode * >(argp1);
  result = (int) ((arg1)->valDefault);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Mode_hasMin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Mode *arg1 = (Pythia8::Mode *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Mode_hasMin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Mode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mode_hasMin_set" "', argument " "1"" of type '" "Pythia8::Mode *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Mode * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mode_hasMin_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->hasMin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Mode_hasMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Mode *arg1 = (Pythia8::Mode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Mode_hasMin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Mode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mode_hasMin_get" "', argument " "1"" of type '" "Pythia8::Mode *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Mode * >(argp1);
  result = (bool) ((arg1)->hasMin);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Mode_hasMax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Mode *arg1 = (Pythia8::Mode *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Mode_hasMax_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Mode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mode_hasMax_set" "', argument " "1"" of type '" "Pythia8::Mode *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Mode * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mode_hasMax_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->hasMax = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Mode_hasMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Mode *arg1 = (Pythia8::Mode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Mode_hasMax_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Mode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mode_hasMax_get" "', argument " "1"" of type '" "Pythia8::Mode *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Mode * >(argp1);
  result = (bool) ((arg1)->hasMax);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Mode_valMin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Mode *arg1 = (Pythia8::Mode *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Mode_valMin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Mode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mode_valMin_set" "', argument " "1"" of type '" "Pythia8::Mode *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Mode * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mode_valMin_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->valMin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Mode_valMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Mode *arg1 = (Pythia8::Mode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Mode_valMin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Mode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mode_valMin_get" "', argument " "1"" of type '" "Pythia8::Mode *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Mode * >(argp1);
  result = (int) ((arg1)->valMin);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Mode_valMax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Mode *arg1 = (Pythia8::Mode *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Mode_valMax_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Mode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mode_valMax_set" "', argument " "1"" of type '" "Pythia8::Mode *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Mode * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mode_valMax_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->valMax = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Mode_valMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Mode *arg1 = (Pythia8::Mode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Mode_valMax_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Mode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mode_valMax_get" "', argument " "1"" of type '" "Pythia8::Mode *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Mode * >(argp1);
  result = (int) ((arg1)->valMax);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Mode_optOnly_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Mode *arg1 = (Pythia8::Mode *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Mode_optOnly_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Mode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mode_optOnly_set" "', argument " "1"" of type '" "Pythia8::Mode *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Mode * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mode_optOnly_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->optOnly = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Mode_optOnly_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Mode *arg1 = (Pythia8::Mode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Mode_optOnly_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Mode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mode_optOnly_get" "', argument " "1"" of type '" "Pythia8::Mode *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Mode * >(argp1);
  result = (bool) ((arg1)->optOnly);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Mode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Mode *arg1 = (Pythia8::Mode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Mode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Mode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Mode" "', argument " "1"" of type '" "Pythia8::Mode *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Mode * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Mode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Mode, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Parm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  double arg2 ;
  bool arg3 ;
  bool arg4 ;
  double arg5 ;
  double arg6 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::Parm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_Parm",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Parm" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Parm" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Parm" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Parm" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Parm" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Parm" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (Pythia8::Parm *)new Pythia8::Parm(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Parm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Parm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  double arg2 ;
  bool arg3 ;
  bool arg4 ;
  double arg5 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::Parm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Parm",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Parm" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Parm" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Parm" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Parm" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Parm" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (Pythia8::Parm *)new Pythia8::Parm(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Parm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Parm__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  double arg2 ;
  bool arg3 ;
  bool arg4 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::Parm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Parm",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Parm" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Parm" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Parm" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Parm" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (Pythia8::Parm *)new Pythia8::Parm(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Parm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Parm__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  double arg2 ;
  bool arg3 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Parm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Parm",&obj0,&obj1,&obj2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Parm" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Parm" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Parm" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (Pythia8::Parm *)new Pythia8::Parm(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Parm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Parm__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  double arg2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Parm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Parm",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Parm" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Parm" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (Pythia8::Parm *)new Pythia8::Parm(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Parm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Parm__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  Pythia8::Parm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Parm",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Parm" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::Parm *)new Pythia8::Parm(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Parm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Parm__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Parm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Parm")) SWIG_fail;
  result = (Pythia8::Parm *)new Pythia8::Parm();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Parm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Parm(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Parm__SWIG_6(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Parm__SWIG_5(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Parm__SWIG_4(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Parm__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Parm__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Parm__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_Parm__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Parm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Parm::Parm(std::string,double,bool,bool,double,double)\n"
    "    Pythia8::Parm::Parm(std::string,double,bool,bool,double)\n"
    "    Pythia8::Parm::Parm(std::string,double,bool,bool)\n"
    "    Pythia8::Parm::Parm(std::string,double,bool)\n"
    "    Pythia8::Parm::Parm(std::string,double)\n"
    "    Pythia8::Parm::Parm(std::string)\n"
    "    Pythia8::Parm::Parm()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Parm_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Parm *arg1 = (Pythia8::Parm *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Parm_name_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Parm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parm_name_set" "', argument " "1"" of type '" "Pythia8::Parm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Parm * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Parm_name_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Parm_name_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->name = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parm_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Parm *arg1 = (Pythia8::Parm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Parm_name_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Parm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parm_name_get" "', argument " "1"" of type '" "Pythia8::Parm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Parm * >(argp1);
  result = (std::string *) & ((arg1)->name);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parm_valNow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Parm *arg1 = (Pythia8::Parm *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Parm_valNow_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Parm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parm_valNow_set" "', argument " "1"" of type '" "Pythia8::Parm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Parm * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Parm_valNow_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->valNow = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parm_valNow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Parm *arg1 = (Pythia8::Parm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Parm_valNow_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Parm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parm_valNow_get" "', argument " "1"" of type '" "Pythia8::Parm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Parm * >(argp1);
  result = (double) ((arg1)->valNow);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parm_valDefault_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Parm *arg1 = (Pythia8::Parm *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Parm_valDefault_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Parm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parm_valDefault_set" "', argument " "1"" of type '" "Pythia8::Parm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Parm * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Parm_valDefault_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->valDefault = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parm_valDefault_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Parm *arg1 = (Pythia8::Parm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Parm_valDefault_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Parm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parm_valDefault_get" "', argument " "1"" of type '" "Pythia8::Parm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Parm * >(argp1);
  result = (double) ((arg1)->valDefault);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parm_hasMin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Parm *arg1 = (Pythia8::Parm *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Parm_hasMin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Parm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parm_hasMin_set" "', argument " "1"" of type '" "Pythia8::Parm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Parm * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Parm_hasMin_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->hasMin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parm_hasMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Parm *arg1 = (Pythia8::Parm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Parm_hasMin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Parm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parm_hasMin_get" "', argument " "1"" of type '" "Pythia8::Parm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Parm * >(argp1);
  result = (bool) ((arg1)->hasMin);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parm_hasMax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Parm *arg1 = (Pythia8::Parm *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Parm_hasMax_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Parm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parm_hasMax_set" "', argument " "1"" of type '" "Pythia8::Parm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Parm * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Parm_hasMax_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->hasMax = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parm_hasMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Parm *arg1 = (Pythia8::Parm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Parm_hasMax_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Parm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parm_hasMax_get" "', argument " "1"" of type '" "Pythia8::Parm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Parm * >(argp1);
  result = (bool) ((arg1)->hasMax);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parm_valMin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Parm *arg1 = (Pythia8::Parm *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Parm_valMin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Parm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parm_valMin_set" "', argument " "1"" of type '" "Pythia8::Parm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Parm * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Parm_valMin_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->valMin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parm_valMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Parm *arg1 = (Pythia8::Parm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Parm_valMin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Parm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parm_valMin_get" "', argument " "1"" of type '" "Pythia8::Parm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Parm * >(argp1);
  result = (double) ((arg1)->valMin);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parm_valMax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Parm *arg1 = (Pythia8::Parm *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Parm_valMax_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Parm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parm_valMax_set" "', argument " "1"" of type '" "Pythia8::Parm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Parm * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Parm_valMax_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->valMax = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Parm_valMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Parm *arg1 = (Pythia8::Parm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Parm_valMax_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Parm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Parm_valMax_get" "', argument " "1"" of type '" "Pythia8::Parm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Parm * >(argp1);
  result = (double) ((arg1)->valMax);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Parm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Parm *arg1 = (Pythia8::Parm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Parm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Parm, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Parm" "', argument " "1"" of type '" "Pythia8::Parm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Parm * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Parm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Parm, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Word__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Word *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Word",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Word" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Word" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::Word *)new Pythia8::Word(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Word, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Word__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  Pythia8::Word *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Word",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Word" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::Word *)new Pythia8::Word(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Word, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Word__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Word *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Word")) SWIG_fail;
  result = (Pythia8::Word *)new Pythia8::Word();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Word, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Word(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Word__SWIG_2(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Word__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Word__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Word'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Word::Word(std::string,std::string)\n"
    "    Pythia8::Word::Word(std::string)\n"
    "    Pythia8::Word::Word()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Word_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Word *arg1 = (Pythia8::Word *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Word_name_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Word, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Word_name_set" "', argument " "1"" of type '" "Pythia8::Word *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Word * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Word_name_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Word_name_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->name = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Word_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Word *arg1 = (Pythia8::Word *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Word_name_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Word, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Word_name_get" "', argument " "1"" of type '" "Pythia8::Word *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Word * >(argp1);
  result = (std::string *) & ((arg1)->name);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Word_valNow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Word *arg1 = (Pythia8::Word *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Word_valNow_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Word, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Word_valNow_set" "', argument " "1"" of type '" "Pythia8::Word *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Word * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Word_valNow_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Word_valNow_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->valNow = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Word_valNow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Word *arg1 = (Pythia8::Word *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Word_valNow_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Word, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Word_valNow_get" "', argument " "1"" of type '" "Pythia8::Word *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Word * >(argp1);
  result = (std::string *) & ((arg1)->valNow);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Word_valDefault_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Word *arg1 = (Pythia8::Word *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Word_valDefault_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Word, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Word_valDefault_set" "', argument " "1"" of type '" "Pythia8::Word *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Word * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Word_valDefault_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Word_valDefault_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->valDefault = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Word_valDefault_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Word *arg1 = (Pythia8::Word *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Word_valDefault_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Word, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Word_valDefault_get" "', argument " "1"" of type '" "Pythia8::Word *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Word * >(argp1);
  result = (std::string *) & ((arg1)->valDefault);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Word(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Word *arg1 = (Pythia8::Word *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Word",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Word, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Word" "', argument " "1"" of type '" "Pythia8::Word *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Word * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Word_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Word, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FVec__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::vector< bool,std::allocator< bool > > arg2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::FVec *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_FVec",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FVec" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FVec" "', argument " "2"" of type '" "std::vector< bool,std::allocator< bool > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::FVec *)new Pythia8::FVec(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__FVec, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FVec__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  Pythia8::FVec *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FVec",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FVec" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::FVec *)new Pythia8::FVec(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__FVec, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FVec__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FVec *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FVec")) SWIG_fail;
  result = (Pythia8::FVec *)new Pythia8::FVec();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__FVec, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FVec(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_FVec__SWIG_2(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FVec__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector<bool,std::allocator< bool > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FVec__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FVec'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::FVec::FVec(std::string,std::vector< bool,std::allocator< bool > >)\n"
    "    Pythia8::FVec::FVec(std::string)\n"
    "    Pythia8::FVec::FVec()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FVec_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FVec *arg1 = (Pythia8::FVec *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FVec_name_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FVec_name_set" "', argument " "1"" of type '" "Pythia8::FVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FVec * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FVec_name_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FVec_name_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->name = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_FVec_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FVec *arg1 = (Pythia8::FVec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FVec_name_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FVec_name_get" "', argument " "1"" of type '" "Pythia8::FVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FVec * >(argp1);
  result = (std::string *) & ((arg1)->name);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FVec_valNow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FVec *arg1 = (Pythia8::FVec *) 0 ;
  std::vector< bool,std::allocator< bool > > *arg2 = (std::vector< bool,std::allocator< bool > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FVec_valNow_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FVec_valNow_set" "', argument " "1"" of type '" "Pythia8::FVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FVec * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FVec_valNow_set" "', argument " "2"" of type '" "std::vector< bool,std::allocator< bool > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< bool,std::allocator< bool > > * >(argp2);
  if (arg1) (arg1)->valNow = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FVec_valNow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FVec *arg1 = (Pythia8::FVec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< bool,std::allocator< bool > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FVec_valNow_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FVec_valNow_get" "', argument " "1"" of type '" "Pythia8::FVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FVec * >(argp1);
  result = (std::vector< bool,std::allocator< bool > > *)& ((arg1)->valNow);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FVec_valDefault_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FVec *arg1 = (Pythia8::FVec *) 0 ;
  std::vector< bool,std::allocator< bool > > *arg2 = (std::vector< bool,std::allocator< bool > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FVec_valDefault_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FVec_valDefault_set" "', argument " "1"" of type '" "Pythia8::FVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FVec * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FVec_valDefault_set" "', argument " "2"" of type '" "std::vector< bool,std::allocator< bool > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< bool,std::allocator< bool > > * >(argp2);
  if (arg1) (arg1)->valDefault = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FVec_valDefault_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FVec *arg1 = (Pythia8::FVec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< bool,std::allocator< bool > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FVec_valDefault_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FVec_valDefault_get" "', argument " "1"" of type '" "Pythia8::FVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FVec * >(argp1);
  result = (std::vector< bool,std::allocator< bool > > *)& ((arg1)->valDefault);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FVec *arg1 = (Pythia8::FVec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FVec",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FVec, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FVec" "', argument " "1"" of type '" "Pythia8::FVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FVec * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FVec_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__FVec, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MVec__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::vector< int,std::allocator< int > > arg2 ;
  bool arg3 ;
  bool arg4 ;
  int arg5 ;
  int arg6 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::MVec *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_MVec",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MVec" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MVec" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MVec" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MVec" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MVec" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_MVec" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (Pythia8::MVec *)new Pythia8::MVec(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MVec, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MVec__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::vector< int,std::allocator< int > > arg2 ;
  bool arg3 ;
  bool arg4 ;
  int arg5 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::MVec *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_MVec",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MVec" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MVec" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MVec" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MVec" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MVec" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (Pythia8::MVec *)new Pythia8::MVec(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MVec, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MVec__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::vector< int,std::allocator< int > > arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::MVec *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_MVec",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MVec" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MVec" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MVec" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MVec" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (Pythia8::MVec *)new Pythia8::MVec(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MVec, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MVec__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::vector< int,std::allocator< int > > arg2 ;
  bool arg3 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::MVec *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_MVec",&obj0,&obj1,&obj2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MVec" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MVec" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MVec" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (Pythia8::MVec *)new Pythia8::MVec(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MVec, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MVec__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::vector< int,std::allocator< int > > arg2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::MVec *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_MVec",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MVec" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MVec" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::MVec *)new Pythia8::MVec(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MVec, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MVec__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  Pythia8::MVec *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MVec",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MVec" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::MVec *)new Pythia8::MVec(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MVec, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MVec__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MVec *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MVec")) SWIG_fail;
  result = (Pythia8::MVec *)new Pythia8::MVec();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MVec, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MVec(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_MVec__SWIG_6(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MVec__SWIG_5(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< int,std::allocator< int > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_MVec__SWIG_4(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< int,std::allocator< int > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_MVec__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< int,std::allocator< int > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_MVec__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< int,std::allocator< int > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_MVec__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< int,std::allocator< int > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_MVec__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MVec'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::MVec::MVec(std::string,std::vector< int,std::allocator< int > >,bool,bool,int,int)\n"
    "    Pythia8::MVec::MVec(std::string,std::vector< int,std::allocator< int > >,bool,bool,int)\n"
    "    Pythia8::MVec::MVec(std::string,std::vector< int,std::allocator< int > >,bool,bool)\n"
    "    Pythia8::MVec::MVec(std::string,std::vector< int,std::allocator< int > >,bool)\n"
    "    Pythia8::MVec::MVec(std::string,std::vector< int,std::allocator< int > >)\n"
    "    Pythia8::MVec::MVec(std::string)\n"
    "    Pythia8::MVec::MVec()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MVec_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MVec *arg1 = (Pythia8::MVec *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MVec_name_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MVec_name_set" "', argument " "1"" of type '" "Pythia8::MVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MVec * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MVec_name_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MVec_name_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->name = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MVec_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MVec *arg1 = (Pythia8::MVec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MVec_name_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MVec_name_get" "', argument " "1"" of type '" "Pythia8::MVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MVec * >(argp1);
  result = (std::string *) & ((arg1)->name);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MVec_valNow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MVec *arg1 = (Pythia8::MVec *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = (std::vector< int,std::allocator< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MVec_valNow_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MVec_valNow_set" "', argument " "1"" of type '" "Pythia8::MVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MVec * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MVec_valNow_set" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  if (arg1) (arg1)->valNow = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MVec_valNow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MVec *arg1 = (Pythia8::MVec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int,std::allocator< int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MVec_valNow_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MVec_valNow_get" "', argument " "1"" of type '" "Pythia8::MVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MVec * >(argp1);
  result = (std::vector< int,std::allocator< int > > *)& ((arg1)->valNow);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MVec_valDefault_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MVec *arg1 = (Pythia8::MVec *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = (std::vector< int,std::allocator< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MVec_valDefault_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MVec_valDefault_set" "', argument " "1"" of type '" "Pythia8::MVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MVec * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MVec_valDefault_set" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  if (arg1) (arg1)->valDefault = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MVec_valDefault_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MVec *arg1 = (Pythia8::MVec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int,std::allocator< int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MVec_valDefault_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MVec_valDefault_get" "', argument " "1"" of type '" "Pythia8::MVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MVec * >(argp1);
  result = (std::vector< int,std::allocator< int > > *)& ((arg1)->valDefault);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MVec_hasMin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MVec *arg1 = (Pythia8::MVec *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MVec_hasMin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MVec_hasMin_set" "', argument " "1"" of type '" "Pythia8::MVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MVec * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MVec_hasMin_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->hasMin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MVec_hasMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MVec *arg1 = (Pythia8::MVec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MVec_hasMin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MVec_hasMin_get" "', argument " "1"" of type '" "Pythia8::MVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MVec * >(argp1);
  result = (bool) ((arg1)->hasMin);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MVec_hasMax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MVec *arg1 = (Pythia8::MVec *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MVec_hasMax_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MVec_hasMax_set" "', argument " "1"" of type '" "Pythia8::MVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MVec * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MVec_hasMax_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->hasMax = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MVec_hasMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MVec *arg1 = (Pythia8::MVec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MVec_hasMax_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MVec_hasMax_get" "', argument " "1"" of type '" "Pythia8::MVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MVec * >(argp1);
  result = (bool) ((arg1)->hasMax);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MVec_valMin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MVec *arg1 = (Pythia8::MVec *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MVec_valMin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MVec_valMin_set" "', argument " "1"" of type '" "Pythia8::MVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MVec * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MVec_valMin_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->valMin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MVec_valMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MVec *arg1 = (Pythia8::MVec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MVec_valMin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MVec_valMin_get" "', argument " "1"" of type '" "Pythia8::MVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MVec * >(argp1);
  result = (int) ((arg1)->valMin);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MVec_valMax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MVec *arg1 = (Pythia8::MVec *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MVec_valMax_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MVec_valMax_set" "', argument " "1"" of type '" "Pythia8::MVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MVec * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MVec_valMax_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->valMax = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MVec_valMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MVec *arg1 = (Pythia8::MVec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MVec_valMax_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MVec_valMax_get" "', argument " "1"" of type '" "Pythia8::MVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MVec * >(argp1);
  result = (int) ((arg1)->valMax);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MVec *arg1 = (Pythia8::MVec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MVec",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MVec, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MVec" "', argument " "1"" of type '" "Pythia8::MVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MVec * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MVec_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__MVec, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PVec__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::vector< double,std::allocator< double > > arg2 ;
  bool arg3 ;
  bool arg4 ;
  double arg5 ;
  double arg6 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::PVec *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_PVec",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PVec" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PVec" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_PVec" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_PVec" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_PVec" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PVec" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (Pythia8::PVec *)new Pythia8::PVec(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PVec, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PVec__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::vector< double,std::allocator< double > > arg2 ;
  bool arg3 ;
  bool arg4 ;
  double arg5 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::PVec *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_PVec",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PVec" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PVec" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_PVec" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_PVec" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_PVec" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (Pythia8::PVec *)new Pythia8::PVec(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PVec, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PVec__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::vector< double,std::allocator< double > > arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::PVec *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_PVec",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PVec" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PVec" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_PVec" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_PVec" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (Pythia8::PVec *)new Pythia8::PVec(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PVec, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PVec__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::vector< double,std::allocator< double > > arg2 ;
  bool arg3 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::PVec *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_PVec",&obj0,&obj1,&obj2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PVec" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PVec" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_PVec" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (Pythia8::PVec *)new Pythia8::PVec(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PVec, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PVec__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::vector< double,std::allocator< double > > arg2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::PVec *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_PVec",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PVec" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PVec" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::PVec *)new Pythia8::PVec(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PVec, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PVec__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  Pythia8::PVec *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PVec",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PVec" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::PVec *)new Pythia8::PVec(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PVec, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PVec__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PVec *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PVec")) SWIG_fail;
  result = (Pythia8::PVec *)new Pythia8::PVec();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PVec, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PVec(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_PVec__SWIG_6(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PVec__SWIG_5(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_PVec__SWIG_4(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_PVec__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_PVec__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_PVec__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_PVec__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PVec'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PVec::PVec(std::string,std::vector< double,std::allocator< double > >,bool,bool,double,double)\n"
    "    Pythia8::PVec::PVec(std::string,std::vector< double,std::allocator< double > >,bool,bool,double)\n"
    "    Pythia8::PVec::PVec(std::string,std::vector< double,std::allocator< double > >,bool,bool)\n"
    "    Pythia8::PVec::PVec(std::string,std::vector< double,std::allocator< double > >,bool)\n"
    "    Pythia8::PVec::PVec(std::string,std::vector< double,std::allocator< double > >)\n"
    "    Pythia8::PVec::PVec(std::string)\n"
    "    Pythia8::PVec::PVec()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PVec_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PVec *arg1 = (Pythia8::PVec *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PVec_name_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PVec_name_set" "', argument " "1"" of type '" "Pythia8::PVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PVec * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PVec_name_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PVec_name_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->name = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PVec_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PVec *arg1 = (Pythia8::PVec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PVec_name_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PVec_name_get" "', argument " "1"" of type '" "Pythia8::PVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PVec * >(argp1);
  result = (std::string *) & ((arg1)->name);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PVec_valNow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PVec *arg1 = (Pythia8::PVec *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = (std::vector< double,std::allocator< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PVec_valNow_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PVec_valNow_set" "', argument " "1"" of type '" "Pythia8::PVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PVec * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PVec_valNow_set" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp2);
  if (arg1) (arg1)->valNow = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PVec_valNow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PVec *arg1 = (Pythia8::PVec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PVec_valNow_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PVec_valNow_get" "', argument " "1"" of type '" "Pythia8::PVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PVec * >(argp1);
  result = (std::vector< double,std::allocator< double > > *)& ((arg1)->valNow);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PVec_valDefault_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PVec *arg1 = (Pythia8::PVec *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = (std::vector< double,std::allocator< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PVec_valDefault_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PVec_valDefault_set" "', argument " "1"" of type '" "Pythia8::PVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PVec * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PVec_valDefault_set" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp2);
  if (arg1) (arg1)->valDefault = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PVec_valDefault_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PVec *arg1 = (Pythia8::PVec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PVec_valDefault_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PVec_valDefault_get" "', argument " "1"" of type '" "Pythia8::PVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PVec * >(argp1);
  result = (std::vector< double,std::allocator< double > > *)& ((arg1)->valDefault);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PVec_hasMin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PVec *arg1 = (Pythia8::PVec *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PVec_hasMin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PVec_hasMin_set" "', argument " "1"" of type '" "Pythia8::PVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PVec * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PVec_hasMin_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->hasMin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PVec_hasMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PVec *arg1 = (Pythia8::PVec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PVec_hasMin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PVec_hasMin_get" "', argument " "1"" of type '" "Pythia8::PVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PVec * >(argp1);
  result = (bool) ((arg1)->hasMin);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PVec_hasMax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PVec *arg1 = (Pythia8::PVec *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PVec_hasMax_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PVec_hasMax_set" "', argument " "1"" of type '" "Pythia8::PVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PVec * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PVec_hasMax_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->hasMax = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PVec_hasMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PVec *arg1 = (Pythia8::PVec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PVec_hasMax_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PVec_hasMax_get" "', argument " "1"" of type '" "Pythia8::PVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PVec * >(argp1);
  result = (bool) ((arg1)->hasMax);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PVec_valMin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PVec *arg1 = (Pythia8::PVec *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PVec_valMin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PVec_valMin_set" "', argument " "1"" of type '" "Pythia8::PVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PVec * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PVec_valMin_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->valMin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PVec_valMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PVec *arg1 = (Pythia8::PVec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PVec_valMin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PVec_valMin_get" "', argument " "1"" of type '" "Pythia8::PVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PVec * >(argp1);
  result = (double) ((arg1)->valMin);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PVec_valMax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PVec *arg1 = (Pythia8::PVec *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PVec_valMax_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PVec_valMax_set" "', argument " "1"" of type '" "Pythia8::PVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PVec * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PVec_valMax_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->valMax = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PVec_valMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PVec *arg1 = (Pythia8::PVec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PVec_valMax_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PVec_valMax_get" "', argument " "1"" of type '" "Pythia8::PVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PVec * >(argp1);
  result = (double) ((arg1)->valMax);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PVec *arg1 = (Pythia8::PVec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PVec",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PVec, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PVec" "', argument " "1"" of type '" "Pythia8::PVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PVec * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PVec_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__PVec, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_WVec__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::vector< std::string,std::allocator< std::string > > arg2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::WVec *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_WVec",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_WVec" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_WVec" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::WVec *)new Pythia8::WVec(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__WVec, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WVec__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  Pythia8::WVec *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_WVec",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_WVec" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::WVec *)new Pythia8::WVec(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__WVec, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WVec__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::WVec *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_WVec")) SWIG_fail;
  result = (Pythia8::WVec *)new Pythia8::WVec();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__WVec, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_WVec(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_WVec__SWIG_2(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_WVec__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_WVec__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_WVec'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::WVec::WVec(std::string,std::vector< std::string,std::allocator< std::string > >)\n"
    "    Pythia8::WVec::WVec(std::string)\n"
    "    Pythia8::WVec::WVec()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_WVec_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::WVec *arg1 = (Pythia8::WVec *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:WVec_name_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__WVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WVec_name_set" "', argument " "1"" of type '" "Pythia8::WVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::WVec * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WVec_name_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WVec_name_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->name = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_WVec_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::WVec *arg1 = (Pythia8::WVec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:WVec_name_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__WVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WVec_name_get" "', argument " "1"" of type '" "Pythia8::WVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::WVec * >(argp1);
  result = (std::string *) & ((arg1)->name);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WVec_valNow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::WVec *arg1 = (Pythia8::WVec *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = (std::vector< std::string,std::allocator< std::string > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:WVec_valNow_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__WVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WVec_valNow_set" "', argument " "1"" of type '" "Pythia8::WVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::WVec * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WVec_valNow_set" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp2);
  if (arg1) (arg1)->valNow = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WVec_valNow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::WVec *arg1 = (Pythia8::WVec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:WVec_valNow_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__WVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WVec_valNow_get" "', argument " "1"" of type '" "Pythia8::WVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::WVec * >(argp1);
  result = (std::vector< std::string,std::allocator< std::string > > *)& ((arg1)->valNow);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WVec_valDefault_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::WVec *arg1 = (Pythia8::WVec *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = (std::vector< std::string,std::allocator< std::string > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:WVec_valDefault_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__WVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WVec_valDefault_set" "', argument " "1"" of type '" "Pythia8::WVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::WVec * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WVec_valDefault_set" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp2);
  if (arg1) (arg1)->valDefault = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WVec_valDefault_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::WVec *arg1 = (Pythia8::WVec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:WVec_valDefault_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__WVec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WVec_valDefault_get" "', argument " "1"" of type '" "Pythia8::WVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::WVec * >(argp1);
  result = (std::vector< std::string,std::allocator< std::string > > *)& ((arg1)->valDefault);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_WVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::WVec *arg1 = (Pythia8::WVec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_WVec",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__WVec, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WVec" "', argument " "1"" of type '" "Pythia8::WVec *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::WVec * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *WVec_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__WVec, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Settings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Settings")) SWIG_fail;
  result = (Pythia8::Settings *)new Pythia8::Settings();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Settings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_initPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_initPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_initPtr" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Settings_initPtr" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  (arg1)->initPtr(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_init__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Settings_init",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_init" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_init" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Settings_init" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->init(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_init__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_init",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_init" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_init" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->init(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_init__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Settings_init",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_init" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  result = (bool)(arg1)->init();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_init__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::istream *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Settings_init",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_init" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Settings_init" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Settings_init" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Settings_init" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->init(*arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_init__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::istream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_init",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_init" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Settings_init" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Settings_init" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  result = (bool)(arg1)->init(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_init(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Settings_init__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Settings_init__SWIG_4(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Settings_init__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Settings_init__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Settings_init__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Settings_init'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Settings::init(std::string,bool)\n"
    "    Pythia8::Settings::init(std::string)\n"
    "    Pythia8::Settings::init()\n"
    "    Pythia8::Settings::init(std::istream &,bool)\n"
    "    Pythia8::Settings::init(std::istream &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Settings_reInit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_reInit",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_reInit" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_reInit" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->reInit(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_reInit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Settings_reInit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_reInit" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  result = (bool)(arg1)->reInit();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_reInit(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Settings_reInit__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Settings_reInit__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Settings_reInit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Settings::reInit(std::string)\n"
    "    Pythia8::Settings::reInit()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Settings_readString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Settings_readString",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_readString" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_readString" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Settings_readString" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->readString(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_readString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_readString",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_readString" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_readString" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->readString(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_readString(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Settings_readString__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Settings_readString__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Settings_readString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Settings::readString(std::string,bool)\n"
    "    Pythia8::Settings::readString(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Settings_writeFile__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Settings_writeFile",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_writeFile" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_writeFile" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Settings_writeFile" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->writeFile(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_writeFile__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_writeFile",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_writeFile" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_writeFile" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->writeFile(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_writeFile__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::ostream *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Settings_writeFile",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_writeFile" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Settings_writeFile" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Settings_writeFile" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Settings_writeFile" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->writeFile(*arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_writeFile__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_writeFile",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_writeFile" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Settings_writeFile" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Settings_writeFile" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  result = (bool)(arg1)->writeFile(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_writeFile__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Settings_writeFile",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_writeFile" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  result = (bool)(arg1)->writeFile();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_writeFile(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Settings_writeFile__SWIG_4(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Settings_writeFile__SWIG_3(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Settings_writeFile__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Settings_writeFile__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Settings_writeFile__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Settings_writeFile'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Settings::writeFile(std::string,bool)\n"
    "    Pythia8::Settings::writeFile(std::string)\n"
    "    Pythia8::Settings::writeFile(std::ostream &,bool)\n"
    "    Pythia8::Settings::writeFile(std::ostream &)\n"
    "    Pythia8::Settings::writeFile()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Settings_writeFileXML__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_writeFileXML",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_writeFileXML" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Settings_writeFileXML" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Settings_writeFileXML" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  result = (bool)(arg1)->writeFileXML(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_writeFileXML__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Settings_writeFileXML",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_writeFileXML" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  result = (bool)(arg1)->writeFileXML();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_writeFileXML(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Settings_writeFileXML__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Settings_writeFileXML__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Settings_writeFileXML'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Settings::writeFileXML(std::ostream &)\n"
    "    Pythia8::Settings::writeFileXML()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Settings_listAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Settings_listAll",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_listAll" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  (arg1)->listAll();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_listChanged(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Settings_listChanged",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_listChanged" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  (arg1)->listChanged();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_output__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Settings_output",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_output" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_output" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Settings_output" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (arg1)->output(arg2,arg3);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_output__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_output",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_output" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_output" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->output(arg2);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_output(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Settings_output__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Settings_output__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Settings_output'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Settings::output(std::string,bool)\n"
    "    Pythia8::Settings::output(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Settings_getReadHistory__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_getReadHistory",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_getReadHistory" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Settings_getReadHistory" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (arg1)->getReadHistory(arg2);
  resultobj = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_getReadHistory__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Settings_getReadHistory",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_getReadHistory" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  result = (arg1)->getReadHistory();
  resultobj = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_getReadHistory(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Settings_getReadHistory__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Settings_getReadHistory__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Settings_getReadHistory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Settings::getReadHistory(int)\n"
    "    Pythia8::Settings::getReadHistory()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Settings_resetAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Settings_resetAll",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_resetAll" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  (arg1)->resetAll();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_isFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_isFlag",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_isFlag" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_isFlag" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->isFlag(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_isMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_isMode",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_isMode" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_isMode" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->isMode(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_isParm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_isParm",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_isParm" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_isParm" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->isParm(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_isWord(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_isWord",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_isWord" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_isWord" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->isWord(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_isFVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_isFVec",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_isFVec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_isFVec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->isFVec(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_isMVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_isMVec",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_isMVec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_isMVec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->isMVec(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_isPVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_isPVec",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_isPVec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_isPVec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->isPVec(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_isWVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_isWVec",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_isWVec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_isWVec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->isWVec(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_addFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Settings_addFlag",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_addFlag" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_addFlag" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Settings_addFlag" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->addFlag(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_addMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  int arg3 ;
  bool arg4 ;
  bool arg5 ;
  int arg6 ;
  int arg7 ;
  bool arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Settings_addMode",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_addMode" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_addMode" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Settings_addMode" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Settings_addMode" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Settings_addMode" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Settings_addMode" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Settings_addMode" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Settings_addMode" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  (arg1)->addMode(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_addMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  int arg3 ;
  bool arg4 ;
  bool arg5 ;
  int arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Settings_addMode",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_addMode" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_addMode" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Settings_addMode" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Settings_addMode" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Settings_addMode" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Settings_addMode" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Settings_addMode" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  (arg1)->addMode(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_addMode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 8) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Settings_addMode__SWIG_1(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Settings_addMode__SWIG_0(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Settings_addMode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Settings::addMode(std::string,int,bool,bool,int,int,bool)\n"
    "    Pythia8::Settings::addMode(std::string,int,bool,bool,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Settings_addParm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  double arg3 ;
  bool arg4 ;
  bool arg5 ;
  double arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Settings_addParm",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_addParm" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_addParm" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Settings_addParm" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Settings_addParm" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Settings_addParm" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Settings_addParm" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Settings_addParm" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  (arg1)->addParm(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_addWord(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Settings_addWord",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_addWord" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_addWord" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_addWord" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->addWord(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_addFVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  std::vector< bool,std::allocator< bool > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Settings_addFVec",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_addFVec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_addFVec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_addFVec" "', argument " "3"" of type '" "std::vector< bool,std::allocator< bool > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->addFVec(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_addMVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  std::vector< int,std::allocator< int > > arg3 ;
  bool arg4 ;
  bool arg5 ;
  int arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Settings_addMVec",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_addMVec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_addMVec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_addMVec" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Settings_addMVec" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Settings_addMVec" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Settings_addMVec" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Settings_addMVec" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  (arg1)->addMVec(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_addPVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  std::vector< double,std::allocator< double > > arg3 ;
  bool arg4 ;
  bool arg5 ;
  double arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Settings_addPVec",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_addPVec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_addPVec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_addPVec" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Settings_addPVec" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Settings_addPVec" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Settings_addPVec" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Settings_addPVec" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  (arg1)->addPVec(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_addWVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  std::vector< std::string,std::allocator< std::string > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Settings_addWVec",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_addWVec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_addWVec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_addWVec" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->addWVec(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_flag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_flag",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_flag" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_flag" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->flag(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_mode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_mode",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_mode" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_mode" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (int)(arg1)->mode(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_parm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_parm",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_parm" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_parm" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->parm(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_word__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_word",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_word" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_word" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->word(arg2);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_fvec__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< bool,std::allocator< bool > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_fvec",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_fvec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_fvec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->fvec(arg2);
  resultobj = swig::from(static_cast< std::vector<bool,std::allocator< bool > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_mvec__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< int,std::allocator< int > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_mvec",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_mvec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_mvec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->mvec(arg2);
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_pvec__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< double,std::allocator< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_pvec",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_pvec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_pvec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->pvec(arg2);
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_wvec__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_wvec",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_wvec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_wvec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->wvec(arg2);
  resultobj = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_flagDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_flagDefault",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_flagDefault" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_flagDefault" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->flagDefault(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_modeDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_modeDefault",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_modeDefault" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_modeDefault" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (int)(arg1)->modeDefault(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_parmDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_parmDefault",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_parmDefault" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_parmDefault" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->parmDefault(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_wordDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_wordDefault",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_wordDefault" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_wordDefault" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->wordDefault(arg2);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_fvecDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< bool,std::allocator< bool > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_fvecDefault",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_fvecDefault" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_fvecDefault" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->fvecDefault(arg2);
  resultobj = swig::from(static_cast< std::vector<bool,std::allocator< bool > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_mvecDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< int,std::allocator< int > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_mvecDefault",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_mvecDefault" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_mvecDefault" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->mvecDefault(arg2);
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_pvecDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< double,std::allocator< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_pvecDefault",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_pvecDefault" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_pvecDefault" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->pvecDefault(arg2);
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_wvecDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_wvecDefault",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_wvecDefault" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_wvecDefault" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->wvecDefault(arg2);
  resultobj = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_getFlagMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_getFlagMap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_getFlagMap" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_getFlagMap" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->getFlagMap(arg2);
  resultobj = SWIG_NewPointerObj((new std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >(static_cast< const std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >& >(result))), SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_getModeMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_getModeMap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_getModeMap" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_getModeMap" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->getModeMap(arg2);
  resultobj = SWIG_NewPointerObj((new std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >(static_cast< const std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >& >(result))), SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_getParmMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_getParmMap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_getParmMap" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_getParmMap" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->getParmMap(arg2);
  resultobj = SWIG_NewPointerObj((new std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >(static_cast< const std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >& >(result))), SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_getWordMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_getWordMap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_getWordMap" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_getWordMap" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->getWordMap(arg2);
  resultobj = SWIG_NewPointerObj((new std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >(static_cast< const std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >& >(result))), SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_getFVecMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_getFVecMap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_getFVecMap" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_getFVecMap" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->getFVecMap(arg2);
  resultobj = SWIG_NewPointerObj((new std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >(static_cast< const std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >& >(result))), SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_getMVecMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_getMVecMap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_getMVecMap" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_getMVecMap" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->getMVecMap(arg2);
  resultobj = SWIG_NewPointerObj((new std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >(static_cast< const std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >& >(result))), SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_getPVecMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_getPVecMap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_getPVecMap" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_getPVecMap" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->getPVecMap(arg2);
  resultobj = SWIG_NewPointerObj((new std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >(static_cast< const std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >& >(result))), SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_getWVecMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigValueWrapper< std::map< std::string,Pythia8::WVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::WVec > > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_getWVecMap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_getWVecMap" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_getWVecMap" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->getWVecMap(arg2);
  resultobj = SWIG_NewPointerObj((new std::map< std::string,Pythia8::WVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::WVec > > >(static_cast< const std::map< std::string,Pythia8::WVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::WVec > > >& >(result))), SWIGTYPE_p_std__mapT_std__string_Pythia8__WVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__WVec_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_flag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Settings_flag",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_flag" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_flag" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Settings_flag" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Settings_flag" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->flag(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_flag__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Settings_flag",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_flag" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_flag" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Settings_flag" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->flag(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_flag(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Settings_flag__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Settings_flag__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Settings_flag__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Settings_flag'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Settings::flag(std::string)\n"
    "    Pythia8::Settings::flag(std::string,bool,bool)\n"
    "    Pythia8::Settings::flag(std::string,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Settings_mode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  int arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Settings_mode",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_mode" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_mode" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Settings_mode" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Settings_mode" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (bool)(arg1)->mode(arg2,arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_mode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Settings_mode",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_mode" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_mode" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Settings_mode" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (bool)(arg1)->mode(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_mode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Settings_mode__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Settings_mode__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Settings_mode__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Settings_mode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Settings::mode(std::string)\n"
    "    Pythia8::Settings::mode(std::string,int,bool)\n"
    "    Pythia8::Settings::mode(std::string,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Settings_parm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  double arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Settings_parm",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_parm" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_parm" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Settings_parm" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Settings_parm" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->parm(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_parm__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Settings_parm",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_parm" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_parm" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Settings_parm" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->parm(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_parm(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Settings_parm__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Settings_parm__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Settings_parm__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Settings_parm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Settings::parm(std::string)\n"
    "    Pythia8::Settings::parm(std::string,double,bool)\n"
    "    Pythia8::Settings::parm(std::string,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Settings_word__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Settings_word",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_word" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_word" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_word" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Settings_word" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->word(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_word__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Settings_word",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_word" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_word" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_word" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->word(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_word(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Settings_word__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Settings_word__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Settings_word__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Settings_word'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Settings::word(std::string)\n"
    "    Pythia8::Settings::word(std::string,std::string,bool)\n"
    "    Pythia8::Settings::word(std::string,std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Settings_fvec__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  std::vector< bool,std::allocator< bool > > arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Settings_fvec",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_fvec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_fvec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_fvec" "', argument " "3"" of type '" "std::vector< bool,std::allocator< bool > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Settings_fvec" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->fvec(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_fvec__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  std::vector< bool,std::allocator< bool > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Settings_fvec",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_fvec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_fvec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_fvec" "', argument " "3"" of type '" "std::vector< bool,std::allocator< bool > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->fvec(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_fvec(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Settings_fvec__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector<bool,std::allocator< bool > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Settings_fvec__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector<bool,std::allocator< bool > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Settings_fvec__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Settings_fvec'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Settings::fvec(std::string)\n"
    "    Pythia8::Settings::fvec(std::string,std::vector< bool,std::allocator< bool > >,bool)\n"
    "    Pythia8::Settings::fvec(std::string,std::vector< bool,std::allocator< bool > >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Settings_mvec__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  std::vector< int,std::allocator< int > > arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Settings_mvec",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_mvec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_mvec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_mvec" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Settings_mvec" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->mvec(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_mvec__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  std::vector< int,std::allocator< int > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Settings_mvec",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_mvec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_mvec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_mvec" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->mvec(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_mvec(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Settings_mvec__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< int,std::allocator< int > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Settings_mvec__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< int,std::allocator< int > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Settings_mvec__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Settings_mvec'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Settings::mvec(std::string)\n"
    "    Pythia8::Settings::mvec(std::string,std::vector< int,std::allocator< int > >,bool)\n"
    "    Pythia8::Settings::mvec(std::string,std::vector< int,std::allocator< int > >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Settings_pvec__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  std::vector< double,std::allocator< double > > arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Settings_pvec",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_pvec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_pvec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_pvec" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Settings_pvec" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->pvec(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_pvec__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  std::vector< double,std::allocator< double > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Settings_pvec",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_pvec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_pvec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_pvec" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->pvec(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_pvec(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Settings_pvec__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Settings_pvec__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Settings_pvec__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Settings_pvec'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Settings::pvec(std::string)\n"
    "    Pythia8::Settings::pvec(std::string,std::vector< double,std::allocator< double > >,bool)\n"
    "    Pythia8::Settings::pvec(std::string,std::vector< double,std::allocator< double > >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Settings_wvec__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  std::vector< std::string,std::allocator< std::string > > arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Settings_wvec",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_wvec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_wvec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_wvec" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Settings_wvec" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->wvec(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_wvec__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  std::vector< std::string,std::allocator< std::string > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Settings_wvec",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_wvec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_wvec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_wvec" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->wvec(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_wvec(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Settings_wvec__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Settings_wvec__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Settings_wvec__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Settings_wvec'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Settings::wvec(std::string)\n"
    "    Pythia8::Settings::wvec(std::string,std::vector< std::string,std::allocator< std::string > >,bool)\n"
    "    Pythia8::Settings::wvec(std::string,std::vector< std::string,std::allocator< std::string > >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Settings_forceMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Settings_forceMode",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_forceMode" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_forceMode" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Settings_forceMode" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->forceMode(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_forceParm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Settings_forceParm",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_forceParm" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_forceParm" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Settings_forceParm" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->forceParm(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_forceMVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  std::vector< int,std::allocator< int > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Settings_forceMVec",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_forceMVec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_forceMVec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_forceMVec" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->forceMVec(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_forcePVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  std::vector< double,std::allocator< double > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Settings_forcePVec",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_forcePVec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_forcePVec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_forcePVec" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->forcePVec(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_resetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_resetFlag",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_resetFlag" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_resetFlag" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->resetFlag(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_resetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_resetMode",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_resetMode" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_resetMode" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->resetMode(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_resetParm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_resetParm",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_resetParm" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_resetParm" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->resetParm(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_resetWord(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_resetWord",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_resetWord" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_resetWord" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->resetWord(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_resetFVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_resetFVec",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_resetFVec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_resetFVec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->resetFVec(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_resetMVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_resetMVec",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_resetMVec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_resetMVec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->resetMVec(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_resetPVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_resetPVec",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_resetPVec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_resetPVec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->resetPVec(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_resetWVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Settings_resetWVec",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_resetWVec" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Settings_resetWVec" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->resetWVec(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_getIsInit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Settings_getIsInit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_getIsInit" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  result = (bool)(arg1)->getIsInit();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_readingFailed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Settings_readingFailed",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_readingFailed" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  result = (bool)(arg1)->readingFailed();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Settings_unfinishedInput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Settings_unfinishedInput",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Settings_unfinishedInput" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  result = (bool)(arg1)->unfinishedInput();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Settings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = (Pythia8::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Settings",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Settings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Settings" "', argument " "1"" of type '" "Pythia8::Settings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Settings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Settings, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AlphaStrong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlphaStrong *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AlphaStrong")) SWIG_fail;
  result = (Pythia8::AlphaStrong *)new Pythia8::AlphaStrong();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__AlphaStrong, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AlphaStrong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlphaStrong *arg1 = (Pythia8::AlphaStrong *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AlphaStrong",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlphaStrong, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AlphaStrong" "', argument " "1"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlphaStrong * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlphaStrong_init__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlphaStrong *arg1 = (Pythia8::AlphaStrong *) 0 ;
  double arg2 ;
  int arg3 ;
  int arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:AlphaStrong_init",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaStrong_init" "', argument " "1"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlphaStrong * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AlphaStrong_init" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AlphaStrong_init" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AlphaStrong_init" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "AlphaStrong_init" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  (arg1)->init(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlphaStrong_init__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlphaStrong *arg1 = (Pythia8::AlphaStrong *) 0 ;
  double arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:AlphaStrong_init",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaStrong_init" "', argument " "1"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlphaStrong * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AlphaStrong_init" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AlphaStrong_init" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AlphaStrong_init" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->init(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlphaStrong_init__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlphaStrong *arg1 = (Pythia8::AlphaStrong *) 0 ;
  double arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:AlphaStrong_init",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaStrong_init" "', argument " "1"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlphaStrong * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AlphaStrong_init" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AlphaStrong_init" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->init(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlphaStrong_init__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlphaStrong *arg1 = (Pythia8::AlphaStrong *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:AlphaStrong_init",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaStrong_init" "', argument " "1"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlphaStrong * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AlphaStrong_init" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlphaStrong_init__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlphaStrong *arg1 = (Pythia8::AlphaStrong *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:AlphaStrong_init",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaStrong_init" "', argument " "1"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlphaStrong * >(argp1);
  (arg1)->init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlphaStrong_init(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__AlphaStrong, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_AlphaStrong_init__SWIG_4(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__AlphaStrong, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_AlphaStrong_init__SWIG_3(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__AlphaStrong, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_AlphaStrong_init__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__AlphaStrong, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_AlphaStrong_init__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__AlphaStrong, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_AlphaStrong_init__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'AlphaStrong_init'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::AlphaStrong::init(double,int,int,bool)\n"
    "    Pythia8::AlphaStrong::init(double,int,int)\n"
    "    Pythia8::AlphaStrong::init(double,int)\n"
    "    Pythia8::AlphaStrong::init(double)\n"
    "    Pythia8::AlphaStrong::init()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AlphaStrong_setThresholds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlphaStrong *arg1 = (Pythia8::AlphaStrong *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:AlphaStrong_setThresholds",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaStrong_setThresholds" "', argument " "1"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlphaStrong * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AlphaStrong_setThresholds" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AlphaStrong_setThresholds" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AlphaStrong_setThresholds" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->setThresholds(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlphaStrong_alphaS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlphaStrong *arg1 = (Pythia8::AlphaStrong *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:AlphaStrong_alphaS",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaStrong_alphaS" "', argument " "1"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlphaStrong * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AlphaStrong_alphaS" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->alphaS(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlphaStrong_alphaS1Ord(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlphaStrong *arg1 = (Pythia8::AlphaStrong *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:AlphaStrong_alphaS1Ord",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaStrong_alphaS1Ord" "', argument " "1"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlphaStrong * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AlphaStrong_alphaS1Ord" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->alphaS1Ord(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlphaStrong_alphaS2OrdCorr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlphaStrong *arg1 = (Pythia8::AlphaStrong *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:AlphaStrong_alphaS2OrdCorr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaStrong_alphaS2OrdCorr" "', argument " "1"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlphaStrong * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AlphaStrong_alphaS2OrdCorr" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->alphaS2OrdCorr(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlphaStrong_Lambda3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlphaStrong *arg1 = (Pythia8::AlphaStrong *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:AlphaStrong_Lambda3",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaStrong_Lambda3" "', argument " "1"" of type '" "Pythia8::AlphaStrong const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlphaStrong * >(argp1);
  result = (double)((Pythia8::AlphaStrong const *)arg1)->Lambda3();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlphaStrong_Lambda4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlphaStrong *arg1 = (Pythia8::AlphaStrong *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:AlphaStrong_Lambda4",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaStrong_Lambda4" "', argument " "1"" of type '" "Pythia8::AlphaStrong const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlphaStrong * >(argp1);
  result = (double)((Pythia8::AlphaStrong const *)arg1)->Lambda4();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlphaStrong_Lambda5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlphaStrong *arg1 = (Pythia8::AlphaStrong *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:AlphaStrong_Lambda5",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaStrong_Lambda5" "', argument " "1"" of type '" "Pythia8::AlphaStrong const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlphaStrong * >(argp1);
  result = (double)((Pythia8::AlphaStrong const *)arg1)->Lambda5();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlphaStrong_Lambda6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlphaStrong *arg1 = (Pythia8::AlphaStrong *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:AlphaStrong_Lambda6",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaStrong_Lambda6" "', argument " "1"" of type '" "Pythia8::AlphaStrong const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlphaStrong * >(argp1);
  result = (double)((Pythia8::AlphaStrong const *)arg1)->Lambda6();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlphaStrong_muThres(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlphaStrong *arg1 = (Pythia8::AlphaStrong *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:AlphaStrong_muThres",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaStrong_muThres" "', argument " "1"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlphaStrong * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AlphaStrong_muThres" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->muThres(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlphaStrong_muThres2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlphaStrong *arg1 = (Pythia8::AlphaStrong *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:AlphaStrong_muThres2",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaStrong_muThres2" "', argument " "1"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlphaStrong * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AlphaStrong_muThres2" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->muThres2(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlphaStrong_facCMW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlphaStrong *arg1 = (Pythia8::AlphaStrong *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:AlphaStrong_facCMW",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaStrong_facCMW" "', argument " "1"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlphaStrong * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AlphaStrong_facCMW" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->facCMW(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AlphaStrong_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__AlphaStrong, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AlphaEM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlphaEM *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AlphaEM")) SWIG_fail;
  result = (Pythia8::AlphaEM *)new Pythia8::AlphaEM();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__AlphaEM, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlphaEM_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlphaEM *arg1 = (Pythia8::AlphaEM *) 0 ;
  int arg2 ;
  Pythia8::Settings *arg3 = (Pythia8::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:AlphaEM_init",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaEM_init" "', argument " "1"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlphaEM * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AlphaEM_init" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AlphaEM_init" "', argument " "3"" of type '" "Pythia8::Settings *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  (arg1)->init(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlphaEM_alphaEM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlphaEM *arg1 = (Pythia8::AlphaEM *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:AlphaEM_alphaEM",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaEM_alphaEM" "', argument " "1"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlphaEM * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AlphaEM_alphaEM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->alphaEM(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AlphaEM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlphaEM *arg1 = (Pythia8::AlphaEM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AlphaEM",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlphaEM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AlphaEM" "', argument " "1"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlphaEM * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AlphaEM_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__AlphaEM, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CoupSM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CoupSM")) SWIG_fail;
  result = (Pythia8::CoupSM *)new Pythia8::CoupSM();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CoupSM, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  Pythia8::Settings *arg2 = 0 ;
  Pythia8::Rndm *arg3 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:CoupSM_init",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_init" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSM_init" "', argument " "2"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CoupSM_init" "', argument " "2"" of type '" "Pythia8::Settings &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoupSM_init" "', argument " "3"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Rndm * >(argp3);
  (arg1)->init(*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_alphaS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSM_alphaS",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_alphaS" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSM_alphaS" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->alphaS(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_alphaS1Ord(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSM_alphaS1Ord",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_alphaS1Ord" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSM_alphaS1Ord" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->alphaS1Ord(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_alphaS2OrdCorr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSM_alphaS2OrdCorr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_alphaS2OrdCorr" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSM_alphaS2OrdCorr" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->alphaS2OrdCorr(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_Lambda3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSM_Lambda3",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_Lambda3" "', argument " "1"" of type '" "Pythia8::CoupSM const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  result = (double)((Pythia8::CoupSM const *)arg1)->Lambda3();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_Lambda4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSM_Lambda4",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_Lambda4" "', argument " "1"" of type '" "Pythia8::CoupSM const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  result = (double)((Pythia8::CoupSM const *)arg1)->Lambda4();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_Lambda5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSM_Lambda5",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_Lambda5" "', argument " "1"" of type '" "Pythia8::CoupSM const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  result = (double)((Pythia8::CoupSM const *)arg1)->Lambda5();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_alphaEM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSM_alphaEM",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_alphaEM" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSM_alphaEM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->alphaEM(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_sin2thetaW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSM_sin2thetaW",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_sin2thetaW" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  result = (double)(arg1)->sin2thetaW();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_cos2thetaW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSM_cos2thetaW",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_cos2thetaW" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  result = (double)(arg1)->cos2thetaW();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_sin2thetaWbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSM_sin2thetaWbar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_sin2thetaWbar" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  result = (double)(arg1)->sin2thetaWbar();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_GF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSM_GF",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_GF" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  result = (double)(arg1)->GF();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_ef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSM_ef",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_ef" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSM_ef" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->ef(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_vf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSM_vf",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_vf" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSM_vf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->vf(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_af(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSM_af",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_af" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSM_af" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->af(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_t3f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSM_t3f",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_t3f" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSM_t3f" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->t3f(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_lf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSM_lf",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_lf" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSM_lf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->lf(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_rf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSM_rf",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_rf" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSM_rf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->rf(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_ef2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSM_ef2",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_ef2" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSM_ef2" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->ef2(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_vf2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSM_vf2",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_vf2" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSM_vf2" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->vf2(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_af2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSM_af2",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_af2" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSM_af2" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->af2(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_efvf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSM_efvf",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_efvf" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSM_efvf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->efvf(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_vf2af2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSM_vf2af2",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_vf2af2" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSM_vf2af2" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->vf2af2(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_VCKMgen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:CoupSM_VCKMgen",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_VCKMgen" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSM_VCKMgen" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoupSM_VCKMgen" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)(arg1)->VCKMgen(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_V2CKMgen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:CoupSM_V2CKMgen",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_V2CKMgen" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSM_V2CKMgen" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoupSM_V2CKMgen" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)(arg1)->V2CKMgen(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_VCKMid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:CoupSM_VCKMid",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_VCKMid" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSM_VCKMid" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoupSM_VCKMid" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)(arg1)->VCKMid(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_V2CKMid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:CoupSM_V2CKMid",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_V2CKMid" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSM_V2CKMid" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoupSM_V2CKMid" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)(arg1)->V2CKMid(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_V2CKMsum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSM_V2CKMsum",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_V2CKMsum" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSM_V2CKMsum" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->V2CKMsum(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSM_V2CKMpick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSM_V2CKMpick",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSM_V2CKMpick" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSM_V2CKMpick" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->V2CKMpick(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CoupSM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSM *arg1 = (Pythia8::CoupSM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CoupSM",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CoupSM" "', argument " "1"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSM * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CoupSM_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__CoupSM, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Couplings__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Couplings *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Couplings",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Couplings" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  result = (Pythia8::Couplings *)new Pythia8::Couplings(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Couplings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Couplings__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Couplings *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Couplings")) SWIG_fail;
  result = (Pythia8::Couplings *)new Pythia8::Couplings();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Couplings, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Couplings(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Couplings__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Couplings__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Couplings'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Couplings::Couplings(bool)\n"
    "    Pythia8::Couplings::Couplings()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Couplings_isSUSY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Couplings *arg1 = (Pythia8::Couplings *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Couplings_isSUSY_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Couplings_isSUSY_set" "', argument " "1"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Couplings * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Couplings_isSUSY_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isSUSY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Couplings_isSUSY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Couplings *arg1 = (Pythia8::Couplings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Couplings_isSUSY_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Couplings_isSUSY_get" "', argument " "1"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Couplings * >(argp1);
  result = (bool) ((arg1)->isSUSY);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Couplings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Couplings *arg1 = (Pythia8::Couplings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Couplings",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Couplings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Couplings" "', argument " "1"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Couplings * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Couplings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Couplings, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CoupSUSY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CoupSUSY")) SWIG_fail;
  result = (Pythia8::CoupSUSY *)new Pythia8::CoupSUSY();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CoupSUSY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_initSUSY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::SusyLesHouches *arg2 = (Pythia8::SusyLesHouches *) 0 ;
  Pythia8::Info *arg3 = (Pythia8::Info *) 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Settings *arg5 = (Pythia8::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:CoupSUSY_initSUSY",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_initSUSY" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_initSUSY" "', argument " "2"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoupSUSY_initSUSY" "', argument " "3"" of type '" "Pythia8::Info *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Info * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CoupSUSY_initSUSY" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CoupSUSY_initSUSY" "', argument " "5"" of type '" "Pythia8::Settings *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Settings * >(argp5);
  (arg1)->initSUSY(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_isInit_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_isInit_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_isInit_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_isInit_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isInit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_isInit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_isInit_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_isInit_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (bool) ((arg1)->isInit);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_isNMSSM_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_isNMSSM_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_isNMSSM_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_isNMSSM_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isNMSSM = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_isNMSSM_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_isNMSSM_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_isNMSSM_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (bool) ((arg1)->isNMSSM);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_isLLE_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_isLLE_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_isLLE_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_isLLE_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isLLE = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_isLLE_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_isLLE_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_isLLE_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (bool) ((arg1)->isLLE);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_isLQD_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_isLQD_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_isLQD_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_isLQD_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isLQD = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_isLQD_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_isLQD_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_isLQD_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (bool) ((arg1)->isLQD);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_isUDD_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_isUDD_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_isUDD_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_isUDD_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isUDD = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_isUDD_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_isUDD_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_isUDD_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (bool) ((arg1)->isUDD);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_mWpole_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_mWpole_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_mWpole_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_mWpole_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->mWpole = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_mWpole_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_mWpole_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_mWpole_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (double) ((arg1)->mWpole);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_wWpole_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_wWpole_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_wWpole_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_wWpole_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->wWpole = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_wWpole_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_wWpole_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_wWpole_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (double) ((arg1)->wWpole);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_mZpole_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_mZpole_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_mZpole_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_mZpole_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->mZpole = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_mZpole_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_mZpole_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_mZpole_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (double) ((arg1)->mZpole);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_wZpole_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_wZpole_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_wZpole_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_wZpole_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->wZpole = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_wZpole_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_wZpole_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_wZpole_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (double) ((arg1)->wZpole);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_mW_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_mW_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_mW_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_mW_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->mW = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_mW_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_mW_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_mW_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (double) ((arg1)->mW);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_mZ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_mZ_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_mZ_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_mZ_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->mZ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_mZ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_mZ_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_mZ_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (double) ((arg1)->mZ);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_sin2W_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_sin2W_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_sin2W_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_sin2W_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->sin2W = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_sin2W_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_sin2W_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_sin2W_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (double) ((arg1)->sin2W);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_sinW_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_sinW_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_sinW_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_sinW_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->sinW = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_sinW_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_sinW_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_sinW_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (double) ((arg1)->sinW);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_cosW_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_cosW_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_cosW_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_cosW_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->cosW = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_cosW_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_cosW_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_cosW_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (double) ((arg1)->cosW);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_tanb_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_tanb_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_tanb_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_tanb_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->tanb = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_tanb_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_tanb_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_tanb_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (double) ((arg1)->tanb);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_cosb_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_cosb_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_cosb_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_cosb_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->cosb = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_cosb_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_cosb_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_cosb_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (double) ((arg1)->cosb);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_sinb_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_sinb_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_sinb_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_sinb_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->sinb = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_sinb_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_sinb_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_sinb_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (double) ((arg1)->sinb);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_muHiggs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_muHiggs_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_muHiggs_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_muHiggs_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->muHiggs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_muHiggs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_muHiggs_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_muHiggs_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (double) ((arg1)->muHiggs);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_alphaHiggs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_alphaHiggs_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_alphaHiggs_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_alphaHiggs_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->alphaHiggs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_alphaHiggs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_alphaHiggs_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_alphaHiggs_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (double) ((arg1)->alphaHiggs);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_mAHiggs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_mAHiggs_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_mAHiggs_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_mAHiggs_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->mAHiggs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_mAHiggs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_mAHiggs_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_mAHiggs_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (double) ((arg1)->mAHiggs);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_LsddG_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[4] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_LsddG_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_LsddG_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_4__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_LsddG_set" "', argument " "2"" of type '" "Pythia8::complex [7][4]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[4] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)4; ++jj) arg1->LsddG[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""LsddG""' of type '""Pythia8::complex [7][4]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""LsddG""' of type '""Pythia8::complex [7][4]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_LsddG_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[4] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_LsddG_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_LsddG_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[4])(Pythia8::complex (*)[4]) ((arg1)->LsddG);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_4__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_RsddG_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[4] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_RsddG_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_RsddG_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_4__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_RsddG_set" "', argument " "2"" of type '" "Pythia8::complex [7][4]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[4] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)4; ++jj) arg1->RsddG[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""RsddG""' of type '""Pythia8::complex [7][4]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""RsddG""' of type '""Pythia8::complex [7][4]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_RsddG_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[4] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_RsddG_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_RsddG_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[4])(Pythia8::complex (*)[4]) ((arg1)->RsddG);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_4__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_LsuuG_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[4] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_LsuuG_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_LsuuG_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_4__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_LsuuG_set" "', argument " "2"" of type '" "Pythia8::complex [7][4]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[4] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)4; ++jj) arg1->LsuuG[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""LsuuG""' of type '""Pythia8::complex [7][4]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""LsuuG""' of type '""Pythia8::complex [7][4]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_LsuuG_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[4] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_LsuuG_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_LsuuG_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[4])(Pythia8::complex (*)[4]) ((arg1)->LsuuG);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_4__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_RsuuG_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[4] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_RsuuG_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_RsuuG_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_4__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_RsuuG_set" "', argument " "2"" of type '" "Pythia8::complex [7][4]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[4] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)4; ++jj) arg1->RsuuG[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""RsuuG""' of type '""Pythia8::complex [7][4]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""RsuuG""' of type '""Pythia8::complex [7][4]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_RsuuG_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[4] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_RsuuG_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_RsuuG_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[4])(Pythia8::complex (*)[4]) ((arg1)->RsuuG);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_4__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_getLsqqG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::complex result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:CoupSUSY_getLsqqG",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_getLsqqG" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_getLsqqG" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoupSUSY_getLsqqG" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (arg1)->getLsqqG(arg2,arg3);
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_getRsqqG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::complex result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:CoupSUSY_getRsqqG",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_getRsqqG" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_getRsqqG" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoupSUSY_getRsqqG" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (arg1)->getRsqqG(arg2,arg3);
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_OLpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[6] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_OLpp_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_OLpp_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_6__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_OLpp_set" "', argument " "2"" of type '" "Pythia8::complex [6][6]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[6] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)6; ++jj) arg1->OLpp[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""OLpp""' of type '""Pythia8::complex [6][6]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""OLpp""' of type '""Pythia8::complex [6][6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_OLpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[6] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_OLpp_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_OLpp_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[6])(Pythia8::complex (*)[6]) ((arg1)->OLpp);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_6__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_ORpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[6] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_ORpp_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_ORpp_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_6__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_ORpp_set" "', argument " "2"" of type '" "Pythia8::complex [6][6]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[6] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)6; ++jj) arg1->ORpp[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""ORpp""' of type '""Pythia8::complex [6][6]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""ORpp""' of type '""Pythia8::complex [6][6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_ORpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[6] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_ORpp_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_ORpp_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[6])(Pythia8::complex (*)[6]) ((arg1)->ORpp);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_6__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_OLp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[3] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_OLp_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_OLp_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_3__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_OLp_set" "', argument " "2"" of type '" "Pythia8::complex [3][3]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[3] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)3; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)3; ++jj) arg1->OLp[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""OLp""' of type '""Pythia8::complex [3][3]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""OLp""' of type '""Pythia8::complex [3][3]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_OLp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[3] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_OLp_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_OLp_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[3])(Pythia8::complex (*)[3]) ((arg1)->OLp);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_3__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_ORp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[3] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_ORp_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_ORp_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_3__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_ORp_set" "', argument " "2"" of type '" "Pythia8::complex [3][3]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[3] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)3; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)3; ++jj) arg1->ORp[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""ORp""' of type '""Pythia8::complex [3][3]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""ORp""' of type '""Pythia8::complex [3][3]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_ORp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[3] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_ORp_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_ORp_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[3])(Pythia8::complex (*)[3]) ((arg1)->ORp);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_3__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_OL_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[3] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_OL_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_OL_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_3__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_OL_set" "', argument " "2"" of type '" "Pythia8::complex [6][3]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[3] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)3; ++jj) arg1->OL[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""OL""' of type '""Pythia8::complex [6][3]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""OL""' of type '""Pythia8::complex [6][3]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_OL_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[3] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_OL_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_OL_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[3])(Pythia8::complex (*)[3]) ((arg1)->OL);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_3__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_OR_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[3] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_OR_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_OR_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_3__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_OR_set" "', argument " "2"" of type '" "Pythia8::complex [6][3]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[3] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)3; ++jj) arg1->OR[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""OR""' of type '""Pythia8::complex [6][3]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""OR""' of type '""Pythia8::complex [6][3]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_OR_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[3] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_OR_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_OR_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[3])(Pythia8::complex (*)[3]) ((arg1)->OR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_3__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_LqqZ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_LqqZ_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_LqqZ_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_LqqZ_set" "', argument " "2"" of type '" "double [7]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) *(double *)&arg1->LqqZ[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""LqqZ""' of type '""double [7]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_LqqZ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_LqqZ_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_LqqZ_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (double *)(double *) ((arg1)->LqqZ);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_RqqZ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_RqqZ_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_RqqZ_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_RqqZ_set" "', argument " "2"" of type '" "double [7]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) *(double *)&arg1->RqqZ[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""RqqZ""' of type '""double [7]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_RqqZ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_RqqZ_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_RqqZ_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (double *)(double *) ((arg1)->RqqZ);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_LsdsdZ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[7] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_LsdsdZ_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_LsdsdZ_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_LsdsdZ_set" "', argument " "2"" of type '" "Pythia8::complex [7][7]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[7] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)7; ++jj) arg1->LsdsdZ[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""LsdsdZ""' of type '""Pythia8::complex [7][7]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""LsdsdZ""' of type '""Pythia8::complex [7][7]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_LsdsdZ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[7] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_LsdsdZ_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_LsdsdZ_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[7])(Pythia8::complex (*)[7]) ((arg1)->LsdsdZ);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_RsdsdZ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[7] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_RsdsdZ_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_RsdsdZ_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_RsdsdZ_set" "', argument " "2"" of type '" "Pythia8::complex [7][7]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[7] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)7; ++jj) arg1->RsdsdZ[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""RsdsdZ""' of type '""Pythia8::complex [7][7]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""RsdsdZ""' of type '""Pythia8::complex [7][7]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_RsdsdZ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[7] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_RsdsdZ_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_RsdsdZ_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[7])(Pythia8::complex (*)[7]) ((arg1)->RsdsdZ);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_LsusuZ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[7] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_LsusuZ_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_LsusuZ_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_LsusuZ_set" "', argument " "2"" of type '" "Pythia8::complex [7][7]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[7] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)7; ++jj) arg1->LsusuZ[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""LsusuZ""' of type '""Pythia8::complex [7][7]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""LsusuZ""' of type '""Pythia8::complex [7][7]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_LsusuZ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[7] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_LsusuZ_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_LsusuZ_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[7])(Pythia8::complex (*)[7]) ((arg1)->LsusuZ);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_RsusuZ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[7] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_RsusuZ_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_RsusuZ_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_RsusuZ_set" "', argument " "2"" of type '" "Pythia8::complex [7][7]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[7] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)7; ++jj) arg1->RsusuZ[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""RsusuZ""' of type '""Pythia8::complex [7][7]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""RsusuZ""' of type '""Pythia8::complex [7][7]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_RsusuZ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[7] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_RsusuZ_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_RsusuZ_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[7])(Pythia8::complex (*)[7]) ((arg1)->RsusuZ);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_getLsqsqZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::complex result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:CoupSUSY_getLsqsqZ",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_getLsqsqZ" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_getLsqsqZ" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoupSUSY_getLsqsqZ" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (arg1)->getLsqsqZ(arg2,arg3);
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_getRsqsqZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::complex result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:CoupSUSY_getRsqsqZ",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_getRsqsqZ" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_getRsqsqZ" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoupSUSY_getRsqsqZ" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (arg1)->getRsqsqZ(arg2,arg3);
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_LudW_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[4] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_LudW_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_LudW_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_4__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_LudW_set" "', argument " "2"" of type '" "Pythia8::complex [4][4]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[4] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)4; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)4; ++jj) arg1->LudW[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""LudW""' of type '""Pythia8::complex [4][4]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""LudW""' of type '""Pythia8::complex [4][4]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_LudW_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[4] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_LudW_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_LudW_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[4])(Pythia8::complex (*)[4]) ((arg1)->LudW);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_4__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_RudW_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[4] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_RudW_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_RudW_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_4__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_RudW_set" "', argument " "2"" of type '" "Pythia8::complex [4][4]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[4] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)4; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)4; ++jj) arg1->RudW[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""RudW""' of type '""Pythia8::complex [4][4]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""RudW""' of type '""Pythia8::complex [4][4]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_RudW_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[4] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_RudW_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_RudW_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[4])(Pythia8::complex (*)[4]) ((arg1)->RudW);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_4__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_LsusdW_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[7] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_LsusdW_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_LsusdW_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_LsusdW_set" "', argument " "2"" of type '" "Pythia8::complex [7][7]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[7] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)7; ++jj) arg1->LsusdW[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""LsusdW""' of type '""Pythia8::complex [7][7]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""LsusdW""' of type '""Pythia8::complex [7][7]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_LsusdW_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[7] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_LsusdW_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_LsusdW_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[7])(Pythia8::complex (*)[7]) ((arg1)->LsusdW);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_RsusdW_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[7] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_RsusdW_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_RsusdW_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_RsusdW_set" "', argument " "2"" of type '" "Pythia8::complex [7][7]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[7] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)7; ++jj) arg1->RsusdW[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""RsusdW""' of type '""Pythia8::complex [7][7]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""RsusdW""' of type '""Pythia8::complex [7][7]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_RsusdW_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[7] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_RsusdW_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_RsusdW_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[7])(Pythia8::complex (*)[7]) ((arg1)->RsusdW);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_getLsqqX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::complex result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:CoupSUSY_getLsqqX",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_getLsqqX" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_getLsqqX" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoupSUSY_getLsqqX" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CoupSUSY_getLsqqX" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (arg1)->getLsqqX(arg2,arg3,arg4);
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_getRsqqX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::complex result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:CoupSUSY_getRsqqX",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_getRsqqX" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_getRsqqX" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoupSUSY_getRsqqX" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CoupSUSY_getRsqqX" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (arg1)->getRsqqX(arg2,arg3,arg4);
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_LllZ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_LllZ_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_LllZ_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_LllZ_set" "', argument " "2"" of type '" "double [7]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) *(double *)&arg1->LllZ[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""LllZ""' of type '""double [7]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_LllZ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_LllZ_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_LllZ_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (double *)(double *) ((arg1)->LllZ);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_RllZ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_RllZ_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_RllZ_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_RllZ_set" "', argument " "2"" of type '" "double [7]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) *(double *)&arg1->RllZ[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""RllZ""' of type '""double [7]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_RllZ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_RllZ_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_RllZ_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (double *)(double *) ((arg1)->RllZ);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_LlvW_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[4] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_LlvW_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_LlvW_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_4__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_LlvW_set" "', argument " "2"" of type '" "Pythia8::complex [4][4]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[4] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)4; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)4; ++jj) arg1->LlvW[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""LlvW""' of type '""Pythia8::complex [4][4]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""LlvW""' of type '""Pythia8::complex [4][4]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_LlvW_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[4] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_LlvW_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_LlvW_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[4])(Pythia8::complex (*)[4]) ((arg1)->LlvW);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_4__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_RlvW_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[4] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_RlvW_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_RlvW_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_4__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_RlvW_set" "', argument " "2"" of type '" "Pythia8::complex [4][4]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[4] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)4; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)4; ++jj) arg1->RlvW[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""RlvW""' of type '""Pythia8::complex [4][4]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""RlvW""' of type '""Pythia8::complex [4][4]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_RlvW_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[4] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_RlvW_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_RlvW_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[4])(Pythia8::complex (*)[4]) ((arg1)->RlvW);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_4__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_LslslZ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[7] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_LslslZ_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_LslslZ_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_LslslZ_set" "', argument " "2"" of type '" "Pythia8::complex [7][7]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[7] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)7; ++jj) arg1->LslslZ[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""LslslZ""' of type '""Pythia8::complex [7][7]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""LslslZ""' of type '""Pythia8::complex [7][7]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_LslslZ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[7] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_LslslZ_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_LslslZ_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[7])(Pythia8::complex (*)[7]) ((arg1)->LslslZ);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_RslslZ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[7] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_RslslZ_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_RslslZ_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_RslslZ_set" "', argument " "2"" of type '" "Pythia8::complex [7][7]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[7] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)7; ++jj) arg1->RslslZ[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""RslslZ""' of type '""Pythia8::complex [7][7]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""RslslZ""' of type '""Pythia8::complex [7][7]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_RslslZ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[7] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_RslslZ_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_RslslZ_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[7])(Pythia8::complex (*)[7]) ((arg1)->RslslZ);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_LsvsvZ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[7] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_LsvsvZ_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_LsvsvZ_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_LsvsvZ_set" "', argument " "2"" of type '" "Pythia8::complex [7][7]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[7] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)7; ++jj) arg1->LsvsvZ[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""LsvsvZ""' of type '""Pythia8::complex [7][7]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""LsvsvZ""' of type '""Pythia8::complex [7][7]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_LsvsvZ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[7] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_LsvsvZ_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_LsvsvZ_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[7])(Pythia8::complex (*)[7]) ((arg1)->LsvsvZ);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_RsvsvZ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[7] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_RsvsvZ_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_RsvsvZ_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_RsvsvZ_set" "', argument " "2"" of type '" "Pythia8::complex [7][7]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[7] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)7; ++jj) arg1->RsvsvZ[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""RsvsvZ""' of type '""Pythia8::complex [7][7]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""RsvsvZ""' of type '""Pythia8::complex [7][7]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_RsvsvZ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[7] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_RsvsvZ_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_RsvsvZ_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[7])(Pythia8::complex (*)[7]) ((arg1)->RsvsvZ);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_LslsvW_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[7] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_LslsvW_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_LslsvW_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_LslsvW_set" "', argument " "2"" of type '" "Pythia8::complex [7][7]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[7] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)7; ++jj) arg1->LslsvW[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""LslsvW""' of type '""Pythia8::complex [7][7]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""LslsvW""' of type '""Pythia8::complex [7][7]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_LslsvW_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[7] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_LslsvW_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_LslsvW_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[7])(Pythia8::complex (*)[7]) ((arg1)->LslsvW);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_RslsvW_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[7] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_RslsvW_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_RslsvW_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_RslsvW_set" "', argument " "2"" of type '" "Pythia8::complex [7][7]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[7] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)7; ++jj) arg1->RslsvW[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""RslsvW""' of type '""Pythia8::complex [7][7]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""RslsvW""' of type '""Pythia8::complex [7][7]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_RslsvW_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[7] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_RslsvW_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_RslsvW_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[7])(Pythia8::complex (*)[7]) ((arg1)->RslsvW);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_Rusq_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[7] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_Rusq_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_Rusq_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_Rusq_set" "', argument " "2"" of type '" "Pythia8::complex [7][7]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[7] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)7; ++jj) arg1->Rusq[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Rusq""' of type '""Pythia8::complex [7][7]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Rusq""' of type '""Pythia8::complex [7][7]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_Rusq_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[7] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_Rusq_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_Rusq_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[7])(Pythia8::complex (*)[7]) ((arg1)->Rusq);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_Rdsq_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[7] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_Rdsq_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_Rdsq_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_Rdsq_set" "', argument " "2"" of type '" "Pythia8::complex [7][7]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[7] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)7; ++jj) arg1->Rdsq[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Rdsq""' of type '""Pythia8::complex [7][7]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Rdsq""' of type '""Pythia8::complex [7][7]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_Rdsq_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[7] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_Rdsq_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_Rdsq_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[7])(Pythia8::complex (*)[7]) ((arg1)->Rdsq);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_Rsl_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[7] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_Rsl_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_Rsl_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_Rsl_set" "', argument " "2"" of type '" "Pythia8::complex [7][7]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[7] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)7; ++jj) arg1->Rsl[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Rsl""' of type '""Pythia8::complex [7][7]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Rsl""' of type '""Pythia8::complex [7][7]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_Rsl_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[7] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_Rsl_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_Rsl_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[7])(Pythia8::complex (*)[7]) ((arg1)->Rsl);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_Rsv_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::complex (*arg2)[7] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_Rsv_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_Rsv_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_Rsv_set" "', argument " "2"" of type '" "Pythia8::complex [7][7]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::complex (*)[7] >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)7; ++ii) {
        if (arg2[ii]) {
          size_t jj = 0;
          for (; jj < (size_t)7; ++jj) arg1->Rsv[ii][jj] = arg2[ii][jj];
        } else {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Rsv""' of type '""Pythia8::complex [7][7]""'");
        }
      }
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Rsv""' of type '""Pythia8::complex [7][7]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_Rsv_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::complex (*result)[7] = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_Rsv_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_Rsv_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::complex (*)[7])(Pythia8::complex (*)[7]) ((arg1)->Rsv);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_7__std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_idNeut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_idNeut",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_idNeut" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_idNeut" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->idNeut(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_idChar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_idChar",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_idChar" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_idChar" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->idChar(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_idSup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_idSup",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_idSup" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_idSup" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->idSup(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_idSdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_idSdown",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_idSdown" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_idSdown" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->idSdown(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_idSlep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_idSlep",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_idSlep" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_idSlep" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->idSlep(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_typeNeut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_typeNeut",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_typeNeut" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_typeNeut" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->typeNeut(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_typeChar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_typeChar",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_typeChar" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoupSUSY_typeChar" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->typeChar(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_slhaPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::SusyLesHouches *arg2 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CoupSUSY_slhaPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_slhaPtr_set" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__SusyLesHouches, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoupSUSY_slhaPtr_set" "', argument " "2"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp2);
  if (arg1) (arg1)->slhaPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoupSUSY_slhaPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::SusyLesHouches *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CoupSUSY_slhaPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoupSUSY_slhaPtr_get" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  result = (Pythia8::SusyLesHouches *) ((arg1)->slhaPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CoupSUSY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CoupSUSY *arg1 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CoupSUSY",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CoupSUSY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CoupSUSY" "', argument " "1"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CoupSUSY * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CoupSUSY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__CoupSUSY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BeamShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::BeamShape *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_BeamShape",&obj0)) SWIG_fail;
  arg1 = obj0;
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (Pythia8::BeamShape *)new SwigDirector_BeamShape(arg1); 
  } else {
    result = (Pythia8::BeamShape *)new Pythia8::BeamShape(); 
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__BeamShape, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BeamShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BeamShape",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BeamShape" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  Pythia8::Settings *arg2 = 0 ;
  Pythia8::Rndm *arg3 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:BeamShape_init",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_init" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BeamShape_init" "', argument " "2"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BeamShape_init" "', argument " "2"" of type '" "Pythia8::Settings &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BeamShape_init" "', argument " "3"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Rndm * >(argp3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::BeamShape::init(*arg2,arg3);
    } else {
      (arg1)->init(*arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_pick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_pick",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_pick" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::BeamShape::pick();
    } else {
      (arg1)->pick();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_deltaPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_deltaPA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_deltaPA" "', argument " "1"" of type '" "Pythia8::BeamShape const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  result = ((Pythia8::BeamShape const *)arg1)->deltaPA();
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_deltaPB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_deltaPB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_deltaPB" "', argument " "1"" of type '" "Pythia8::BeamShape const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  result = ((Pythia8::BeamShape const *)arg1)->deltaPB();
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_vertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_vertex",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_vertex" "', argument " "1"" of type '" "Pythia8::BeamShape const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  result = ((Pythia8::BeamShape const *)arg1)->vertex();
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_deltaPxA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_deltaPxA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_deltaPxA_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_deltaPxA_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->deltaPxA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_deltaPxA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_deltaPxA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_deltaPxA_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->deltaPxA);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_deltaPyA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_deltaPyA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_deltaPyA_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_deltaPyA_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->deltaPyA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_deltaPyA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_deltaPyA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_deltaPyA_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->deltaPyA);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_deltaPzA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_deltaPzA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_deltaPzA_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_deltaPzA_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->deltaPzA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_deltaPzA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_deltaPzA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_deltaPzA_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->deltaPzA);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_deltaPxB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_deltaPxB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_deltaPxB_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_deltaPxB_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->deltaPxB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_deltaPxB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_deltaPxB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_deltaPxB_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->deltaPxB);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_deltaPyB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_deltaPyB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_deltaPyB_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_deltaPyB_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->deltaPyB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_deltaPyB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_deltaPyB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_deltaPyB_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->deltaPyB);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_deltaPzB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_deltaPzB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_deltaPzB_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_deltaPzB_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->deltaPzB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_deltaPzB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_deltaPzB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_deltaPzB_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->deltaPzB);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_vertexX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_vertexX_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_vertexX_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_vertexX_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->vertexX = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_vertexX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_vertexX_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_vertexX_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->vertexX);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_vertexY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_vertexY_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_vertexY_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_vertexY_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->vertexY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_vertexY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_vertexY_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_vertexY_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->vertexY);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_vertexZ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_vertexZ_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_vertexZ_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_vertexZ_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->vertexZ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_vertexZ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_vertexZ_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_vertexZ_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->vertexZ);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_vertexT_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_vertexT_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_vertexT_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_vertexT_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->vertexT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_vertexT_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_vertexT_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_vertexT_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->vertexT);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_allowMomentumSpread_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_allowMomentumSpread_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_allowMomentumSpread_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_allowMomentumSpread_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->allowMomentumSpread = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_allowMomentumSpread_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_allowMomentumSpread_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_allowMomentumSpread_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (bool) (darg->allowMomentumSpread);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_allowVertexSpread_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_allowVertexSpread_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_allowVertexSpread_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_allowVertexSpread_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->allowVertexSpread = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_allowVertexSpread_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_allowVertexSpread_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_allowVertexSpread_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (bool) (darg->allowVertexSpread);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_sigmaPxA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_sigmaPxA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_sigmaPxA_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_sigmaPxA_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->sigmaPxA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_sigmaPxA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_sigmaPxA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_sigmaPxA_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->sigmaPxA);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_sigmaPyA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_sigmaPyA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_sigmaPyA_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_sigmaPyA_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->sigmaPyA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_sigmaPyA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_sigmaPyA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_sigmaPyA_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->sigmaPyA);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_sigmaPzA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_sigmaPzA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_sigmaPzA_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_sigmaPzA_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->sigmaPzA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_sigmaPzA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_sigmaPzA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_sigmaPzA_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->sigmaPzA);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_maxDevA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_maxDevA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_maxDevA_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_maxDevA_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->maxDevA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_maxDevA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_maxDevA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_maxDevA_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->maxDevA);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_sigmaPxB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_sigmaPxB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_sigmaPxB_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_sigmaPxB_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->sigmaPxB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_sigmaPxB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_sigmaPxB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_sigmaPxB_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->sigmaPxB);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_sigmaPyB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_sigmaPyB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_sigmaPyB_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_sigmaPyB_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->sigmaPyB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_sigmaPyB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_sigmaPyB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_sigmaPyB_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->sigmaPyB);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_sigmaPzB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_sigmaPzB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_sigmaPzB_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_sigmaPzB_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->sigmaPzB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_sigmaPzB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_sigmaPzB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_sigmaPzB_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->sigmaPzB);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_maxDevB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_maxDevB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_maxDevB_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_maxDevB_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->maxDevB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_maxDevB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_maxDevB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_maxDevB_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->maxDevB);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_sigmaVertexX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_sigmaVertexX_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_sigmaVertexX_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_sigmaVertexX_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->sigmaVertexX = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_sigmaVertexX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_sigmaVertexX_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_sigmaVertexX_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->sigmaVertexX);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_sigmaVertexY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_sigmaVertexY_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_sigmaVertexY_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_sigmaVertexY_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->sigmaVertexY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_sigmaVertexY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_sigmaVertexY_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_sigmaVertexY_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->sigmaVertexY);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_sigmaVertexZ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_sigmaVertexZ_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_sigmaVertexZ_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_sigmaVertexZ_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->sigmaVertexZ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_sigmaVertexZ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_sigmaVertexZ_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_sigmaVertexZ_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->sigmaVertexZ);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_maxDevVertex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_maxDevVertex_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_maxDevVertex_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_maxDevVertex_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->maxDevVertex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_maxDevVertex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_maxDevVertex_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_maxDevVertex_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->maxDevVertex);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_sigmaTime_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_sigmaTime_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_sigmaTime_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_sigmaTime_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->sigmaTime = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_sigmaTime_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_sigmaTime_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_sigmaTime_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->sigmaTime);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_maxDevTime_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_maxDevTime_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_maxDevTime_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_maxDevTime_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->maxDevTime = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_maxDevTime_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_maxDevTime_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_maxDevTime_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->maxDevTime);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_offsetX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_offsetX_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_offsetX_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_offsetX_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->offsetX = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_offsetX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_offsetX_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_offsetX_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->offsetX);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_offsetY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_offsetY_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_offsetY_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_offsetY_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->offsetY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_offsetY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_offsetY_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_offsetY_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->offsetY);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_offsetZ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_offsetZ_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_offsetZ_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_offsetZ_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->offsetZ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_offsetZ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_offsetZ_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_offsetZ_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->offsetZ);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_offsetT_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_offsetT_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_offsetT_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamShape_offsetT_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->offsetT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_offsetT_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_offsetT_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_offsetT_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (double) (darg->offsetT);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_rndmPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  Pythia8::Rndm *arg2 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamShape_rndmPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_rndmPtr_set" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Rndm, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BeamShape_rndmPtr_set" "', argument " "2"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Rndm * >(argp2);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  if (arg1) darg->rndmPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamShape_rndmPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_BeamShape *darg = 0;
  Pythia8::Rndm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamShape_rndmPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamShape_rndmPtr_get" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  darg = dynamic_cast<SwigDirector_BeamShape *>(arg1);
  result = (Pythia8::Rndm *) (darg->rndmPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_BeamShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamShape *arg1 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:disown_BeamShape",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_BeamShape" "', argument " "1"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamShape * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BeamShape_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__BeamShape, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DecayChannel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int arg10 ;
  int arg11 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  Pythia8::DecayChannel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:new_DecayChannel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DecayChannel" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DecayChannel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DecayChannel" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DecayChannel" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DecayChannel" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DecayChannel" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DecayChannel" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DecayChannel" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DecayChannel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_DecayChannel" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_DecayChannel" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  result = (Pythia8::DecayChannel *)new Pythia8::DecayChannel(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__DecayChannel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DecayChannel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int arg10 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  Pythia8::DecayChannel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:new_DecayChannel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DecayChannel" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DecayChannel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DecayChannel" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DecayChannel" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DecayChannel" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DecayChannel" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DecayChannel" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DecayChannel" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DecayChannel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_DecayChannel" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  result = (Pythia8::DecayChannel *)new Pythia8::DecayChannel(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__DecayChannel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DecayChannel__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  Pythia8::DecayChannel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_DecayChannel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DecayChannel" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DecayChannel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DecayChannel" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DecayChannel" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DecayChannel" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DecayChannel" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DecayChannel" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DecayChannel" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DecayChannel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  result = (Pythia8::DecayChannel *)new Pythia8::DecayChannel(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__DecayChannel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DecayChannel__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  Pythia8::DecayChannel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:new_DecayChannel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DecayChannel" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DecayChannel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DecayChannel" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DecayChannel" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DecayChannel" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DecayChannel" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DecayChannel" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DecayChannel" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  result = (Pythia8::DecayChannel *)new Pythia8::DecayChannel(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__DecayChannel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DecayChannel__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Pythia8::DecayChannel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_DecayChannel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DecayChannel" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DecayChannel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DecayChannel" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DecayChannel" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DecayChannel" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DecayChannel" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DecayChannel" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  result = (Pythia8::DecayChannel *)new Pythia8::DecayChannel(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__DecayChannel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DecayChannel__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::DecayChannel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_DecayChannel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DecayChannel" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DecayChannel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DecayChannel" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DecayChannel" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DecayChannel" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DecayChannel" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (Pythia8::DecayChannel *)new Pythia8::DecayChannel(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__DecayChannel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DecayChannel__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::DecayChannel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_DecayChannel",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DecayChannel" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DecayChannel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DecayChannel" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DecayChannel" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DecayChannel" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (Pythia8::DecayChannel *)new Pythia8::DecayChannel(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__DecayChannel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DecayChannel__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::DecayChannel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_DecayChannel",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DecayChannel" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DecayChannel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DecayChannel" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DecayChannel" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (Pythia8::DecayChannel *)new Pythia8::DecayChannel(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__DecayChannel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DecayChannel__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::DecayChannel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_DecayChannel",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DecayChannel" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DecayChannel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DecayChannel" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::DecayChannel *)new Pythia8::DecayChannel(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__DecayChannel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DecayChannel__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::DecayChannel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_DecayChannel",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DecayChannel" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DecayChannel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (Pythia8::DecayChannel *)new Pythia8::DecayChannel(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__DecayChannel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DecayChannel__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::DecayChannel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DecayChannel",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DecayChannel" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::DecayChannel *)new Pythia8::DecayChannel(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__DecayChannel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DecayChannel__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DecayChannel")) SWIG_fail;
  result = (Pythia8::DecayChannel *)new Pythia8::DecayChannel();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__DecayChannel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DecayChannel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[12] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 11) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_DecayChannel__SWIG_11(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_DecayChannel__SWIG_10(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_DecayChannel__SWIG_9(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_DecayChannel__SWIG_8(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_DecayChannel__SWIG_7(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_DecayChannel__SWIG_6(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_DecayChannel__SWIG_5(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_DecayChannel__SWIG_4(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_DecayChannel__SWIG_3(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_DecayChannel__SWIG_2(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_DecayChannel__SWIG_1(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_DecayChannel__SWIG_0(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DecayChannel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::DecayChannel::DecayChannel(int,double,int,int,int,int,int,int,int,int,int)\n"
    "    Pythia8::DecayChannel::DecayChannel(int,double,int,int,int,int,int,int,int,int)\n"
    "    Pythia8::DecayChannel::DecayChannel(int,double,int,int,int,int,int,int,int)\n"
    "    Pythia8::DecayChannel::DecayChannel(int,double,int,int,int,int,int,int)\n"
    "    Pythia8::DecayChannel::DecayChannel(int,double,int,int,int,int,int)\n"
    "    Pythia8::DecayChannel::DecayChannel(int,double,int,int,int,int)\n"
    "    Pythia8::DecayChannel::DecayChannel(int,double,int,int,int)\n"
    "    Pythia8::DecayChannel::DecayChannel(int,double,int,int)\n"
    "    Pythia8::DecayChannel::DecayChannel(int,double,int)\n"
    "    Pythia8::DecayChannel::DecayChannel(int,double)\n"
    "    Pythia8::DecayChannel::DecayChannel(int)\n"
    "    Pythia8::DecayChannel::DecayChannel()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DecayChannel_onMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *arg1 = (Pythia8::DecayChannel *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:DecayChannel_onMode",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayChannel_onMode" "', argument " "1"" of type '" "Pythia8::DecayChannel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayChannel * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DecayChannel_onMode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->onMode(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayChannel_bRatio__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *arg1 = (Pythia8::DecayChannel *) 0 ;
  double arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:DecayChannel_bRatio",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayChannel_bRatio" "', argument " "1"" of type '" "Pythia8::DecayChannel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayChannel * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DecayChannel_bRatio" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DecayChannel_bRatio" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->bRatio(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayChannel_bRatio__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *arg1 = (Pythia8::DecayChannel *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:DecayChannel_bRatio",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayChannel_bRatio" "', argument " "1"" of type '" "Pythia8::DecayChannel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayChannel * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DecayChannel_bRatio" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->bRatio(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayChannel_rescaleBR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *arg1 = (Pythia8::DecayChannel *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:DecayChannel_rescaleBR",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayChannel_rescaleBR" "', argument " "1"" of type '" "Pythia8::DecayChannel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayChannel * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DecayChannel_rescaleBR" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->rescaleBR(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayChannel_meMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *arg1 = (Pythia8::DecayChannel *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:DecayChannel_meMode",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayChannel_meMode" "', argument " "1"" of type '" "Pythia8::DecayChannel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayChannel * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DecayChannel_meMode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->meMode(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayChannel_multiplicity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *arg1 = (Pythia8::DecayChannel *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:DecayChannel_multiplicity",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayChannel_multiplicity" "', argument " "1"" of type '" "Pythia8::DecayChannel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayChannel * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DecayChannel_multiplicity" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->multiplicity(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayChannel_product__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *arg1 = (Pythia8::DecayChannel *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:DecayChannel_product",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayChannel_product" "', argument " "1"" of type '" "Pythia8::DecayChannel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayChannel * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DecayChannel_product" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DecayChannel_product" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->product(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayChannel_setHasChanged(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *arg1 = (Pythia8::DecayChannel *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:DecayChannel_setHasChanged",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayChannel_setHasChanged" "', argument " "1"" of type '" "Pythia8::DecayChannel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayChannel * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DecayChannel_setHasChanged" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setHasChanged(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayChannel_onMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *arg1 = (Pythia8::DecayChannel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DecayChannel_onMode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayChannel_onMode" "', argument " "1"" of type '" "Pythia8::DecayChannel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayChannel * >(argp1);
  result = (int)((Pythia8::DecayChannel const *)arg1)->onMode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayChannel_onMode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__DecayChannel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_DecayChannel_onMode__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__DecayChannel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DecayChannel_onMode__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DecayChannel_onMode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::DecayChannel::onMode(int)\n"
    "    Pythia8::DecayChannel::onMode() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DecayChannel_bRatio__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *arg1 = (Pythia8::DecayChannel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DecayChannel_bRatio",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayChannel_bRatio" "', argument " "1"" of type '" "Pythia8::DecayChannel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayChannel * >(argp1);
  result = (double)((Pythia8::DecayChannel const *)arg1)->bRatio();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayChannel_bRatio(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__DecayChannel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_DecayChannel_bRatio__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__DecayChannel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DecayChannel_bRatio__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__DecayChannel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DecayChannel_bRatio__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DecayChannel_bRatio'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::DecayChannel::bRatio(double,bool)\n"
    "    Pythia8::DecayChannel::bRatio(double)\n"
    "    Pythia8::DecayChannel::bRatio() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DecayChannel_meMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *arg1 = (Pythia8::DecayChannel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DecayChannel_meMode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayChannel_meMode" "', argument " "1"" of type '" "Pythia8::DecayChannel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayChannel * >(argp1);
  result = (int)((Pythia8::DecayChannel const *)arg1)->meMode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayChannel_meMode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__DecayChannel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_DecayChannel_meMode__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__DecayChannel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DecayChannel_meMode__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DecayChannel_meMode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::DecayChannel::meMode(int)\n"
    "    Pythia8::DecayChannel::meMode() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DecayChannel_multiplicity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *arg1 = (Pythia8::DecayChannel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DecayChannel_multiplicity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayChannel_multiplicity" "', argument " "1"" of type '" "Pythia8::DecayChannel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayChannel * >(argp1);
  result = (int)((Pythia8::DecayChannel const *)arg1)->multiplicity();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayChannel_multiplicity(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__DecayChannel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_DecayChannel_multiplicity__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__DecayChannel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DecayChannel_multiplicity__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DecayChannel_multiplicity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::DecayChannel::multiplicity(int)\n"
    "    Pythia8::DecayChannel::multiplicity() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DecayChannel_product__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *arg1 = (Pythia8::DecayChannel *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:DecayChannel_product",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayChannel_product" "', argument " "1"" of type '" "Pythia8::DecayChannel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayChannel * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DecayChannel_product" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::DecayChannel const *)arg1)->product(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayChannel_product(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__DecayChannel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DecayChannel_product__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__DecayChannel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DecayChannel_product__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DecayChannel_product'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::DecayChannel::product(int,int)\n"
    "    Pythia8::DecayChannel::product(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DecayChannel_hasChanged(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *arg1 = (Pythia8::DecayChannel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DecayChannel_hasChanged",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayChannel_hasChanged" "', argument " "1"" of type '" "Pythia8::DecayChannel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayChannel * >(argp1);
  result = (bool)((Pythia8::DecayChannel const *)arg1)->hasChanged();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayChannel_contains__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *arg1 = (Pythia8::DecayChannel *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:DecayChannel_contains",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayChannel_contains" "', argument " "1"" of type '" "Pythia8::DecayChannel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayChannel * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DecayChannel_contains" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)((Pythia8::DecayChannel const *)arg1)->contains(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayChannel_contains__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *arg1 = (Pythia8::DecayChannel *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:DecayChannel_contains",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayChannel_contains" "', argument " "1"" of type '" "Pythia8::DecayChannel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayChannel * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DecayChannel_contains" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DecayChannel_contains" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (bool)((Pythia8::DecayChannel const *)arg1)->contains(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayChannel_contains__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *arg1 = (Pythia8::DecayChannel *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:DecayChannel_contains",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayChannel_contains" "', argument " "1"" of type '" "Pythia8::DecayChannel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayChannel * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DecayChannel_contains" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DecayChannel_contains" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DecayChannel_contains" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (bool)((Pythia8::DecayChannel const *)arg1)->contains(arg2,arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayChannel_contains(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__DecayChannel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DecayChannel_contains__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__DecayChannel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DecayChannel_contains__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__DecayChannel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_DecayChannel_contains__SWIG_2(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DecayChannel_contains'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::DecayChannel::contains(int) const\n"
    "    Pythia8::DecayChannel::contains(int,int) const\n"
    "    Pythia8::DecayChannel::contains(int,int,int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DecayChannel_currentBR__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *arg1 = (Pythia8::DecayChannel *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:DecayChannel_currentBR",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayChannel_currentBR" "', argument " "1"" of type '" "Pythia8::DecayChannel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayChannel * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DecayChannel_currentBR" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->currentBR(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayChannel_currentBR__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *arg1 = (Pythia8::DecayChannel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DecayChannel_currentBR",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayChannel_currentBR" "', argument " "1"" of type '" "Pythia8::DecayChannel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayChannel * >(argp1);
  result = (double)((Pythia8::DecayChannel const *)arg1)->currentBR();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayChannel_currentBR(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__DecayChannel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_DecayChannel_currentBR__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__DecayChannel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DecayChannel_currentBR__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DecayChannel_currentBR'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::DecayChannel::currentBR(double)\n"
    "    Pythia8::DecayChannel::currentBR() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DecayChannel_onShellWidth__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *arg1 = (Pythia8::DecayChannel *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:DecayChannel_onShellWidth",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayChannel_onShellWidth" "', argument " "1"" of type '" "Pythia8::DecayChannel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayChannel * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DecayChannel_onShellWidth" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->onShellWidth(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayChannel_onShellWidth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *arg1 = (Pythia8::DecayChannel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DecayChannel_onShellWidth",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayChannel_onShellWidth" "', argument " "1"" of type '" "Pythia8::DecayChannel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayChannel * >(argp1);
  result = (double)((Pythia8::DecayChannel const *)arg1)->onShellWidth();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayChannel_onShellWidth(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__DecayChannel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_DecayChannel_onShellWidth__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__DecayChannel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DecayChannel_onShellWidth__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DecayChannel_onShellWidth'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::DecayChannel::onShellWidth(double)\n"
    "    Pythia8::DecayChannel::onShellWidth() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DecayChannel_onShellWidthFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *arg1 = (Pythia8::DecayChannel *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:DecayChannel_onShellWidthFactor",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayChannel_onShellWidthFactor" "', argument " "1"" of type '" "Pythia8::DecayChannel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayChannel * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DecayChannel_onShellWidthFactor" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->onShellWidthFactor(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayChannel_openSec__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *arg1 = (Pythia8::DecayChannel *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:DecayChannel_openSec",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayChannel_openSec" "', argument " "1"" of type '" "Pythia8::DecayChannel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayChannel * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DecayChannel_openSec" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DecayChannel_openSec" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->openSec(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayChannel_openSec__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *arg1 = (Pythia8::DecayChannel *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:DecayChannel_openSec",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayChannel_openSec" "', argument " "1"" of type '" "Pythia8::DecayChannel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayChannel * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DecayChannel_openSec" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::DecayChannel const *)arg1)->openSec(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayChannel_openSec(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__DecayChannel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DecayChannel_openSec__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__DecayChannel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DecayChannel_openSec__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DecayChannel_openSec'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::DecayChannel::openSec(int,double)\n"
    "    Pythia8::DecayChannel::openSec(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DecayChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayChannel *arg1 = (Pythia8::DecayChannel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DecayChannel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayChannel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DecayChannel" "', argument " "1"" of type '" "Pythia8::DecayChannel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayChannel * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DecayChannel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__DecayChannel, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ParticleDataEntry__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  int val1 ;
  int ecode1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  Pythia8::ParticleDataEntry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:new_ParticleDataEntry",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ParticleDataEntry" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ParticleDataEntry" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ParticleDataEntry" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ParticleDataEntry" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ParticleDataEntry" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ParticleDataEntry" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ParticleDataEntry" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ParticleDataEntry" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ParticleDataEntry" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (Pythia8::ParticleDataEntry *)new Pythia8::ParticleDataEntry(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDataEntry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParticleDataEntry__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  int val1 ;
  int ecode1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  Pythia8::ParticleDataEntry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_ParticleDataEntry",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ParticleDataEntry" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ParticleDataEntry" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ParticleDataEntry" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ParticleDataEntry" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ParticleDataEntry" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ParticleDataEntry" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ParticleDataEntry" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ParticleDataEntry" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (Pythia8::ParticleDataEntry *)new Pythia8::ParticleDataEntry(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDataEntry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParticleDataEntry__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  Pythia8::ParticleDataEntry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:new_ParticleDataEntry",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ParticleDataEntry" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ParticleDataEntry" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ParticleDataEntry" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ParticleDataEntry" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ParticleDataEntry" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ParticleDataEntry" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ParticleDataEntry" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (Pythia8::ParticleDataEntry *)new Pythia8::ParticleDataEntry(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDataEntry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParticleDataEntry__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Pythia8::ParticleDataEntry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_ParticleDataEntry",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ParticleDataEntry" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ParticleDataEntry" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ParticleDataEntry" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ParticleDataEntry" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ParticleDataEntry" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ParticleDataEntry" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (Pythia8::ParticleDataEntry *)new Pythia8::ParticleDataEntry(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDataEntry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParticleDataEntry__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  double arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::ParticleDataEntry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_ParticleDataEntry",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ParticleDataEntry" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ParticleDataEntry" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ParticleDataEntry" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ParticleDataEntry" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ParticleDataEntry" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (Pythia8::ParticleDataEntry *)new Pythia8::ParticleDataEntry(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDataEntry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParticleDataEntry__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::ParticleDataEntry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_ParticleDataEntry",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ParticleDataEntry" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ParticleDataEntry" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ParticleDataEntry" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ParticleDataEntry" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (Pythia8::ParticleDataEntry *)new Pythia8::ParticleDataEntry(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDataEntry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParticleDataEntry__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::ParticleDataEntry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_ParticleDataEntry",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ParticleDataEntry" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ParticleDataEntry" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ParticleDataEntry" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (Pythia8::ParticleDataEntry *)new Pythia8::ParticleDataEntry(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDataEntry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParticleDataEntry__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::ParticleDataEntry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_ParticleDataEntry",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ParticleDataEntry" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ParticleDataEntry" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::ParticleDataEntry *)new Pythia8::ParticleDataEntry(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDataEntry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParticleDataEntry__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::ParticleDataEntry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_ParticleDataEntry",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ParticleDataEntry" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::ParticleDataEntry *)new Pythia8::ParticleDataEntry(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDataEntry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParticleDataEntry__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ParticleDataEntry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ParticleDataEntry",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ParticleDataEntry" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ParticleDataEntry *)new Pythia8::ParticleDataEntry(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDataEntry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParticleDataEntry__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ParticleDataEntry")) SWIG_fail;
  result = (Pythia8::ParticleDataEntry *)new Pythia8::ParticleDataEntry();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDataEntry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParticleDataEntry__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  int val1 ;
  int ecode1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  Pythia8::ParticleDataEntry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:new_ParticleDataEntry",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ParticleDataEntry" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ParticleDataEntry" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ParticleDataEntry" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ParticleDataEntry" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ParticleDataEntry" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ParticleDataEntry" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ParticleDataEntry" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ParticleDataEntry" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_ParticleDataEntry" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  result = (Pythia8::ParticleDataEntry *)new Pythia8::ParticleDataEntry(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDataEntry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParticleDataEntry__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  int val1 ;
  int ecode1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  Pythia8::ParticleDataEntry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:new_ParticleDataEntry",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ParticleDataEntry" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ParticleDataEntry" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ParticleDataEntry" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ParticleDataEntry" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ParticleDataEntry" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ParticleDataEntry" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ParticleDataEntry" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_ParticleDataEntry" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (Pythia8::ParticleDataEntry *)new Pythia8::ParticleDataEntry(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDataEntry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParticleDataEntry__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  int val1 ;
  int ecode1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  Pythia8::ParticleDataEntry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_ParticleDataEntry",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ParticleDataEntry" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ParticleDataEntry" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ParticleDataEntry" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ParticleDataEntry" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ParticleDataEntry" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ParticleDataEntry" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_ParticleDataEntry" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (Pythia8::ParticleDataEntry *)new Pythia8::ParticleDataEntry(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDataEntry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParticleDataEntry__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  Pythia8::ParticleDataEntry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:new_ParticleDataEntry",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ParticleDataEntry" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ParticleDataEntry" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ParticleDataEntry" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ParticleDataEntry" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ParticleDataEntry" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ParticleDataEntry" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (Pythia8::ParticleDataEntry *)new Pythia8::ParticleDataEntry(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDataEntry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParticleDataEntry__SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Pythia8::ParticleDataEntry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_ParticleDataEntry",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ParticleDataEntry" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ParticleDataEntry" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ParticleDataEntry" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ParticleDataEntry" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ParticleDataEntry" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (Pythia8::ParticleDataEntry *)new Pythia8::ParticleDataEntry(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDataEntry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParticleDataEntry__SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::ParticleDataEntry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_ParticleDataEntry",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ParticleDataEntry" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ParticleDataEntry" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ParticleDataEntry" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ParticleDataEntry" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (Pythia8::ParticleDataEntry *)new Pythia8::ParticleDataEntry(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDataEntry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParticleDataEntry__SWIG_17(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  int arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::ParticleDataEntry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_ParticleDataEntry",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ParticleDataEntry" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ParticleDataEntry" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ParticleDataEntry" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (Pythia8::ParticleDataEntry *)new Pythia8::ParticleDataEntry(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDataEntry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParticleDataEntry__SWIG_18(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::ParticleDataEntry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_ParticleDataEntry",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ParticleDataEntry" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ParticleDataEntry" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (Pythia8::ParticleDataEntry *)new Pythia8::ParticleDataEntry(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDataEntry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParticleDataEntry__SWIG_19(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  std::string arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::ParticleDataEntry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_ParticleDataEntry",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ParticleDataEntry" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleDataEntry" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::ParticleDataEntry *)new Pythia8::ParticleDataEntry(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDataEntry, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ParticleDataEntry(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[12] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 11) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_ParticleDataEntry__SWIG_10(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ParticleDataEntry__SWIG_9(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_ParticleDataEntry__SWIG_8(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_ParticleDataEntry__SWIG_7(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_ParticleDataEntry__SWIG_19(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_ParticleDataEntry__SWIG_6(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_ParticleDataEntry__SWIG_18(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_ParticleDataEntry__SWIG_5(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_ParticleDataEntry__SWIG_17(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_ParticleDataEntry__SWIG_4(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_ParticleDataEntry__SWIG_16(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_ParticleDataEntry__SWIG_3(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_ParticleDataEntry__SWIG_15(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_ParticleDataEntry__SWIG_2(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_ParticleDataEntry__SWIG_14(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_ParticleDataEntry__SWIG_1(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_ParticleDataEntry__SWIG_13(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_ParticleDataEntry__SWIG_0(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_ParticleDataEntry__SWIG_12(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_ParticleDataEntry__SWIG_11(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ParticleDataEntry'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleDataEntry::ParticleDataEntry(int,std::string,int,int,int,double,double,double,double,double)\n"
    "    Pythia8::ParticleDataEntry::ParticleDataEntry(int,std::string,int,int,int,double,double,double,double)\n"
    "    Pythia8::ParticleDataEntry::ParticleDataEntry(int,std::string,int,int,int,double,double,double)\n"
    "    Pythia8::ParticleDataEntry::ParticleDataEntry(int,std::string,int,int,int,double,double)\n"
    "    Pythia8::ParticleDataEntry::ParticleDataEntry(int,std::string,int,int,int,double)\n"
    "    Pythia8::ParticleDataEntry::ParticleDataEntry(int,std::string,int,int,int)\n"
    "    Pythia8::ParticleDataEntry::ParticleDataEntry(int,std::string,int,int)\n"
    "    Pythia8::ParticleDataEntry::ParticleDataEntry(int,std::string,int)\n"
    "    Pythia8::ParticleDataEntry::ParticleDataEntry(int,std::string)\n"
    "    Pythia8::ParticleDataEntry::ParticleDataEntry(int)\n"
    "    Pythia8::ParticleDataEntry::ParticleDataEntry()\n"
    "    Pythia8::ParticleDataEntry::ParticleDataEntry(int,std::string,std::string,int,int,int,double,double,double,double,double)\n"
    "    Pythia8::ParticleDataEntry::ParticleDataEntry(int,std::string,std::string,int,int,int,double,double,double,double)\n"
    "    Pythia8::ParticleDataEntry::ParticleDataEntry(int,std::string,std::string,int,int,int,double,double,double)\n"
    "    Pythia8::ParticleDataEntry::ParticleDataEntry(int,std::string,std::string,int,int,int,double,double)\n"
    "    Pythia8::ParticleDataEntry::ParticleDataEntry(int,std::string,std::string,int,int,int,double)\n"
    "    Pythia8::ParticleDataEntry::ParticleDataEntry(int,std::string,std::string,int,int,int)\n"
    "    Pythia8::ParticleDataEntry::ParticleDataEntry(int,std::string,std::string,int,int)\n"
    "    Pythia8::ParticleDataEntry::ParticleDataEntry(int,std::string,std::string,int)\n"
    "    Pythia8::ParticleDataEntry::ParticleDataEntry(int,std::string,std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ParticleDataEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ParticleDataEntry",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ParticleDataEntry" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_setDefaults",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setDefaults" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  (arg1)->setDefaults();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_initPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  Pythia8::ParticleData *arg2 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_initPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_initPtr" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParticleDataEntry_initPtr" "', argument " "2"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ParticleData * >(argp2);
  (arg1)->initPtr(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setAll__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:ParticleDataEntry_setAll",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setAll" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleDataEntry_setAll" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleDataEntry_setAll" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleDataEntry_setAll" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleDataEntry_setAll" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleDataEntry_setAll" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleDataEntry_setAll" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ParticleDataEntry_setAll" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ParticleDataEntry_setAll" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ParticleDataEntry_setAll" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ParticleDataEntry_setAll" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  (arg1)->setAll(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setAll__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:ParticleDataEntry_setAll",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setAll" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleDataEntry_setAll" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleDataEntry_setAll" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleDataEntry_setAll" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleDataEntry_setAll" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleDataEntry_setAll" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleDataEntry_setAll" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ParticleDataEntry_setAll" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ParticleDataEntry_setAll" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ParticleDataEntry_setAll" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  (arg1)->setAll(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setAll__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:ParticleDataEntry_setAll",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setAll" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleDataEntry_setAll" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleDataEntry_setAll" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleDataEntry_setAll" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleDataEntry_setAll" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleDataEntry_setAll" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleDataEntry_setAll" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ParticleDataEntry_setAll" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ParticleDataEntry_setAll" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  (arg1)->setAll(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setAll__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:ParticleDataEntry_setAll",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setAll" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleDataEntry_setAll" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleDataEntry_setAll" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleDataEntry_setAll" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleDataEntry_setAll" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleDataEntry_setAll" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleDataEntry_setAll" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ParticleDataEntry_setAll" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  (arg1)->setAll(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setAll__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:ParticleDataEntry_setAll",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setAll" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleDataEntry_setAll" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleDataEntry_setAll" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleDataEntry_setAll" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleDataEntry_setAll" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleDataEntry_setAll" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleDataEntry_setAll" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  (arg1)->setAll(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setAll__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ParticleDataEntry_setAll",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setAll" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleDataEntry_setAll" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleDataEntry_setAll" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleDataEntry_setAll" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleDataEntry_setAll" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleDataEntry_setAll" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  (arg1)->setAll(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setAll__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ParticleDataEntry_setAll",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setAll" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleDataEntry_setAll" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleDataEntry_setAll" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleDataEntry_setAll" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleDataEntry_setAll" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  (arg1)->setAll(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setAll__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ParticleDataEntry_setAll",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setAll" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleDataEntry_setAll" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleDataEntry_setAll" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleDataEntry_setAll" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->setAll(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setAll__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleDataEntry_setAll",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setAll" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleDataEntry_setAll" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleDataEntry_setAll" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->setAll(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setAll(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[12] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 11) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ParticleDataEntry_setAll__SWIG_8(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ParticleDataEntry_setAll__SWIG_7(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ParticleDataEntry_setAll__SWIG_6(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_ParticleDataEntry_setAll__SWIG_5(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_ParticleDataEntry_setAll__SWIG_4(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_ParticleDataEntry_setAll__SWIG_3(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_ParticleDataEntry_setAll__SWIG_2(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_ParticleDataEntry_setAll__SWIG_1(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_ParticleDataEntry_setAll__SWIG_0(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleDataEntry_setAll'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleDataEntry::setAll(std::string,std::string,int,int,int,double,double,double,double,double)\n"
    "    Pythia8::ParticleDataEntry::setAll(std::string,std::string,int,int,int,double,double,double,double)\n"
    "    Pythia8::ParticleDataEntry::setAll(std::string,std::string,int,int,int,double,double,double)\n"
    "    Pythia8::ParticleDataEntry::setAll(std::string,std::string,int,int,int,double,double)\n"
    "    Pythia8::ParticleDataEntry::setAll(std::string,std::string,int,int,int,double)\n"
    "    Pythia8::ParticleDataEntry::setAll(std::string,std::string,int,int,int)\n"
    "    Pythia8::ParticleDataEntry::setAll(std::string,std::string,int,int)\n"
    "    Pythia8::ParticleDataEntry::setAll(std::string,std::string,int)\n"
    "    Pythia8::ParticleDataEntry::setAll(std::string,std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_setName",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setName" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleDataEntry_setName" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->setName(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setAntiName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_setAntiName",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setAntiName" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleDataEntry_setAntiName" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->setAntiName(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setNames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleDataEntry_setNames",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setNames" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleDataEntry_setNames" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleDataEntry_setNames" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->setNames(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setSpinType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_setSpinType",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setSpinType" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_setSpinType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setSpinType(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setChargeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_setChargeType",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setChargeType" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_setChargeType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setChargeType(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setColType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_setColType",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setColType" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_setColType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setColType(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setM0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_setM0",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setM0" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_setM0" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setM0(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setMWidth__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  double arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleDataEntry_setMWidth",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setMWidth" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_setMWidth" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleDataEntry_setMWidth" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setMWidth(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setMWidth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_setMWidth",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setMWidth" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_setMWidth" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setMWidth(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setMWidth(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleDataEntry_setMWidth__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleDataEntry_setMWidth__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleDataEntry_setMWidth'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleDataEntry::setMWidth(double,bool)\n"
    "    Pythia8::ParticleDataEntry::setMWidth(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setMMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_setMMin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setMMin" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_setMMin" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setMMin(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setMMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_setMMax",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setMMax" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_setMMax" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setMMax(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setMMinNoChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_setMMinNoChange",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setMMinNoChange" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_setMMinNoChange" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setMMinNoChange(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setMMaxNoChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_setMMaxNoChange",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setMMaxNoChange" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_setMMaxNoChange" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setMMaxNoChange(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setTau0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_setTau0",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setTau0" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_setTau0" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setTau0(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setIsResonance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_setIsResonance",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setIsResonance" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_setIsResonance" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setIsResonance(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setMayDecay__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleDataEntry_setMayDecay",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setMayDecay" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_setMayDecay" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleDataEntry_setMayDecay" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setMayDecay(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setMayDecay__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_setMayDecay",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setMayDecay" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_setMayDecay" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setMayDecay(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setMayDecay(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleDataEntry_setMayDecay__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleDataEntry_setMayDecay__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleDataEntry_setMayDecay'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleDataEntry::setMayDecay(bool,bool)\n"
    "    Pythia8::ParticleDataEntry::setMayDecay(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setDoExternalDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_setDoExternalDecay",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setDoExternalDecay" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_setDoExternalDecay" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setDoExternalDecay(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setIsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_setIsVisible",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setIsVisible" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_setIsVisible" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setIsVisible(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setDoForceWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_setDoForceWidth",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setDoForceWidth" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_setDoForceWidth" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setDoForceWidth(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setHasChanged(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_setHasChanged",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setHasChanged" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_setHasChanged" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setHasChanged(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_id",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_id" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (int)((Pythia8::ParticleDataEntry const *)arg1)->id();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_hasAnti(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_hasAnti",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_hasAnti" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (bool)((Pythia8::ParticleDataEntry const *)arg1)->hasAnti();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_name__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_name",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_name" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_name" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((Pythia8::ParticleDataEntry const *)arg1)->name(arg2);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_name__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_name" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = ((Pythia8::ParticleDataEntry const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_name(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ParticleDataEntry_name__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleDataEntry_name__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleDataEntry_name'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleDataEntry::name(int) const\n"
    "    Pythia8::ParticleDataEntry::name() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_spinType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_spinType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_spinType" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (int)((Pythia8::ParticleDataEntry const *)arg1)->spinType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_chargeType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_chargeType",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_chargeType" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_chargeType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::ParticleDataEntry const *)arg1)->chargeType(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_chargeType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_chargeType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_chargeType" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (int)((Pythia8::ParticleDataEntry const *)arg1)->chargeType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_chargeType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ParticleDataEntry_chargeType__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleDataEntry_chargeType__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleDataEntry_chargeType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleDataEntry::chargeType(int) const\n"
    "    Pythia8::ParticleDataEntry::chargeType() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_charge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_charge",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_charge" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_charge" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::ParticleDataEntry const *)arg1)->charge(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_charge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_charge",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_charge" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (double)((Pythia8::ParticleDataEntry const *)arg1)->charge();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_charge(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ParticleDataEntry_charge__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleDataEntry_charge__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleDataEntry_charge'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleDataEntry::charge(int) const\n"
    "    Pythia8::ParticleDataEntry::charge() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_colType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_colType",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_colType" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_colType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::ParticleDataEntry const *)arg1)->colType(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_colType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_colType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_colType" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (int)((Pythia8::ParticleDataEntry const *)arg1)->colType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_colType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ParticleDataEntry_colType__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleDataEntry_colType__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleDataEntry_colType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleDataEntry::colType(int) const\n"
    "    Pythia8::ParticleDataEntry::colType() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_m0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_m0",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_m0" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (double)((Pythia8::ParticleDataEntry const *)arg1)->m0();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_mWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_mWidth",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_mWidth" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (double)((Pythia8::ParticleDataEntry const *)arg1)->mWidth();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_mMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_mMin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_mMin" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (double)((Pythia8::ParticleDataEntry const *)arg1)->mMin();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_mMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_mMax",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_mMax" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (double)((Pythia8::ParticleDataEntry const *)arg1)->mMax();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_m0Min(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_m0Min",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_m0Min" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (double)((Pythia8::ParticleDataEntry const *)arg1)->m0Min();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_m0Max(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_m0Max",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_m0Max" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (double)((Pythia8::ParticleDataEntry const *)arg1)->m0Max();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_tau0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_tau0",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_tau0" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (double)((Pythia8::ParticleDataEntry const *)arg1)->tau0();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_isResonance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_isResonance",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_isResonance" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (bool)((Pythia8::ParticleDataEntry const *)arg1)->isResonance();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_mayDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_mayDecay",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_mayDecay" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (bool)((Pythia8::ParticleDataEntry const *)arg1)->mayDecay();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_doExternalDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_doExternalDecay",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_doExternalDecay" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (bool)((Pythia8::ParticleDataEntry const *)arg1)->doExternalDecay();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_isVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_isVisible",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_isVisible" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (bool)((Pythia8::ParticleDataEntry const *)arg1)->isVisible();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_doForceWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_doForceWidth",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_doForceWidth" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (bool)((Pythia8::ParticleDataEntry const *)arg1)->doForceWidth();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_hasChanged(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_hasChanged",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_hasChanged" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (bool)((Pythia8::ParticleDataEntry const *)arg1)->hasChanged();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_hasChangedMMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_hasChangedMMin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_hasChangedMMin" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (bool)((Pythia8::ParticleDataEntry const *)arg1)->hasChangedMMin();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_hasChangedMMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_hasChangedMMax",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_hasChangedMMax" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (bool)((Pythia8::ParticleDataEntry const *)arg1)->hasChangedMMax();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_initBWmass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_initBWmass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_initBWmass" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  (arg1)->initBWmass();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_constituentMass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_constituentMass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_constituentMass" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (double)((Pythia8::ParticleDataEntry const *)arg1)->constituentMass();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_mSel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_mSel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_mSel" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (double)(arg1)->mSel();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_mRun(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_mRun",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_mRun" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_mRun" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->mRun(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_useBreitWigner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_useBreitWigner",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_useBreitWigner" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (bool)((Pythia8::ParticleDataEntry const *)arg1)->useBreitWigner();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_canDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_canDecay",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_canDecay" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (bool)((Pythia8::ParticleDataEntry const *)arg1)->canDecay();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_isLepton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_isLepton",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_isLepton" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (bool)((Pythia8::ParticleDataEntry const *)arg1)->isLepton();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_isQuark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_isQuark",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_isQuark" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (bool)((Pythia8::ParticleDataEntry const *)arg1)->isQuark();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_isGluon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_isGluon",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_isGluon" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (bool)((Pythia8::ParticleDataEntry const *)arg1)->isGluon();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_isDiquark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_isDiquark",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_isDiquark" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (bool)((Pythia8::ParticleDataEntry const *)arg1)->isDiquark();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_isParton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_isParton",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_isParton" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (bool)((Pythia8::ParticleDataEntry const *)arg1)->isParton();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_isHadron(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_isHadron",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_isHadron" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (bool)((Pythia8::ParticleDataEntry const *)arg1)->isHadron();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_isMeson(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_isMeson",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_isMeson" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (bool)((Pythia8::ParticleDataEntry const *)arg1)->isMeson();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_isBaryon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_isBaryon",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_isBaryon" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (bool)((Pythia8::ParticleDataEntry const *)arg1)->isBaryon();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_isOctetHadron(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_isOctetHadron",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_isOctetHadron" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (bool)((Pythia8::ParticleDataEntry const *)arg1)->isOctetHadron();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_heaviestQuark__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_heaviestQuark",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_heaviestQuark" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_heaviestQuark" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::ParticleDataEntry const *)arg1)->heaviestQuark(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_heaviestQuark__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_heaviestQuark",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_heaviestQuark" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (int)((Pythia8::ParticleDataEntry const *)arg1)->heaviestQuark();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_heaviestQuark(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ParticleDataEntry_heaviestQuark__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleDataEntry_heaviestQuark__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleDataEntry_heaviestQuark'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleDataEntry::heaviestQuark(int) const\n"
    "    Pythia8::ParticleDataEntry::heaviestQuark() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_baryonNumberType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_baryonNumberType",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_baryonNumberType" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_baryonNumberType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::ParticleDataEntry const *)arg1)->baryonNumberType(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_baryonNumberType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_baryonNumberType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_baryonNumberType" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (int)((Pythia8::ParticleDataEntry const *)arg1)->baryonNumberType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_baryonNumberType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ParticleDataEntry_baryonNumberType__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleDataEntry_baryonNumberType__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleDataEntry_baryonNumberType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleDataEntry::baryonNumberType(int) const\n"
    "    Pythia8::ParticleDataEntry::baryonNumberType() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_nQuarksInCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_nQuarksInCode",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_nQuarksInCode" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_nQuarksInCode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::ParticleDataEntry const *)arg1)->nQuarksInCode(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_clearChannels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_clearChannels",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_clearChannels" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  (arg1)->clearChannels();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_addChannel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int arg10 ;
  int arg11 ;
  int arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:ParticleDataEntry_addChannel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_addChannel" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_addChannel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleDataEntry_addChannel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleDataEntry_addChannel" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleDataEntry_addChannel" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleDataEntry_addChannel" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleDataEntry_addChannel" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ParticleDataEntry_addChannel" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ParticleDataEntry_addChannel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ParticleDataEntry_addChannel" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ParticleDataEntry_addChannel" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ParticleDataEntry_addChannel" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  (arg1)->addChannel(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_addChannel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int arg10 ;
  int arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:ParticleDataEntry_addChannel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_addChannel" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_addChannel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleDataEntry_addChannel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleDataEntry_addChannel" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleDataEntry_addChannel" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleDataEntry_addChannel" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleDataEntry_addChannel" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ParticleDataEntry_addChannel" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ParticleDataEntry_addChannel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ParticleDataEntry_addChannel" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ParticleDataEntry_addChannel" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  (arg1)->addChannel(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_addChannel__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:ParticleDataEntry_addChannel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_addChannel" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_addChannel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleDataEntry_addChannel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleDataEntry_addChannel" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleDataEntry_addChannel" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleDataEntry_addChannel" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleDataEntry_addChannel" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ParticleDataEntry_addChannel" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ParticleDataEntry_addChannel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ParticleDataEntry_addChannel" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  (arg1)->addChannel(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_addChannel__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:ParticleDataEntry_addChannel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_addChannel" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_addChannel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleDataEntry_addChannel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleDataEntry_addChannel" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleDataEntry_addChannel" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleDataEntry_addChannel" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleDataEntry_addChannel" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ParticleDataEntry_addChannel" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ParticleDataEntry_addChannel" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  (arg1)->addChannel(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_addChannel__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:ParticleDataEntry_addChannel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_addChannel" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_addChannel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleDataEntry_addChannel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleDataEntry_addChannel" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleDataEntry_addChannel" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleDataEntry_addChannel" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleDataEntry_addChannel" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ParticleDataEntry_addChannel" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  (arg1)->addChannel(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_addChannel__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:ParticleDataEntry_addChannel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_addChannel" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_addChannel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleDataEntry_addChannel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleDataEntry_addChannel" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleDataEntry_addChannel" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleDataEntry_addChannel" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleDataEntry_addChannel" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  (arg1)->addChannel(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_addChannel__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ParticleDataEntry_addChannel",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_addChannel" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_addChannel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleDataEntry_addChannel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleDataEntry_addChannel" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleDataEntry_addChannel" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleDataEntry_addChannel" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  (arg1)->addChannel(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_addChannel__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ParticleDataEntry_addChannel",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_addChannel" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_addChannel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleDataEntry_addChannel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleDataEntry_addChannel" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleDataEntry_addChannel" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  (arg1)->addChannel(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_addChannel__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ParticleDataEntry_addChannel",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_addChannel" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_addChannel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleDataEntry_addChannel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleDataEntry_addChannel" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->addChannel(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_addChannel__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleDataEntry_addChannel",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_addChannel" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_addChannel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleDataEntry_addChannel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->addChannel(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_addChannel__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_addChannel",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_addChannel" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_addChannel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->addChannel(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_addChannel__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_addChannel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_addChannel" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  (arg1)->addChannel();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_addChannel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[13] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 12) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ParticleDataEntry_addChannel__SWIG_11(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleDataEntry_addChannel__SWIG_10(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleDataEntry_addChannel__SWIG_9(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ParticleDataEntry_addChannel__SWIG_8(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ParticleDataEntry_addChannel__SWIG_7(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_ParticleDataEntry_addChannel__SWIG_6(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_ParticleDataEntry_addChannel__SWIG_5(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_ParticleDataEntry_addChannel__SWIG_4(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_ParticleDataEntry_addChannel__SWIG_3(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_ParticleDataEntry_addChannel__SWIG_2(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_ParticleDataEntry_addChannel__SWIG_1(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_ParticleDataEntry_addChannel__SWIG_0(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleDataEntry_addChannel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleDataEntry::addChannel(int,double,int,int,int,int,int,int,int,int,int)\n"
    "    Pythia8::ParticleDataEntry::addChannel(int,double,int,int,int,int,int,int,int,int)\n"
    "    Pythia8::ParticleDataEntry::addChannel(int,double,int,int,int,int,int,int,int)\n"
    "    Pythia8::ParticleDataEntry::addChannel(int,double,int,int,int,int,int,int)\n"
    "    Pythia8::ParticleDataEntry::addChannel(int,double,int,int,int,int,int)\n"
    "    Pythia8::ParticleDataEntry::addChannel(int,double,int,int,int,int)\n"
    "    Pythia8::ParticleDataEntry::addChannel(int,double,int,int,int)\n"
    "    Pythia8::ParticleDataEntry::addChannel(int,double,int,int)\n"
    "    Pythia8::ParticleDataEntry::addChannel(int,double,int)\n"
    "    Pythia8::ParticleDataEntry::addChannel(int,double)\n"
    "    Pythia8::ParticleDataEntry::addChannel(int)\n"
    "    Pythia8::ParticleDataEntry::addChannel()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_sizeChannels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_sizeChannels",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_sizeChannels" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (int)((Pythia8::ParticleDataEntry const *)arg1)->sizeChannels();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_channel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::DecayChannel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_channel",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_channel" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_channel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::DecayChannel *) &(arg1)->channel(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_channel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::DecayChannel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_channel",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_channel" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_channel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::DecayChannel *) &((Pythia8::ParticleDataEntry const *)arg1)->channel(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_channel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleDataEntry_channel__SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleDataEntry_channel__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleDataEntry_channel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleDataEntry::channel(int)\n"
    "    Pythia8::ParticleDataEntry::channel(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_rescaleBR__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_rescaleBR",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_rescaleBR" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_rescaleBR" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->rescaleBR(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_rescaleBR__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_rescaleBR",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_rescaleBR" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  (arg1)->rescaleBR();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_rescaleBR(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ParticleDataEntry_rescaleBR__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleDataEntry_rescaleBR__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleDataEntry_rescaleBR'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleDataEntry::rescaleBR(double)\n"
    "    Pythia8::ParticleDataEntry::rescaleBR()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_preparePick__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ParticleDataEntry_preparePick",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_preparePick" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_preparePick" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleDataEntry_preparePick" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleDataEntry_preparePick" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (bool)(arg1)->preparePick(arg2,arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_preparePick__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleDataEntry_preparePick",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_preparePick" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_preparePick" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleDataEntry_preparePick" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (bool)(arg1)->preparePick(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_preparePick__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_preparePick",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_preparePick" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_preparePick" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->preparePick(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_preparePick(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleDataEntry_preparePick__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleDataEntry_preparePick__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ParticleDataEntry_preparePick__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleDataEntry_preparePick'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleDataEntry::preparePick(int,double,int)\n"
    "    Pythia8::ParticleDataEntry::preparePick(int,double)\n"
    "    Pythia8::ParticleDataEntry::preparePick(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_pickChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::DecayChannel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_pickChannel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_pickChannel" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (Pythia8::DecayChannel *) &(arg1)->pickChannel();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__DecayChannel, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_setResonancePtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  Pythia8::ResonanceWidths *arg2 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_setResonancePtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_setResonancePtr" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParticleDataEntry_setResonancePtr" "', argument " "2"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp2);
  (arg1)->setResonancePtr(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_getResonancePtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceWidths *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_getResonancePtr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_getResonancePtr" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (Pythia8::ResonanceWidths *)(arg1)->getResonancePtr();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_resInit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = (Pythia8::Settings *) 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Couplings *arg5 = (Pythia8::Couplings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ParticleDataEntry_resInit",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_resInit" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParticleDataEntry_resInit" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParticleDataEntry_resInit" "', argument " "3"" of type '" "Pythia8::Settings *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParticleDataEntry_resInit" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ParticleDataEntry_resInit" "', argument " "5"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Couplings * >(argp5);
  (arg1)->resInit(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_resWidth__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  bool arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ParticleDataEntry_resWidth",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_resWidth" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_resWidth" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleDataEntry_resWidth" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleDataEntry_resWidth" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleDataEntry_resWidth" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleDataEntry_resWidth" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  result = (double)(arg1)->resWidth(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_resWidth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ParticleDataEntry_resWidth",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_resWidth" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_resWidth" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleDataEntry_resWidth" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleDataEntry_resWidth" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleDataEntry_resWidth" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (double)(arg1)->resWidth(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_resWidth__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ParticleDataEntry_resWidth",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_resWidth" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_resWidth" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleDataEntry_resWidth" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleDataEntry_resWidth" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->resWidth(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_resWidth__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleDataEntry_resWidth",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_resWidth" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_resWidth" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleDataEntry_resWidth" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)(arg1)->resWidth(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_resWidth(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleDataEntry_resWidth__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ParticleDataEntry_resWidth__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ParticleDataEntry_resWidth__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_ParticleDataEntry_resWidth__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleDataEntry_resWidth'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleDataEntry::resWidth(int,double,int,bool,bool)\n"
    "    Pythia8::ParticleDataEntry::resWidth(int,double,int,bool)\n"
    "    Pythia8::ParticleDataEntry::resWidth(int,double,int)\n"
    "    Pythia8::ParticleDataEntry::resWidth(int,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_resWidthOpen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ParticleDataEntry_resWidthOpen",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_resWidthOpen" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_resWidthOpen" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleDataEntry_resWidthOpen" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleDataEntry_resWidthOpen" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->resWidthOpen(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_resWidthOpen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleDataEntry_resWidthOpen",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_resWidthOpen" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_resWidthOpen" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleDataEntry_resWidthOpen" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)(arg1)->resWidthOpen(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_resWidthOpen(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleDataEntry_resWidthOpen__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ParticleDataEntry_resWidthOpen__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleDataEntry_resWidthOpen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleDataEntry::resWidthOpen(int,double,int)\n"
    "    Pythia8::ParticleDataEntry::resWidthOpen(int,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_resWidthStore__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ParticleDataEntry_resWidthStore",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_resWidthStore" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_resWidthStore" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleDataEntry_resWidthStore" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleDataEntry_resWidthStore" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->resWidthStore(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_resWidthStore__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleDataEntry_resWidthStore",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_resWidthStore" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_resWidthStore" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleDataEntry_resWidthStore" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)(arg1)->resWidthStore(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_resWidthStore(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleDataEntry_resWidthStore__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ParticleDataEntry_resWidthStore__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleDataEntry_resWidthStore'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleDataEntry::resWidthStore(int,double,int)\n"
    "    Pythia8::ParticleDataEntry::resWidthStore(int,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_resOpenFrac(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_resOpenFrac",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_resOpenFrac" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_resOpenFrac" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->resOpenFrac(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_resWidthRescaleFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDataEntry_resWidthRescaleFactor",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_resWidthRescaleFactor" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  result = (double)(arg1)->resWidthRescaleFactor();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_resWidthChan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  double arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ParticleDataEntry_resWidthChan",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_resWidthChan" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_resWidthChan" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleDataEntry_resWidthChan" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleDataEntry_resWidthChan" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->resWidthChan(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_resWidthChan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  double arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleDataEntry_resWidthChan",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_resWidthChan" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_resWidthChan" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleDataEntry_resWidthChan" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)(arg1)->resWidthChan(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_resWidthChan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDataEntry *arg1 = (Pythia8::ParticleDataEntry *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleDataEntry_resWidthChan",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDataEntry_resWidthChan" "', argument " "1"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDataEntry_resWidthChan" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->resWidthChan(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDataEntry_resWidthChan(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleDataEntry_resWidthChan__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleDataEntry_resWidthChan__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ParticleDataEntry_resWidthChan__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleDataEntry_resWidthChan'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleDataEntry::resWidthChan(double,int,int)\n"
    "    Pythia8::ParticleDataEntry::resWidthChan(double,int)\n"
    "    Pythia8::ParticleDataEntry::resWidthChan(double)\n");
  return 0;
}


SWIGINTERN PyObject *ParticleDataEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ParticleDataEntry, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ParticleData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ParticleData")) SWIG_fail;
  result = (Pythia8::ParticleData *)new Pythia8::ParticleData();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleData, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_initPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = (Pythia8::Settings *) 0 ;
  Pythia8::Rndm *arg4 = (Pythia8::Rndm *) 0 ;
  Pythia8::Couplings *arg5 = (Pythia8::Couplings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ParticleData_initPtr",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_initPtr" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParticleData_initPtr" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParticleData_initPtr" "', argument " "3"" of type '" "Pythia8::Settings *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParticleData_initPtr" "', argument " "4"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Rndm * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ParticleData_initPtr" "', argument " "5"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Couplings * >(argp5);
  (arg1)->initPtr(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_init__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_init",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_init" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_init" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->init(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_init__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleData_init",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_init" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  result = (bool)(arg1)->init();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_init__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  Pythia8::ParticleData *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_init",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_init" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__ParticleData,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParticleData_init" "', argument " "2"" of type '" "Pythia8::ParticleData const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParticleData_init" "', argument " "2"" of type '" "Pythia8::ParticleData const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ParticleData * >(argp2);
  result = (bool)(arg1)->init((Pythia8::ParticleData const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_init__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  std::istream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_init",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_init" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParticleData_init" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParticleData_init" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  result = (bool)(arg1)->init(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_init(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ParticleData_init__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__ParticleData, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ParticleData_init__SWIG_2(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ParticleData_init__SWIG_3(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ParticleData_init__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_init'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::init(std::string)\n"
    "    Pythia8::ParticleData::init()\n"
    "    Pythia8::ParticleData::init(Pythia8::ParticleData const &)\n"
    "    Pythia8::ParticleData::init(std::istream &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_reInit__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_reInit",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_reInit" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_reInit" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_reInit" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->reInit(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_reInit__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_reInit",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_reInit" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_reInit" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->reInit(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_reInit(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ParticleData_reInit__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_reInit__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_reInit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::reInit(std::string,bool)\n"
    "    Pythia8::ParticleData::reInit(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_initWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_initWidths",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_initWidths" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParticleData_initWidths" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParticleData_initWidths" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > >""'");
    } else {
      std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > * temp = reinterpret_cast< std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->initWidths(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_readXML__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_readXML",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_readXML" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_readXML" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_readXML" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->readXML(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_readXML__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_readXML",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_readXML" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_readXML" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->readXML(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_listXML(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_listXML",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_listXML" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_listXML" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->listXML(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_readXML__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  std::istream *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_readXML",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_readXML" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParticleData_readXML" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParticleData_readXML" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_readXML" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->readXML(*arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_readXML__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  std::istream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_readXML",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_readXML" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParticleData_readXML" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParticleData_readXML" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  result = (bool)(arg1)->readXML(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_readXML(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ParticleData_readXML__SWIG_3(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ParticleData_readXML__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_readXML__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_readXML__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_readXML'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::readXML(std::string,bool)\n"
    "    Pythia8::ParticleData::readXML(std::string)\n"
    "    Pythia8::ParticleData::readXML(std::istream &,bool)\n"
    "    Pythia8::ParticleData::readXML(std::istream &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_copyXML(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  Pythia8::ParticleData *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_copyXML",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_copyXML" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__ParticleData,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParticleData_copyXML" "', argument " "2"" of type '" "Pythia8::ParticleData const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParticleData_copyXML" "', argument " "2"" of type '" "Pythia8::ParticleData const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ParticleData * >(argp2);
  result = (bool)(arg1)->copyXML((Pythia8::ParticleData const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_loadXML__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_loadXML",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_loadXML" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_loadXML" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_loadXML" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->loadXML(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_loadXML__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_loadXML",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_loadXML" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_loadXML" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->loadXML(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_loadXML__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  std::istream *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_loadXML",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_loadXML" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParticleData_loadXML" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParticleData_loadXML" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_loadXML" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->loadXML(*arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_loadXML__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  std::istream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_loadXML",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_loadXML" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParticleData_loadXML" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParticleData_loadXML" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  result = (bool)(arg1)->loadXML(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_loadXML(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ParticleData_loadXML__SWIG_3(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ParticleData_loadXML__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_loadXML__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_loadXML__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_loadXML'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::loadXML(std::string,bool)\n"
    "    Pythia8::ParticleData::loadXML(std::string)\n"
    "    Pythia8::ParticleData::loadXML(std::istream &,bool)\n"
    "    Pythia8::ParticleData::loadXML(std::istream &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_processXML__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_processXML",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_processXML" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_processXML" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)(arg1)->processXML(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_processXML__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleData_processXML",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_processXML" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  result = (bool)(arg1)->processXML();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_processXML(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ParticleData_processXML__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleData_processXML__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_processXML'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::processXML(bool)\n"
    "    Pythia8::ParticleData::processXML()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_readFF__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_readFF",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_readFF" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_readFF" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_readFF" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->readFF(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_readFF__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_readFF",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_readFF" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_readFF" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->readFF(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_readFF__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  std::istream *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_readFF",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_readFF" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParticleData_readFF" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParticleData_readFF" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_readFF" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->readFF(*arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_readFF__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  std::istream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_readFF",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_readFF" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParticleData_readFF" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParticleData_readFF" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  result = (bool)(arg1)->readFF(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_readFF(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ParticleData_readFF__SWIG_3(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ParticleData_readFF__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_readFF__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_readFF__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_readFF'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::readFF(std::string,bool)\n"
    "    Pythia8::ParticleData::readFF(std::string)\n"
    "    Pythia8::ParticleData::readFF(std::istream &,bool)\n"
    "    Pythia8::ParticleData::readFF(std::istream &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_listFF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_listFF",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_listFF" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_listFF" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->listFF(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_readString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_readString",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_readString" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_readString" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_readString" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->readString(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_readString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_readString",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_readString" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_readString" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->readString(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_readString(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ParticleData_readString__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_readString__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_readString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::readString(std::string,bool)\n"
    "    Pythia8::ParticleData::readString(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_readingFailed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleData_readingFailed",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_readingFailed" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  result = (bool)(arg1)->readingFailed();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_listAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleData_listAll",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_listAll" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  (arg1)->listAll();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_listChanged__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_listChanged",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_listChanged" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_listChanged" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->listChanged(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_listChanged__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleData_listChanged",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_listChanged" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  (arg1)->listChanged();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_listChanged(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ParticleData_listChanged__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleData_listChanged__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_listChanged'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::listChanged(bool)\n"
    "    Pythia8::ParticleData::listChanged()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_getReadHistory__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_getReadHistory",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_getReadHistory" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_getReadHistory" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (arg1)->getReadHistory(arg2);
  resultobj = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_getReadHistory__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleData_getReadHistory",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_getReadHistory" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  result = (arg1)->getReadHistory();
  resultobj = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_getReadHistory(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ParticleData_getReadHistory__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleData_getReadHistory__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_getReadHistory'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::getReadHistory(int)\n"
    "    Pythia8::ParticleData::getReadHistory()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_checkTable__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_checkTable",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_checkTable" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_checkTable" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->checkTable(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_checkTable__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleData_checkTable",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_checkTable" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  (arg1)->checkTable();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_checkTable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ParticleData_checkTable__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleData_checkTable__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_checkTable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::checkTable(int)\n"
    "    Pythia8::ParticleData::checkTable()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_addParticle__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:ParticleData_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_addParticle" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleData_addParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleData_addParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleData_addParticle" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ParticleData_addParticle" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ParticleData_addParticle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ParticleData_addParticle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ParticleData_addParticle" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  (arg1)->addParticle(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_addParticle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:ParticleData_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_addParticle" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleData_addParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleData_addParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleData_addParticle" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ParticleData_addParticle" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ParticleData_addParticle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ParticleData_addParticle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  (arg1)->addParticle(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_addParticle__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:ParticleData_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_addParticle" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleData_addParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleData_addParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleData_addParticle" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ParticleData_addParticle" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ParticleData_addParticle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  (arg1)->addParticle(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_addParticle__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:ParticleData_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_addParticle" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleData_addParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleData_addParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleData_addParticle" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ParticleData_addParticle" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  (arg1)->addParticle(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_addParticle__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:ParticleData_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_addParticle" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleData_addParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleData_addParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleData_addParticle" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  (arg1)->addParticle(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_addParticle__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ParticleData_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_addParticle" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleData_addParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleData_addParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  (arg1)->addParticle(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_addParticle__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ParticleData_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_addParticle" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleData_addParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  (arg1)->addParticle(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_addParticle__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ParticleData_addParticle",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_addParticle" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleData_addParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->addParticle(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_addParticle__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_addParticle",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_addParticle" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->addParticle(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_addParticle__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_addParticle",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_addParticle" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->addParticle(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_addParticle__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:ParticleData_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_addParticle" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleData_addParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleData_addParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ParticleData_addParticle" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ParticleData_addParticle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ParticleData_addParticle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ParticleData_addParticle" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ParticleData_addParticle" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  (arg1)->addParticle(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_addParticle__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:ParticleData_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_addParticle" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleData_addParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleData_addParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ParticleData_addParticle" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ParticleData_addParticle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ParticleData_addParticle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ParticleData_addParticle" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  (arg1)->addParticle(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_addParticle__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:ParticleData_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_addParticle" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleData_addParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleData_addParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ParticleData_addParticle" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ParticleData_addParticle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ParticleData_addParticle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  (arg1)->addParticle(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_addParticle__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:ParticleData_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_addParticle" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleData_addParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleData_addParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ParticleData_addParticle" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ParticleData_addParticle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  (arg1)->addParticle(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_addParticle__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:ParticleData_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_addParticle" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleData_addParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleData_addParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ParticleData_addParticle" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  (arg1)->addParticle(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_addParticle__SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:ParticleData_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_addParticle" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleData_addParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleData_addParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  (arg1)->addParticle(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_addParticle__SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ParticleData_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_addParticle" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleData_addParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  (arg1)->addParticle(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_addParticle__SWIG_17(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ParticleData_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_addParticle" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  (arg1)->addParticle(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_addParticle__SWIG_18(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ParticleData_addParticle",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_addParticle" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_addParticle" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->addParticle(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_addParticle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[13] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 12) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleData_addParticle__SWIG_9(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ParticleData_addParticle__SWIG_8(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ParticleData_addParticle__SWIG_7(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ParticleData_addParticle__SWIG_18(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ParticleData_addParticle__SWIG_6(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ParticleData_addParticle__SWIG_17(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_ParticleData_addParticle__SWIG_5(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_ParticleData_addParticle__SWIG_16(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_ParticleData_addParticle__SWIG_4(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_ParticleData_addParticle__SWIG_15(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_ParticleData_addParticle__SWIG_3(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_ParticleData_addParticle__SWIG_14(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_ParticleData_addParticle__SWIG_2(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_ParticleData_addParticle__SWIG_13(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_ParticleData_addParticle__SWIG_1(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_ParticleData_addParticle__SWIG_12(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_ParticleData_addParticle__SWIG_0(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_ParticleData_addParticle__SWIG_11(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_ParticleData_addParticle__SWIG_10(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_addParticle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::addParticle(int,std::string,int,int,int,double,double,double,double,double)\n"
    "    Pythia8::ParticleData::addParticle(int,std::string,int,int,int,double,double,double,double)\n"
    "    Pythia8::ParticleData::addParticle(int,std::string,int,int,int,double,double,double)\n"
    "    Pythia8::ParticleData::addParticle(int,std::string,int,int,int,double,double)\n"
    "    Pythia8::ParticleData::addParticle(int,std::string,int,int,int,double)\n"
    "    Pythia8::ParticleData::addParticle(int,std::string,int,int,int)\n"
    "    Pythia8::ParticleData::addParticle(int,std::string,int,int)\n"
    "    Pythia8::ParticleData::addParticle(int,std::string,int)\n"
    "    Pythia8::ParticleData::addParticle(int,std::string)\n"
    "    Pythia8::ParticleData::addParticle(int)\n"
    "    Pythia8::ParticleData::addParticle(int,std::string,std::string,int,int,int,double,double,double,double,double)\n"
    "    Pythia8::ParticleData::addParticle(int,std::string,std::string,int,int,int,double,double,double,double)\n"
    "    Pythia8::ParticleData::addParticle(int,std::string,std::string,int,int,int,double,double,double)\n"
    "    Pythia8::ParticleData::addParticle(int,std::string,std::string,int,int,int,double,double)\n"
    "    Pythia8::ParticleData::addParticle(int,std::string,std::string,int,int,int,double)\n"
    "    Pythia8::ParticleData::addParticle(int,std::string,std::string,int,int,int)\n"
    "    Pythia8::ParticleData::addParticle(int,std::string,std::string,int,int)\n"
    "    Pythia8::ParticleData::addParticle(int,std::string,std::string,int)\n"
    "    Pythia8::ParticleData::addParticle(int,std::string,std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_setAll__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:ParticleData_setAll",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_setAll" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_setAll" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_setAll" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_setAll" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_setAll" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleData_setAll" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleData_setAll" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ParticleData_setAll" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ParticleData_setAll" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ParticleData_setAll" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ParticleData_setAll" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ParticleData_setAll" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  (arg1)->setAll(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_setAll__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:ParticleData_setAll",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_setAll" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_setAll" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_setAll" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_setAll" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_setAll" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleData_setAll" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleData_setAll" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ParticleData_setAll" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ParticleData_setAll" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ParticleData_setAll" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ParticleData_setAll" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  (arg1)->setAll(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_setAll__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:ParticleData_setAll",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_setAll" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_setAll" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_setAll" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_setAll" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_setAll" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleData_setAll" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleData_setAll" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ParticleData_setAll" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ParticleData_setAll" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ParticleData_setAll" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  (arg1)->setAll(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_setAll__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:ParticleData_setAll",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_setAll" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_setAll" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_setAll" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_setAll" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_setAll" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleData_setAll" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleData_setAll" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ParticleData_setAll" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ParticleData_setAll" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  (arg1)->setAll(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_setAll__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:ParticleData_setAll",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_setAll" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_setAll" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_setAll" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_setAll" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_setAll" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleData_setAll" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleData_setAll" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ParticleData_setAll" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  (arg1)->setAll(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_setAll__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:ParticleData_setAll",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_setAll" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_setAll" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_setAll" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_setAll" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_setAll" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleData_setAll" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ParticleData_setAll" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  (arg1)->setAll(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_setAll__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ParticleData_setAll",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_setAll" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_setAll" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_setAll" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_setAll" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_setAll" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleData_setAll" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  (arg1)->setAll(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_setAll__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ParticleData_setAll",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_setAll" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_setAll" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_setAll" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_setAll" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_setAll" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  (arg1)->setAll(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_setAll__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ParticleData_setAll",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_setAll" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_setAll" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_setAll" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_setAll" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->setAll(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_setAll(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[13] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 12) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ParticleData_setAll__SWIG_8(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ParticleData_setAll__SWIG_7(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_ParticleData_setAll__SWIG_6(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_ParticleData_setAll__SWIG_5(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_ParticleData_setAll__SWIG_4(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_ParticleData_setAll__SWIG_3(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_ParticleData_setAll__SWIG_2(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_ParticleData_setAll__SWIG_1(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_ParticleData_setAll__SWIG_0(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_setAll'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::setAll(int,std::string,std::string,int,int,int,double,double,double,double,double)\n"
    "    Pythia8::ParticleData::setAll(int,std::string,std::string,int,int,int,double,double,double,double)\n"
    "    Pythia8::ParticleData::setAll(int,std::string,std::string,int,int,int,double,double,double)\n"
    "    Pythia8::ParticleData::setAll(int,std::string,std::string,int,int,int,double,double)\n"
    "    Pythia8::ParticleData::setAll(int,std::string,std::string,int,int,int,double)\n"
    "    Pythia8::ParticleData::setAll(int,std::string,std::string,int,int,int)\n"
    "    Pythia8::ParticleData::setAll(int,std::string,std::string,int,int)\n"
    "    Pythia8::ParticleData::setAll(int,std::string,std::string,int)\n"
    "    Pythia8::ParticleData::setAll(int,std::string,std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_isParticle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_isParticle",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_isParticle" "', argument " "1"" of type '" "Pythia8::ParticleData const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_isParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)((Pythia8::ParticleData const *)arg1)->isParticle(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_findParticle__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::ParticleDataEntry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_findParticle",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_findParticle" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_findParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::ParticleDataEntry *)(arg1)->findParticle(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_findParticle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::ParticleDataEntry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_findParticle",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_findParticle" "', argument " "1"" of type '" "Pythia8::ParticleData const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_findParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::ParticleDataEntry *)((Pythia8::ParticleData const *)arg1)->findParticle(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_findParticle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleData_findParticle__SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleData_findParticle__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_findParticle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::findParticle(int)\n"
    "    Pythia8::ParticleData::findParticle(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_nextId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_nextId",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_nextId" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_nextId" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->nextId(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_name__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_name",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_name" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_name" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_name" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->name(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_antiName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_antiName",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_antiName" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_antiName" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_antiName" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->antiName(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_names(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ParticleData_names",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_names" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_names" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_names" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleData_names" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->names(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_spinType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_spinType",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_spinType" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_spinType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_spinType" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->spinType(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_chargeType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_chargeType",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_chargeType" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_chargeType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_chargeType" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->chargeType(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_colType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_colType",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_colType" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_colType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_colType" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->colType(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_m0__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_m0",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_m0" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_m0" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_m0" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->m0(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_mWidth__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_mWidth",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_mWidth" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_mWidth" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_mWidth" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->mWidth(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_mMin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_mMin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_mMin" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_mMin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_mMin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->mMin(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_mMax__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_mMax",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_mMax" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_mMax" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_mMax" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->mMax(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_tau0__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_tau0",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_tau0" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_tau0" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_tau0" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->tau0(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_isResonance__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_isResonance",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_isResonance" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_isResonance" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_isResonance" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->isResonance(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_mayDecay__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_mayDecay",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_mayDecay" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_mayDecay" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_mayDecay" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->mayDecay(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_doExternalDecay__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_doExternalDecay",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_doExternalDecay" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_doExternalDecay" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_doExternalDecay" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->doExternalDecay(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_isVisible__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_isVisible",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_isVisible" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_isVisible" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_isVisible" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->isVisible(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_doForceWidth__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_doForceWidth",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_doForceWidth" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_doForceWidth" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_doForceWidth" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->doForceWidth(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_hasChanged__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_hasChanged",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_hasChanged" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_hasChanged" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_hasChanged" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->hasChanged(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_hasAnti(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_hasAnti",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_hasAnti" "', argument " "1"" of type '" "Pythia8::ParticleData const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_hasAnti" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)((Pythia8::ParticleData const *)arg1)->hasAnti(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_name__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_name",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_name" "', argument " "1"" of type '" "Pythia8::ParticleData const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_name" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((Pythia8::ParticleData const *)arg1)->name(arg2);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_name(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleData_name__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ParticleData_name__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_name'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::name(int,std::string)\n"
    "    Pythia8::ParticleData::name(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_spinType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_spinType",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_spinType" "', argument " "1"" of type '" "Pythia8::ParticleData const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_spinType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::ParticleData const *)arg1)->spinType(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_spinType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleData_spinType__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_spinType__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_spinType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::spinType(int,int)\n"
    "    Pythia8::ParticleData::spinType(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_chargeType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_chargeType",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_chargeType" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_chargeType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->chargeType(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_chargeType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleData_chargeType__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_chargeType__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_chargeType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::chargeType(int,int)\n"
    "    Pythia8::ParticleData::chargeType(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_charge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_charge",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_charge" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_charge" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->charge(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_colType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_colType",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_colType" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_colType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->colType(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_colType(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleData_colType__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_colType__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_colType'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::colType(int,int)\n"
    "    Pythia8::ParticleData::colType(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_m0__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_m0",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_m0" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_m0" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->m0(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_m0(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleData_m0__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_m0__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_m0'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::m0(int,double)\n"
    "    Pythia8::ParticleData::m0(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_mWidth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_mWidth",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_mWidth" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_mWidth" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->mWidth(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_mWidth(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleData_mWidth__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_mWidth__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_mWidth'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::mWidth(int,double)\n"
    "    Pythia8::ParticleData::mWidth(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_mMin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_mMin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_mMin" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_mMin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->mMin(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_mMin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleData_mMin__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_mMin__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_mMin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::mMin(int,double)\n"
    "    Pythia8::ParticleData::mMin(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_m0Min(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_m0Min",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_m0Min" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_m0Min" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->m0Min(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_mMax__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_mMax",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_mMax" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_mMax" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->mMax(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_mMax(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleData_mMax__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_mMax__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_mMax'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::mMax(int,double)\n"
    "    Pythia8::ParticleData::mMax(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_m0Max(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_m0Max",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_m0Max" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_m0Max" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->m0Max(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_tau0__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_tau0",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_tau0" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_tau0" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->tau0(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_tau0(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleData_tau0__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_tau0__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_tau0'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::tau0(int,double)\n"
    "    Pythia8::ParticleData::tau0(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_isResonance__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_isResonance",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_isResonance" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_isResonance" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->isResonance(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_isResonance(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleData_isResonance__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_isResonance__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_isResonance'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::isResonance(int,bool)\n"
    "    Pythia8::ParticleData::isResonance(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_mayDecay__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_mayDecay",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_mayDecay" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_mayDecay" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->mayDecay(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_mayDecay(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleData_mayDecay__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_mayDecay__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_mayDecay'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::mayDecay(int,bool)\n"
    "    Pythia8::ParticleData::mayDecay(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_doExternalDecay__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_doExternalDecay",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_doExternalDecay" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_doExternalDecay" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->doExternalDecay(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_doExternalDecay(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleData_doExternalDecay__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_doExternalDecay__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_doExternalDecay'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::doExternalDecay(int,bool)\n"
    "    Pythia8::ParticleData::doExternalDecay(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_isVisible__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_isVisible",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_isVisible" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_isVisible" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->isVisible(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_isVisible(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleData_isVisible__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_isVisible__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_isVisible'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::isVisible(int,bool)\n"
    "    Pythia8::ParticleData::isVisible(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_doForceWidth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_doForceWidth",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_doForceWidth" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_doForceWidth" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->doForceWidth(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_doForceWidth(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleData_doForceWidth__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_doForceWidth__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_doForceWidth'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::doForceWidth(int,bool)\n"
    "    Pythia8::ParticleData::doForceWidth(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_hasChanged__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_hasChanged",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_hasChanged" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_hasChanged" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->hasChanged(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_hasChanged(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleData_hasChanged__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_hasChanged__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_hasChanged'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::hasChanged(int,bool)\n"
    "    Pythia8::ParticleData::hasChanged(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_hasChangedMMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_hasChangedMMin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_hasChangedMMin" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_hasChangedMMin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->hasChangedMMin(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_hasChangedMMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_hasChangedMMax",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_hasChangedMMax" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_hasChangedMMax" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->hasChangedMMax(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_useBreitWigner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_useBreitWigner",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_useBreitWigner" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_useBreitWigner" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->useBreitWigner(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_constituentMass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_constituentMass",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_constituentMass" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_constituentMass" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->constituentMass(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_mSel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_mSel",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_mSel" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_mSel" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->mSel(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_mRun(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_mRun",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_mRun" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_mRun" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_mRun" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)(arg1)->mRun(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_canDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_canDecay",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_canDecay" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_canDecay" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->canDecay(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_isLepton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_isLepton",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_isLepton" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_isLepton" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->isLepton(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_isQuark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_isQuark",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_isQuark" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_isQuark" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->isQuark(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_isGluon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_isGluon",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_isGluon" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_isGluon" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->isGluon(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_isDiquark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_isDiquark",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_isDiquark" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_isDiquark" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->isDiquark(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_isParton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_isParton",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_isParton" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_isParton" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->isParton(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_isHadron(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_isHadron",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_isHadron" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_isHadron" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->isHadron(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_isMeson(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_isMeson",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_isMeson" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_isMeson" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->isMeson(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_isBaryon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_isBaryon",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_isBaryon" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_isBaryon" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->isBaryon(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_isOctetHadron(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_isOctetHadron",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_isOctetHadron" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_isOctetHadron" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->isOctetHadron(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_heaviestQuark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_heaviestQuark",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_heaviestQuark" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_heaviestQuark" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->heaviestQuark(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_baryonNumberType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_baryonNumberType",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_baryonNumberType" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_baryonNumberType" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->baryonNumberType(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_nQuarksInCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_nQuarksInCode",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_nQuarksInCode" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_nQuarksInCode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_nQuarksInCode" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->nQuarksInCode(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_rescaleBR__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_rescaleBR",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_rescaleBR" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_rescaleBR" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_rescaleBR" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->rescaleBR(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_rescaleBR__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_rescaleBR",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_rescaleBR" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_rescaleBR" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->rescaleBR(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_rescaleBR(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleData_rescaleBR__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_rescaleBR__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_rescaleBR'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::rescaleBR(int,double)\n"
    "    Pythia8::ParticleData::rescaleBR(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_setResonancePtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  Pythia8::ResonanceWidths *arg3 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_setResonancePtr",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_setResonancePtr" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_setResonancePtr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParticleData_setResonancePtr" "', argument " "3"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp3);
  (arg1)->setResonancePtr(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_resInit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_resInit",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_resInit" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_resInit" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->resInit(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_resWidth__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  bool arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ParticleData_resWidth",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_resWidth" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_resWidth" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_resWidth" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleData_resWidth" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_resWidth" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ParticleData_resWidth" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  result = (double)(arg1)->resWidth(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_resWidth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ParticleData_resWidth",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_resWidth" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_resWidth" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_resWidth" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleData_resWidth" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_resWidth" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (double)(arg1)->resWidth(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_resWidth__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ParticleData_resWidth",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_resWidth" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_resWidth" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_resWidth" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleData_resWidth" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->resWidth(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_resWidth__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_resWidth",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_resWidth" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_resWidth" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_resWidth" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)(arg1)->resWidth(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_resWidth(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_resWidth__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ParticleData_resWidth__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ParticleData_resWidth__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_ParticleData_resWidth__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_resWidth'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::resWidth(int,double,int,bool,bool)\n"
    "    Pythia8::ParticleData::resWidth(int,double,int,bool)\n"
    "    Pythia8::ParticleData::resWidth(int,double,int)\n"
    "    Pythia8::ParticleData::resWidth(int,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_resWidthOpen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ParticleData_resWidthOpen",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_resWidthOpen" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_resWidthOpen" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_resWidthOpen" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleData_resWidthOpen" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->resWidthOpen(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_resWidthOpen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_resWidthOpen",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_resWidthOpen" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_resWidthOpen" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_resWidthOpen" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)(arg1)->resWidthOpen(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_resWidthOpen(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_resWidthOpen__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ParticleData_resWidthOpen__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_resWidthOpen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::resWidthOpen(int,double,int)\n"
    "    Pythia8::ParticleData::resWidthOpen(int,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_resWidthStore__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ParticleData_resWidthStore",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_resWidthStore" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_resWidthStore" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_resWidthStore" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleData_resWidthStore" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->resWidthStore(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_resWidthStore__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_resWidthStore",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_resWidthStore" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_resWidthStore" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_resWidthStore" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)(arg1)->resWidthStore(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_resWidthStore(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_resWidthStore__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ParticleData_resWidthStore__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_resWidthStore'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::resWidthStore(int,double,int)\n"
    "    Pythia8::ParticleData::resWidthStore(int,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_resOpenFrac__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ParticleData_resOpenFrac",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_resOpenFrac" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_resOpenFrac" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_resOpenFrac" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleData_resOpenFrac" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->resOpenFrac(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_resOpenFrac__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_resOpenFrac",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_resOpenFrac" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_resOpenFrac" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_resOpenFrac" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)(arg1)->resOpenFrac(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_resOpenFrac__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_resOpenFrac",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_resOpenFrac" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_resOpenFrac" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->resOpenFrac(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_resOpenFrac(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleData_resOpenFrac__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_resOpenFrac__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ParticleData_resOpenFrac__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_resOpenFrac'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::resOpenFrac(int,int,int)\n"
    "    Pythia8::ParticleData::resOpenFrac(int,int)\n"
    "    Pythia8::ParticleData::resOpenFrac(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_resWidthRescaleFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_resWidthRescaleFactor",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_resWidthRescaleFactor" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_resWidthRescaleFactor" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->resWidthRescaleFactor(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_resWidthChan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ParticleData_resWidthChan",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_resWidthChan" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_resWidthChan" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_resWidthChan" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleData_resWidthChan" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParticleData_resWidthChan" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (double)(arg1)->resWidthChan(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_resWidthChan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ParticleData_resWidthChan",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_resWidthChan" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_resWidthChan" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_resWidthChan" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParticleData_resWidthChan" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->resWidthChan(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_resWidthChan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleData_resWidthChan",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_resWidthChan" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_resWidthChan" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParticleData_resWidthChan" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)(arg1)->resWidthChan(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_resWidthChan(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleData_resWidthChan__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ParticleData_resWidthChan__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ParticleData_resWidthChan__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ParticleData_resWidthChan'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ParticleData::resWidthChan(int,double,int,int)\n"
    "    Pythia8::ParticleData::resWidthChan(int,double,int)\n"
    "    Pythia8::ParticleData::resWidthChan(int,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ParticleData_particleDataEntryPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::ParticleDataEntry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ParticleData_particleDataEntryPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_particleDataEntryPtr" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleData_particleDataEntryPtr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::ParticleDataEntry *)(arg1)->particleDataEntryPtr(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData_getIsInit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleData_getIsInit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData_getIsInit" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  result = (bool)(arg1)->getIsInit();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleData___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleData___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleData___str__" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  result = Pythia8_ParticleData___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ParticleData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleData *arg1 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ParticleData",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ParticleData" "', argument " "1"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleData * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ParticleData_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ParticleData, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PDF__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::PDF *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_PDF",&obj0,&obj1)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PDF" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (Pythia8::PDF *)new SwigDirector_PDF(arg1,arg2); 
  } else {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
    SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PDF, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PDF__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::PDF *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PDF",&obj0)) SWIG_fail;
  arg1 = obj0;
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (Pythia8::PDF *)new SwigDirector_PDF(arg1); 
  } else {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
    SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PDF, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PDF(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    _v = (argv[0] != 0);
    if (_v) {
      return _wrap_new_PDF__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    _v = (argv[0] != 0);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_PDF__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PDF'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PDF::PDF(int)\n"
    "    Pythia8::PDF::PDF(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PDF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PDF",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PDF" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_isSetup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_isSetup",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_isSetup" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::PDF::isSetup();
    } else {
      result = (bool)(arg1)->isSetup();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_newValenceContent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PDF_newValenceContent",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_newValenceContent" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_newValenceContent" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PDF_newValenceContent" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::PDF::newValenceContent(arg2,arg3);
    } else {
      (arg1)->newValenceContent(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_setExtrapolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_setExtrapolate",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_setExtrapolate" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_setExtrapolate" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::PDF::setExtrapolate(arg2);
    } else {
      (arg1)->setExtrapolate(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:PDF_xf",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xf" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PDF_xf" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PDF_xf" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::PDF::xf(arg2,arg3,arg4);
    } else {
      result = (double)(arg1)->xf(arg2,arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xfVal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:PDF_xfVal",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xfVal" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xfVal" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PDF_xfVal" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PDF_xfVal" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::PDF::xfVal(arg2,arg3,arg4);
    } else {
      result = (double)(arg1)->xfVal(arg2,arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xfSea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:PDF_xfSea",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xfSea" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xfSea" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PDF_xfSea" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PDF_xfSea" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::PDF::xfSea(arg2,arg3,arg4);
    } else {
      result = (double)(arg1)->xfSea(arg2,arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_insideBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PDF_insideBounds",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_insideBounds" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_insideBounds" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PDF_insideBounds" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::PDF::insideBounds(arg2,arg3);
    } else {
      result = (bool)(arg1)->insideBounds(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_alphaS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_alphaS",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_alphaS" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_alphaS" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::PDF::alphaS(arg2);
    } else {
      result = (double)(arg1)->alphaS(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_mQuarkPDF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_mQuarkPDF",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_mQuarkPDF" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_mQuarkPDF" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::PDF::mQuarkPDF(arg2);
    } else {
      result = (double)(arg1)->mQuarkPDF(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_nMembers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_nMembers",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_nMembers" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Pythia8::PDF::nMembers();
    } else {
      result = (int)(arg1)->nMembers();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_calcPDFEnvelope__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:PDF_calcPDFEnvelope",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_calcPDFEnvelope" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_calcPDFEnvelope" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PDF_calcPDFEnvelope" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PDF_calcPDFEnvelope" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PDF_calcPDFEnvelope" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::PDF::calcPDFEnvelope(arg2,arg3,arg4,arg5);
    } else {
      (arg1)->calcPDFEnvelope(arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_calcPDFEnvelope__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  std::pair< int,int > arg2 ;
  SwigValueWrapper< std::pair< double,double > > arg3 ;
  double arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:PDF_calcPDFEnvelope",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_calcPDFEnvelope" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  {
    std::pair< int,int > *ptr = (std::pair< int,int > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PDF_calcPDFEnvelope" "', argument " "2"" of type '" "std::pair< int,int >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__pairT_double_double_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PDF_calcPDFEnvelope" "', argument " "3"" of type '" "std::pair< double,double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PDF_calcPDFEnvelope" "', argument " "3"" of type '" "std::pair< double,double >""'");
    } else {
      std::pair< double,double > * temp = reinterpret_cast< std::pair< double,double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PDF_calcPDFEnvelope" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PDF_calcPDFEnvelope" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::PDF::calcPDFEnvelope(arg2,arg3,arg4,arg5);
    } else {
      (arg1)->calcPDFEnvelope(arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_calcPDFEnvelope(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_PDF_calcPDFEnvelope__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::pair< int,int >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__pairT_double_double_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_PDF_calcPDFEnvelope__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PDF_calcPDFEnvelope'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PDF::calcPDFEnvelope(int,double,double,int)\n"
    "    Pythia8::PDF::calcPDFEnvelope(std::pair< int,int >,std::pair< double,double >,double,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PDF_getPDFEnvelope(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Pythia8::PDF::PDFEnvelope result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_getPDFEnvelope",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_getPDFEnvelope" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (arg1)->Pythia8::PDF::getPDFEnvelope();
    } else {
      result = (arg1)->getPDFEnvelope();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj((new Pythia8::PDF::PDFEnvelope(static_cast< const Pythia8::PDF::PDFEnvelope& >(result))), SWIGTYPE_p_Pythia8__PDF__PDFEnvelope, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_gammaPDFxDependence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PDF_gammaPDFxDependence",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_gammaPDFxDependence" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_gammaPDFxDependence" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PDF_gammaPDFxDependence" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::PDF::gammaPDFxDependence(arg2,arg3);
    } else {
      result = (double)(arg1)->gammaPDFxDependence(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_gammaPDFRefScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_gammaPDFRefScale",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_gammaPDFRefScale" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_gammaPDFRefScale" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::PDF::gammaPDFRefScale(arg2);
    } else {
      result = (double)(arg1)->gammaPDFRefScale(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_sampleGammaValFlavor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_sampleGammaValFlavor",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_sampleGammaValFlavor" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_sampleGammaValFlavor" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Pythia8::PDF::sampleGammaValFlavor(arg2);
    } else {
      result = (int)(arg1)->sampleGammaValFlavor(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xfIntegratedTotal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_xfIntegratedTotal",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xfIntegratedTotal" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xfIntegratedTotal" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::PDF::xfIntegratedTotal(arg2);
    } else {
      result = (double)(arg1)->xfIntegratedTotal(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xGamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_xGamma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xGamma" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::PDF::xGamma();
    } else {
      result = (double)(arg1)->xGamma();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xPom__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_xPom",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xPom" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xPom" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::PDF::xPom(arg2);
    } else {
      (arg1)->xPom(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xPom__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_xPom",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xPom" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::PDF::xPom();
    } else {
      (arg1)->xPom();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xPom(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_PDF_xPom__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PDF_xPom__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PDF_xPom'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PDF::xPom(double)\n"
    "    Pythia8::PDF::xPom()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PDF_xfFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:PDF_xfFlux",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xfFlux" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xfFlux" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PDF_xfFlux" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PDF_xfFlux" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::PDF::xfFlux(arg2,arg3,arg4);
    } else {
      result = (double)(arg1)->xfFlux(arg2,arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xfApprox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:PDF_xfApprox",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xfApprox" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xfApprox" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PDF_xfApprox" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PDF_xfApprox" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::PDF::xfApprox(arg2,arg3,arg4);
    } else {
      result = (double)(arg1)->xfApprox(arg2,arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xfGamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:PDF_xfGamma",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xfGamma" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xfGamma" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PDF_xfGamma" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PDF_xfGamma" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::PDF::xfGamma(arg2,arg3,arg4);
    } else {
      result = (double)(arg1)->xfGamma(arg2,arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_getQ2min(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_getQ2min",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_getQ2min" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::PDF::getQ2min();
    } else {
      result = (double)(arg1)->getQ2min();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_getXmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_getXmin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_getXmin" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::PDF::getXmin();
    } else {
      result = (double)(arg1)->getXmin();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_getXhadr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_getXhadr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_getXhadr" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::PDF::getXhadr();
    } else {
      result = (double)(arg1)->getXhadr();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_getGammaFluxNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_getGammaFluxNorm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_getGammaFluxNorm" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::PDF::getGammaFluxNorm();
    } else {
      result = (double)(arg1)->getGammaFluxNorm();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_sampleXgamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_sampleXgamma",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_sampleXgamma" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_sampleXgamma" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::PDF::sampleXgamma(arg2);
    } else {
      result = (double)(arg1)->sampleXgamma(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_sampleQ2gamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_sampleQ2gamma",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_sampleQ2gamma" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_sampleQ2gamma" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::PDF::sampleQ2gamma(arg2);
    } else {
      result = (double)(arg1)->sampleQ2gamma(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xfMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:PDF_xfMax",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xfMax" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xfMax" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PDF_xfMax" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PDF_xfMax" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::PDF::xfMax(arg2,arg3,arg4);
    } else {
      result = (double)(arg1)->xfMax(arg2,arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xfSame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:PDF_xfSame",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xfSame" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xfSame" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PDF_xfSame" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PDF_xfSame" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::PDF::xfSame(arg2,arg3,arg4);
    } else {
      result = (double)(arg1)->xfSame(arg2,arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_setVMDscale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_setVMDscale",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_setVMDscale" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_setVMDscale" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::PDF::setVMDscale(arg2);
    } else {
      (arg1)->setVMDscale(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_setVMDscale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_setVMDscale",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_setVMDscale" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::PDF::setVMDscale();
    } else {
      (arg1)->setVMDscale();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_setVMDscale(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_PDF_setVMDscale__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PDF_setVMDscale__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PDF_setVMDscale'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PDF::setVMDscale(double)\n"
    "    Pythia8::PDF::setVMDscale()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PDF_idBeam_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_idBeam_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_idBeam_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_idBeam_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->idBeam = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_idBeam_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_idBeam_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_idBeam_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (int) (darg->idBeam);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_idBeamAbs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_idBeamAbs_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_idBeamAbs_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_idBeamAbs_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->idBeamAbs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_idBeamAbs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_idBeamAbs_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_idBeamAbs_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (int) (darg->idBeamAbs);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_idSav_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_idSav_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_idSav_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_idSav_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->idSav = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_idSav_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_idSav_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_idSav_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (int) (darg->idSav);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_idVal1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_idVal1_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_idVal1_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_idVal1_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->idVal1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_idVal1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_idVal1_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_idVal1_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (int) (darg->idVal1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_idVal2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_idVal2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_idVal2_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_idVal2_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->idVal2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_idVal2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_idVal2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_idVal2_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (int) (darg->idVal2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xSav_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_xSav_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xSav_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xSav_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->xSav = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xSav_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_xSav_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xSav_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (double) (darg->xSav);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_Q2Sav_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_Q2Sav_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_Q2Sav_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_Q2Sav_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->Q2Sav = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_Q2Sav_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_Q2Sav_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_Q2Sav_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (double) (darg->Q2Sav);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xu_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_xu_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xu_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xu_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->xu = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xu_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_xu_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xu_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (double) (darg->xu);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_xd_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xd_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xd_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->xd = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_xd_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xd_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (double) (darg->xd);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_xs_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xs_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xs_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->xs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_xs_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xs_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (double) (darg->xs);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xubar_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_xubar_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xubar_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xubar_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->xubar = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xubar_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_xubar_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xubar_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (double) (darg->xubar);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xdbar_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_xdbar_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xdbar_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xdbar_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->xdbar = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xdbar_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_xdbar_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xdbar_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (double) (darg->xdbar);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xsbar_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_xsbar_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xsbar_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xsbar_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->xsbar = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xsbar_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_xsbar_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xsbar_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (double) (darg->xsbar);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_xc_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xc_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xc_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->xc = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_xc_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xc_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (double) (darg->xc);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xb_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_xb_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xb_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xb_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->xb = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xb_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_xb_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xb_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (double) (darg->xb);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_xg_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xg_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xg_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->xg = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_xg_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xg_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (double) (darg->xg);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xlepton_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_xlepton_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xlepton_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xlepton_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->xlepton = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xlepton_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_xlepton_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xlepton_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (double) (darg->xlepton);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xgamma_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_xgamma_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xgamma_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xgamma_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->xgamma = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xgamma_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_xgamma_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xgamma_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (double) (darg->xgamma);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xuVal_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_xuVal_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xuVal_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xuVal_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->xuVal = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xuVal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_xuVal_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xuVal_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (double) (darg->xuVal);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xuSea_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_xuSea_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xuSea_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xuSea_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->xuSea = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xuSea_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_xuSea_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xuSea_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (double) (darg->xuSea);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xdVal_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_xdVal_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xdVal_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xdVal_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->xdVal = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xdVal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_xdVal_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xdVal_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (double) (darg->xdVal);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xdSea_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_xdSea_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xdSea_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xdSea_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->xdSea = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xdSea_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_xdSea_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xdSea_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (double) (darg->xdSea);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_isSet_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_isSet_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_isSet_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_isSet_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->isSet = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_isSet_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_isSet_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_isSet_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (bool) (darg->isSet);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_isInit_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_isInit_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_isInit_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_isInit_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->isInit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_isInit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_isInit_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_isInit_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (bool) (darg->isInit);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xsVal_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_xsVal_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xsVal_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xsVal_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->xsVal = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xsVal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_xsVal_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xsVal_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (double) (darg->xsVal);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xcVal_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_xcVal_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xcVal_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xcVal_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->xcVal = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xcVal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_xcVal_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xcVal_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (double) (darg->xcVal);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xbVal_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_xbVal_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xbVal_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xbVal_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->xbVal = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xbVal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_xbVal_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xbVal_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (double) (darg->xbVal);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xsSea_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_xsSea_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xsSea_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xsSea_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->xsSea = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xsSea_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_xsSea_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xsSea_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (double) (darg->xsSea);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xcSea_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_xcSea_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xcSea_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xcSea_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->xcSea = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xcSea_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_xcSea_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xcSea_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (double) (darg->xcSea);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xbSea_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_xbSea_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xbSea_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xbSea_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->xbSea = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xbSea_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_xbSea_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xbSea_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (double) (darg->xbSea);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_hasGammaInLepton_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_hasGammaInLepton_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_hasGammaInLepton_set" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_hasGammaInLepton_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  if (arg1) darg->hasGammaInLepton = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_hasGammaInLepton_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_hasGammaInLepton_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_hasGammaInLepton_get" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  result = (bool) (darg->hasGammaInLepton);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_setValenceContent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PDF_setValenceContent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_setValenceContent" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  (darg)->setValenceContent();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_xfUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:PDF_xfUpdate",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_xfUpdate" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PDF_xfUpdate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PDF_xfUpdate" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PDF_xfUpdate" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("xfUpdate"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member xfUpdate");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_PDF *>(arg1);
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("Pythia8::PDF::xfUpdate");
    } else {
      (darg)->xfUpdate(arg2,arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_printErr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  std::string arg2 ;
  Pythia8::Info *arg3 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PDF_printErr",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_printErr" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PDF_printErr" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PDF_printErr" "', argument " "3"" of type '" "Pythia8::Info *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Info * >(argp3);
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  (darg)->printErr(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_printErr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PDF *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PDF_printErr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PDF_printErr" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PDF_printErr" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  darg = dynamic_cast<SwigDirector_PDF *>(arg1);
  (darg)->printErr(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PDF_printErr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PDF_printErr__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_PDF_printErr__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PDF_printErr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PDF::printErr(std::string,Pythia8::Info *)\n"
    "    Pythia8::PDF::printErr(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_disown_PDF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PDF *arg1 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:disown_PDF",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_PDF" "', argument " "1"" of type '" "Pythia8::PDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PDF * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PDF_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__PDF, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_GRV94L__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::GRV94L *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_GRV94L",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GRV94L" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::GRV94L *)new Pythia8::GRV94L(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__GRV94L, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GRV94L__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GRV94L *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_GRV94L")) SWIG_fail;
  result = (Pythia8::GRV94L *)new Pythia8::GRV94L();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__GRV94L, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GRV94L(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_GRV94L__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_GRV94L__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GRV94L'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::GRV94L::GRV94L(int)\n"
    "    Pythia8::GRV94L::GRV94L()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GRV94L(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GRV94L *arg1 = (Pythia8::GRV94L *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_GRV94L",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GRV94L, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GRV94L" "', argument " "1"" of type '" "Pythia8::GRV94L *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GRV94L * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GRV94L_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__GRV94L, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CTEQ5L__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::CTEQ5L *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CTEQ5L",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CTEQ5L" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::CTEQ5L *)new Pythia8::CTEQ5L(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CTEQ5L, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CTEQ5L__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CTEQ5L *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CTEQ5L")) SWIG_fail;
  result = (Pythia8::CTEQ5L *)new Pythia8::CTEQ5L();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CTEQ5L, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CTEQ5L(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_CTEQ5L__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_CTEQ5L__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CTEQ5L'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::CTEQ5L::CTEQ5L(int)\n"
    "    Pythia8::CTEQ5L::CTEQ5L()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_CTEQ5L(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CTEQ5L *arg1 = (Pythia8::CTEQ5L *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CTEQ5L",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CTEQ5L, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CTEQ5L" "', argument " "1"" of type '" "Pythia8::CTEQ5L *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CTEQ5L * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CTEQ5L_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__CTEQ5L, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MSTWpdf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  std::string arg3 ;
  Pythia8::Info *arg4 = (Pythia8::Info *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::MSTWpdf *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_MSTWpdf",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MSTWpdf" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MSTWpdf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MSTWpdf" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_MSTWpdf" "', argument " "4"" of type '" "Pythia8::Info *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Info * >(argp4);
  result = (Pythia8::MSTWpdf *)new Pythia8::MSTWpdf(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MSTWpdf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MSTWpdf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  std::string arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::MSTWpdf *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_MSTWpdf",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MSTWpdf" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MSTWpdf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MSTWpdf" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::MSTWpdf *)new Pythia8::MSTWpdf(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MSTWpdf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MSTWpdf__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::MSTWpdf *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_MSTWpdf",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MSTWpdf" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MSTWpdf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::MSTWpdf *)new Pythia8::MSTWpdf(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MSTWpdf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MSTWpdf__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::MSTWpdf *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MSTWpdf",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MSTWpdf" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::MSTWpdf *)new Pythia8::MSTWpdf(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MSTWpdf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MSTWpdf__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MSTWpdf *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MSTWpdf")) SWIG_fail;
  result = (Pythia8::MSTWpdf *)new Pythia8::MSTWpdf();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MSTWpdf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MSTWpdf__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::istream *arg2 = 0 ;
  Pythia8::Info *arg3 = (Pythia8::Info *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::MSTWpdf *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_MSTWpdf",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MSTWpdf" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MSTWpdf" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MSTWpdf" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MSTWpdf" "', argument " "3"" of type '" "Pythia8::Info *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Info * >(argp3);
  result = (Pythia8::MSTWpdf *)new Pythia8::MSTWpdf(arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MSTWpdf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MSTWpdf__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::istream *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::MSTWpdf *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_MSTWpdf",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MSTWpdf" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MSTWpdf" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MSTWpdf" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  result = (Pythia8::MSTWpdf *)new Pythia8::MSTWpdf(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MSTWpdf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MSTWpdf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_MSTWpdf__SWIG_4(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_MSTWpdf__SWIG_3(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_MSTWpdf__SWIG_6(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_MSTWpdf__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_MSTWpdf__SWIG_5(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_MSTWpdf__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_MSTWpdf__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MSTWpdf'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::MSTWpdf::MSTWpdf(int,int,std::string,Pythia8::Info *)\n"
    "    Pythia8::MSTWpdf::MSTWpdf(int,int,std::string)\n"
    "    Pythia8::MSTWpdf::MSTWpdf(int,int)\n"
    "    Pythia8::MSTWpdf::MSTWpdf(int)\n"
    "    Pythia8::MSTWpdf::MSTWpdf()\n"
    "    Pythia8::MSTWpdf::MSTWpdf(int,std::istream &,Pythia8::Info *)\n"
    "    Pythia8::MSTWpdf::MSTWpdf(int,std::istream &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MSTWpdf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MSTWpdf *arg1 = (Pythia8::MSTWpdf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MSTWpdf",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MSTWpdf, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MSTWpdf" "', argument " "1"" of type '" "Pythia8::MSTWpdf *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MSTWpdf * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MSTWpdf_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__MSTWpdf, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CTEQ6pdf__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  Pythia8::Info *arg5 = (Pythia8::Info *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::CTEQ6pdf *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_CTEQ6pdf",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CTEQ6pdf" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CTEQ6pdf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CTEQ6pdf" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_CTEQ6pdf" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_CTEQ6pdf" "', argument " "5"" of type '" "Pythia8::Info *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Info * >(argp5);
  result = (Pythia8::CTEQ6pdf *)new Pythia8::CTEQ6pdf(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CTEQ6pdf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CTEQ6pdf__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::CTEQ6pdf *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_CTEQ6pdf",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CTEQ6pdf" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CTEQ6pdf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CTEQ6pdf" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_CTEQ6pdf" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::CTEQ6pdf *)new Pythia8::CTEQ6pdf(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CTEQ6pdf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CTEQ6pdf__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::CTEQ6pdf *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_CTEQ6pdf",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CTEQ6pdf" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CTEQ6pdf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CTEQ6pdf" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (Pythia8::CTEQ6pdf *)new Pythia8::CTEQ6pdf(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CTEQ6pdf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CTEQ6pdf__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::CTEQ6pdf *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_CTEQ6pdf",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CTEQ6pdf" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CTEQ6pdf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::CTEQ6pdf *)new Pythia8::CTEQ6pdf(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CTEQ6pdf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CTEQ6pdf__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::CTEQ6pdf *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CTEQ6pdf",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CTEQ6pdf" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::CTEQ6pdf *)new Pythia8::CTEQ6pdf(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CTEQ6pdf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CTEQ6pdf__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CTEQ6pdf *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CTEQ6pdf")) SWIG_fail;
  result = (Pythia8::CTEQ6pdf *)new Pythia8::CTEQ6pdf();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CTEQ6pdf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CTEQ6pdf__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::istream *arg2 = 0 ;
  bool arg3 ;
  Pythia8::Info *arg4 = (Pythia8::Info *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::CTEQ6pdf *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_CTEQ6pdf",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CTEQ6pdf" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CTEQ6pdf" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CTEQ6pdf" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CTEQ6pdf" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_CTEQ6pdf" "', argument " "4"" of type '" "Pythia8::Info *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Info * >(argp4);
  result = (Pythia8::CTEQ6pdf *)new Pythia8::CTEQ6pdf(arg1,*arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CTEQ6pdf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CTEQ6pdf__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::istream *arg2 = 0 ;
  bool arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::CTEQ6pdf *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_CTEQ6pdf",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CTEQ6pdf" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CTEQ6pdf" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CTEQ6pdf" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CTEQ6pdf" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (Pythia8::CTEQ6pdf *)new Pythia8::CTEQ6pdf(arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CTEQ6pdf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CTEQ6pdf__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::istream *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::CTEQ6pdf *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_CTEQ6pdf",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CTEQ6pdf" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CTEQ6pdf" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CTEQ6pdf" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  result = (Pythia8::CTEQ6pdf *)new Pythia8::CTEQ6pdf(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CTEQ6pdf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CTEQ6pdf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_CTEQ6pdf__SWIG_5(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_CTEQ6pdf__SWIG_4(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_CTEQ6pdf__SWIG_8(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_CTEQ6pdf__SWIG_3(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_CTEQ6pdf__SWIG_7(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_CTEQ6pdf__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_CTEQ6pdf__SWIG_6(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_CTEQ6pdf__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_CTEQ6pdf__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CTEQ6pdf'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::CTEQ6pdf::CTEQ6pdf(int,int,double,std::string,Pythia8::Info *)\n"
    "    Pythia8::CTEQ6pdf::CTEQ6pdf(int,int,double,std::string)\n"
    "    Pythia8::CTEQ6pdf::CTEQ6pdf(int,int,double)\n"
    "    Pythia8::CTEQ6pdf::CTEQ6pdf(int,int)\n"
    "    Pythia8::CTEQ6pdf::CTEQ6pdf(int)\n"
    "    Pythia8::CTEQ6pdf::CTEQ6pdf()\n"
    "    Pythia8::CTEQ6pdf::CTEQ6pdf(int,std::istream &,bool,Pythia8::Info *)\n"
    "    Pythia8::CTEQ6pdf::CTEQ6pdf(int,std::istream &,bool)\n"
    "    Pythia8::CTEQ6pdf::CTEQ6pdf(int,std::istream &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CTEQ6pdf_setExtrapolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CTEQ6pdf *arg1 = (Pythia8::CTEQ6pdf *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CTEQ6pdf_setExtrapolate",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CTEQ6pdf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CTEQ6pdf_setExtrapolate" "', argument " "1"" of type '" "Pythia8::CTEQ6pdf *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CTEQ6pdf * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CTEQ6pdf_setExtrapolate" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setExtrapolate(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CTEQ6pdf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CTEQ6pdf *arg1 = (Pythia8::CTEQ6pdf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CTEQ6pdf",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CTEQ6pdf, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CTEQ6pdf" "', argument " "1"" of type '" "Pythia8::CTEQ6pdf *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CTEQ6pdf * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CTEQ6pdf_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__CTEQ6pdf, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ProtonPoint__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::ProtonPoint *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_ProtonPoint",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProtonPoint" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ProtonPoint" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  result = (Pythia8::ProtonPoint *)new Pythia8::ProtonPoint(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ProtonPoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProtonPoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ProtonPoint *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ProtonPoint",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProtonPoint" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ProtonPoint *)new Pythia8::ProtonPoint(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ProtonPoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProtonPoint__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProtonPoint *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ProtonPoint")) SWIG_fail;
  result = (Pythia8::ProtonPoint *)new Pythia8::ProtonPoint();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ProtonPoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProtonPoint(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_ProtonPoint__SWIG_2(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ProtonPoint__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_ProtonPoint__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ProtonPoint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ProtonPoint::ProtonPoint(int,Pythia8::Info *)\n"
    "    Pythia8::ProtonPoint::ProtonPoint(int)\n"
    "    Pythia8::ProtonPoint::ProtonPoint()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ProtonPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProtonPoint *arg1 = (Pythia8::ProtonPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ProtonPoint",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProtonPoint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ProtonPoint" "', argument " "1"" of type '" "Pythia8::ProtonPoint *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProtonPoint * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ProtonPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ProtonPoint, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_GRVpiL__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::GRVpiL *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_GRVpiL",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GRVpiL" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GRVpiL" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (Pythia8::GRVpiL *)new Pythia8::GRVpiL(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__GRVpiL, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GRVpiL__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::GRVpiL *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_GRVpiL",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GRVpiL" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::GRVpiL *)new Pythia8::GRVpiL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__GRVpiL, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GRVpiL__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GRVpiL *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_GRVpiL")) SWIG_fail;
  result = (Pythia8::GRVpiL *)new Pythia8::GRVpiL();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__GRVpiL, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GRVpiL(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_GRVpiL__SWIG_2(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_GRVpiL__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_GRVpiL__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GRVpiL'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::GRVpiL::GRVpiL(int,double)\n"
    "    Pythia8::GRVpiL::GRVpiL(int)\n"
    "    Pythia8::GRVpiL::GRVpiL()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GRVpiL_setVMDscale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GRVpiL *arg1 = (Pythia8::GRVpiL *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GRVpiL_setVMDscale",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GRVpiL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GRVpiL_setVMDscale" "', argument " "1"" of type '" "Pythia8::GRVpiL *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GRVpiL * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GRVpiL_setVMDscale" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setVMDscale(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GRVpiL_setVMDscale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GRVpiL *arg1 = (Pythia8::GRVpiL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GRVpiL_setVMDscale",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GRVpiL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GRVpiL_setVMDscale" "', argument " "1"" of type '" "Pythia8::GRVpiL *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GRVpiL * >(argp1);
  (arg1)->setVMDscale();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GRVpiL_setVMDscale(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__GRVpiL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_GRVpiL_setVMDscale__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__GRVpiL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_GRVpiL_setVMDscale__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GRVpiL_setVMDscale'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::GRVpiL::setVMDscale(double)\n"
    "    Pythia8::GRVpiL::setVMDscale()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GRVpiL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GRVpiL *arg1 = (Pythia8::GRVpiL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_GRVpiL",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GRVpiL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GRVpiL" "', argument " "1"" of type '" "Pythia8::GRVpiL *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GRVpiL * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GRVpiL_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__GRVpiL, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PomFix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Pythia8::PomFix *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_PomFix",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PomFix" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PomFix" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_PomFix" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_PomFix" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_PomFix" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PomFix" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_PomFix" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (Pythia8::PomFix *)new Pythia8::PomFix(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomFix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomFix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::PomFix *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_PomFix",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PomFix" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PomFix" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_PomFix" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_PomFix" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_PomFix" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_PomFix" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (Pythia8::PomFix *)new Pythia8::PomFix(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomFix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomFix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::PomFix *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_PomFix",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PomFix" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PomFix" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_PomFix" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_PomFix" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_PomFix" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (Pythia8::PomFix *)new Pythia8::PomFix(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomFix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomFix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::PomFix *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_PomFix",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PomFix" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PomFix" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_PomFix" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_PomFix" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (Pythia8::PomFix *)new Pythia8::PomFix(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomFix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomFix__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::PomFix *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_PomFix",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PomFix" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PomFix" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_PomFix" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (Pythia8::PomFix *)new Pythia8::PomFix(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomFix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomFix__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::PomFix *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_PomFix",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PomFix" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PomFix" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (Pythia8::PomFix *)new Pythia8::PomFix(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomFix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomFix__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::PomFix *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PomFix",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PomFix" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::PomFix *)new Pythia8::PomFix(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomFix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomFix__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PomFix *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PomFix")) SWIG_fail;
  result = (Pythia8::PomFix *)new Pythia8::PomFix();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomFix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomFix(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_PomFix__SWIG_7(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_PomFix__SWIG_6(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_PomFix__SWIG_5(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_PomFix__SWIG_4(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_PomFix__SWIG_3(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_PomFix__SWIG_2(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_PomFix__SWIG_1(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_PomFix__SWIG_0(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PomFix'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PomFix::PomFix(int,double,double,double,double,double,double)\n"
    "    Pythia8::PomFix::PomFix(int,double,double,double,double,double)\n"
    "    Pythia8::PomFix::PomFix(int,double,double,double,double)\n"
    "    Pythia8::PomFix::PomFix(int,double,double,double)\n"
    "    Pythia8::PomFix::PomFix(int,double,double)\n"
    "    Pythia8::PomFix::PomFix(int,double)\n"
    "    Pythia8::PomFix::PomFix(int)\n"
    "    Pythia8::PomFix::PomFix()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PomFix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PomFix *arg1 = (Pythia8::PomFix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PomFix",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PomFix, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PomFix" "', argument " "1"" of type '" "Pythia8::PomFix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PomFix * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PomFix_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__PomFix, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PomH1FitAB__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  Pythia8::Info *arg5 = (Pythia8::Info *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::PomH1FitAB *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_PomH1FitAB",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PomH1FitAB" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PomH1FitAB" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_PomH1FitAB" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PomH1FitAB" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PomH1FitAB" "', argument " "5"" of type '" "Pythia8::Info *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Info * >(argp5);
  result = (Pythia8::PomH1FitAB *)new Pythia8::PomH1FitAB(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomH1FitAB, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomH1FitAB__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::PomH1FitAB *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_PomH1FitAB",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PomH1FitAB" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PomH1FitAB" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_PomH1FitAB" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PomH1FitAB" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::PomH1FitAB *)new Pythia8::PomH1FitAB(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomH1FitAB, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomH1FitAB__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::PomH1FitAB *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_PomH1FitAB",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PomH1FitAB" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PomH1FitAB" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_PomH1FitAB" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (Pythia8::PomH1FitAB *)new Pythia8::PomH1FitAB(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomH1FitAB, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomH1FitAB__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::PomH1FitAB *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_PomH1FitAB",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PomH1FitAB" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PomH1FitAB" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::PomH1FitAB *)new Pythia8::PomH1FitAB(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomH1FitAB, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomH1FitAB__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::PomH1FitAB *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PomH1FitAB",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PomH1FitAB" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::PomH1FitAB *)new Pythia8::PomH1FitAB(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomH1FitAB, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomH1FitAB__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PomH1FitAB *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PomH1FitAB")) SWIG_fail;
  result = (Pythia8::PomH1FitAB *)new Pythia8::PomH1FitAB();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomH1FitAB, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomH1FitAB__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  std::istream *arg3 = 0 ;
  Pythia8::Info *arg4 = (Pythia8::Info *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::PomH1FitAB *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_PomH1FitAB",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PomH1FitAB" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PomH1FitAB" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PomH1FitAB" "', argument " "3"" of type '" "std::istream &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PomH1FitAB" "', argument " "3"" of type '" "std::istream &""'"); 
  }
  arg3 = reinterpret_cast< std::istream * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PomH1FitAB" "', argument " "4"" of type '" "Pythia8::Info *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Info * >(argp4);
  result = (Pythia8::PomH1FitAB *)new Pythia8::PomH1FitAB(arg1,arg2,*arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomH1FitAB, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomH1FitAB__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  std::istream *arg3 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::PomH1FitAB *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_PomH1FitAB",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PomH1FitAB" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PomH1FitAB" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PomH1FitAB" "', argument " "3"" of type '" "std::istream &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PomH1FitAB" "', argument " "3"" of type '" "std::istream &""'"); 
  }
  arg3 = reinterpret_cast< std::istream * >(argp3);
  result = (Pythia8::PomH1FitAB *)new Pythia8::PomH1FitAB(arg1,arg2,*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomH1FitAB, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomH1FitAB(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_PomH1FitAB__SWIG_5(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_PomH1FitAB__SWIG_4(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_PomH1FitAB__SWIG_3(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_PomH1FitAB__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_PomH1FitAB__SWIG_7(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PomH1FitAB__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PomH1FitAB__SWIG_6(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PomH1FitAB__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PomH1FitAB'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PomH1FitAB::PomH1FitAB(int,int,double,std::string,Pythia8::Info *)\n"
    "    Pythia8::PomH1FitAB::PomH1FitAB(int,int,double,std::string)\n"
    "    Pythia8::PomH1FitAB::PomH1FitAB(int,int,double)\n"
    "    Pythia8::PomH1FitAB::PomH1FitAB(int,int)\n"
    "    Pythia8::PomH1FitAB::PomH1FitAB(int)\n"
    "    Pythia8::PomH1FitAB::PomH1FitAB()\n"
    "    Pythia8::PomH1FitAB::PomH1FitAB(int,double,std::istream &,Pythia8::Info *)\n"
    "    Pythia8::PomH1FitAB::PomH1FitAB(int,double,std::istream &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PomH1FitAB_setExtrapolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PomH1FitAB *arg1 = (Pythia8::PomH1FitAB *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PomH1FitAB_setExtrapolate",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PomH1FitAB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PomH1FitAB_setExtrapolate" "', argument " "1"" of type '" "Pythia8::PomH1FitAB *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PomH1FitAB * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PomH1FitAB_setExtrapolate" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setExtrapolate(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PomH1FitAB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PomH1FitAB *arg1 = (Pythia8::PomH1FitAB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PomH1FitAB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PomH1FitAB, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PomH1FitAB" "', argument " "1"" of type '" "Pythia8::PomH1FitAB *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PomH1FitAB * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PomH1FitAB_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__PomH1FitAB, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PomH1Jets__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  Pythia8::Info *arg5 = (Pythia8::Info *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::PomH1Jets *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_PomH1Jets",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PomH1Jets" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PomH1Jets" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_PomH1Jets" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PomH1Jets" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_PomH1Jets" "', argument " "5"" of type '" "Pythia8::Info *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Info * >(argp5);
  result = (Pythia8::PomH1Jets *)new Pythia8::PomH1Jets(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomH1Jets, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomH1Jets__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  std::string arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::PomH1Jets *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_PomH1Jets",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PomH1Jets" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PomH1Jets" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_PomH1Jets" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PomH1Jets" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::PomH1Jets *)new Pythia8::PomH1Jets(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomH1Jets, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomH1Jets__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::PomH1Jets *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_PomH1Jets",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PomH1Jets" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PomH1Jets" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_PomH1Jets" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (Pythia8::PomH1Jets *)new Pythia8::PomH1Jets(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomH1Jets, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomH1Jets__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::PomH1Jets *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_PomH1Jets",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PomH1Jets" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PomH1Jets" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::PomH1Jets *)new Pythia8::PomH1Jets(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomH1Jets, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomH1Jets__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::PomH1Jets *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PomH1Jets",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PomH1Jets" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::PomH1Jets *)new Pythia8::PomH1Jets(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomH1Jets, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomH1Jets__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PomH1Jets *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PomH1Jets")) SWIG_fail;
  result = (Pythia8::PomH1Jets *)new Pythia8::PomH1Jets();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomH1Jets, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomH1Jets__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  std::istream *arg3 = 0 ;
  Pythia8::Info *arg4 = (Pythia8::Info *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::PomH1Jets *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_PomH1Jets",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PomH1Jets" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PomH1Jets" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PomH1Jets" "', argument " "3"" of type '" "std::istream &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PomH1Jets" "', argument " "3"" of type '" "std::istream &""'"); 
  }
  arg3 = reinterpret_cast< std::istream * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PomH1Jets" "', argument " "4"" of type '" "Pythia8::Info *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Info * >(argp4);
  result = (Pythia8::PomH1Jets *)new Pythia8::PomH1Jets(arg1,arg2,*arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomH1Jets, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomH1Jets__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  std::istream *arg3 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::PomH1Jets *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_PomH1Jets",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PomH1Jets" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PomH1Jets" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PomH1Jets" "', argument " "3"" of type '" "std::istream &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PomH1Jets" "', argument " "3"" of type '" "std::istream &""'"); 
  }
  arg3 = reinterpret_cast< std::istream * >(argp3);
  result = (Pythia8::PomH1Jets *)new Pythia8::PomH1Jets(arg1,arg2,*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomH1Jets, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomH1Jets(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_PomH1Jets__SWIG_5(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_PomH1Jets__SWIG_4(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_PomH1Jets__SWIG_3(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_PomH1Jets__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_PomH1Jets__SWIG_7(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PomH1Jets__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PomH1Jets__SWIG_6(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PomH1Jets__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PomH1Jets'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PomH1Jets::PomH1Jets(int,int,double,std::string,Pythia8::Info *)\n"
    "    Pythia8::PomH1Jets::PomH1Jets(int,int,double,std::string)\n"
    "    Pythia8::PomH1Jets::PomH1Jets(int,int,double)\n"
    "    Pythia8::PomH1Jets::PomH1Jets(int,int)\n"
    "    Pythia8::PomH1Jets::PomH1Jets(int)\n"
    "    Pythia8::PomH1Jets::PomH1Jets()\n"
    "    Pythia8::PomH1Jets::PomH1Jets(int,double,std::istream &,Pythia8::Info *)\n"
    "    Pythia8::PomH1Jets::PomH1Jets(int,double,std::istream &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PomH1Jets_setExtrapolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PomH1Jets *arg1 = (Pythia8::PomH1Jets *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PomH1Jets_setExtrapolate",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PomH1Jets, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PomH1Jets_setExtrapolate" "', argument " "1"" of type '" "Pythia8::PomH1Jets *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PomH1Jets * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PomH1Jets_setExtrapolate" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setExtrapolate(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PomH1Jets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PomH1Jets *arg1 = (Pythia8::PomH1Jets *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PomH1Jets",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PomH1Jets, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PomH1Jets" "', argument " "1"" of type '" "Pythia8::PomH1Jets *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PomH1Jets * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PomH1Jets_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__PomH1Jets, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PomHISASD__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Pythia8::PDF *arg2 = (Pythia8::PDF *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::Info *arg4 = (Pythia8::Info *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::PomHISASD *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_PomHISASD",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PomHISASD" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PomHISASD" "', argument " "2"" of type '" "Pythia8::PDF *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PDF * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PomHISASD" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PomHISASD" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PomHISASD" "', argument " "4"" of type '" "Pythia8::Info *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Info * >(argp4);
  result = (Pythia8::PomHISASD *)new Pythia8::PomHISASD(arg1,arg2,*arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomHISASD, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomHISASD__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Pythia8::PDF *arg2 = (Pythia8::PDF *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::PomHISASD *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_PomHISASD",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PomHISASD" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PomHISASD" "', argument " "2"" of type '" "Pythia8::PDF *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PDF * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PomHISASD" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PomHISASD" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  result = (Pythia8::PomHISASD *)new Pythia8::PomHISASD(arg1,arg2,*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PomHISASD, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PomHISASD(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_PomHISASD__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PomHISASD__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PomHISASD'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PomHISASD::PomHISASD(int,Pythia8::PDF *,Pythia8::Settings &,Pythia8::Info *)\n"
    "    Pythia8::PomHISASD::PomHISASD(int,Pythia8::PDF *,Pythia8::Settings &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PomHISASD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PomHISASD *arg1 = (Pythia8::PomHISASD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PomHISASD",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PomHISASD, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PomHISASD" "', argument " "1"" of type '" "Pythia8::PomHISASD *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PomHISASD * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PomHISASD_xPom__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PomHISASD *arg1 = (Pythia8::PomHISASD *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PomHISASD_xPom",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PomHISASD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PomHISASD_xPom" "', argument " "1"" of type '" "Pythia8::PomHISASD *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PomHISASD * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PomHISASD_xPom" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->xPom(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PomHISASD_xPom__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PomHISASD *arg1 = (Pythia8::PomHISASD *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PomHISASD_xPom",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PomHISASD, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PomHISASD_xPom" "', argument " "1"" of type '" "Pythia8::PomHISASD *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PomHISASD * >(argp1);
  (arg1)->xPom();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PomHISASD_xPom(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PomHISASD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_PomHISASD_xPom__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PomHISASD, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PomHISASD_xPom__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PomHISASD_xPom'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PomHISASD::xPom(double)\n"
    "    Pythia8::PomHISASD::xPom()\n");
  return 0;
}


SWIGINTERN PyObject *PomHISASD_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__PomHISASD, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Lepton__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Lepton *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Lepton",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Lepton" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Lepton *)new Pythia8::Lepton(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Lepton, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Lepton__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Lepton *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Lepton")) SWIG_fail;
  result = (Pythia8::Lepton *)new Pythia8::Lepton();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Lepton, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Lepton__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  Pythia8::Info *arg3 = (Pythia8::Info *) 0 ;
  Pythia8::Rndm *arg4 = (Pythia8::Rndm *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::Lepton *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Lepton",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Lepton" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Lepton" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Lepton" "', argument " "3"" of type '" "Pythia8::Info *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Info * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Lepton" "', argument " "4"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Rndm * >(argp4);
  result = (Pythia8::Lepton *)new Pythia8::Lepton(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Lepton, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Lepton__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  Pythia8::Info *arg3 = (Pythia8::Info *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Lepton *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Lepton",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Lepton" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Lepton" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Lepton" "', argument " "3"" of type '" "Pythia8::Info *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Info * >(argp3);
  result = (Pythia8::Lepton *)new Pythia8::Lepton(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Lepton, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Lepton(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Lepton__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Lepton__SWIG_0(self, args);
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_Lepton__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__Rndm, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_Lepton__SWIG_2(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Lepton'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Lepton::Lepton(int)\n"
    "    Pythia8::Lepton::Lepton()\n"
    "    Pythia8::Lepton::Lepton(int,double,Pythia8::Info *,Pythia8::Rndm *)\n"
    "    Pythia8::Lepton::Lepton(int,double,Pythia8::Info *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Lepton_sampleQ2gamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Lepton *arg1 = (Pythia8::Lepton *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Lepton_sampleQ2gamma",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Lepton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Lepton_sampleQ2gamma" "', argument " "1"" of type '" "Pythia8::Lepton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Lepton * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Lepton_sampleQ2gamma" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->sampleQ2gamma(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Lepton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Lepton *arg1 = (Pythia8::Lepton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Lepton",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Lepton, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Lepton" "', argument " "1"" of type '" "Pythia8::Lepton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Lepton * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Lepton_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Lepton, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LeptonPoint__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LeptonPoint *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LeptonPoint",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LeptonPoint" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::LeptonPoint *)new Pythia8::LeptonPoint(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LeptonPoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LeptonPoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LeptonPoint *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LeptonPoint")) SWIG_fail;
  result = (Pythia8::LeptonPoint *)new Pythia8::LeptonPoint();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LeptonPoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LeptonPoint(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_LeptonPoint__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_LeptonPoint__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LeptonPoint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LeptonPoint::LeptonPoint(int)\n"
    "    Pythia8::LeptonPoint::LeptonPoint()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LeptonPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LeptonPoint *arg1 = (Pythia8::LeptonPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LeptonPoint",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LeptonPoint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LeptonPoint" "', argument " "1"" of type '" "Pythia8::LeptonPoint *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LeptonPoint * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LeptonPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__LeptonPoint, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NeutrinoPoint__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::NeutrinoPoint *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NeutrinoPoint",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NeutrinoPoint" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::NeutrinoPoint *)new Pythia8::NeutrinoPoint(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__NeutrinoPoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NeutrinoPoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::NeutrinoPoint *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NeutrinoPoint")) SWIG_fail;
  result = (Pythia8::NeutrinoPoint *)new Pythia8::NeutrinoPoint();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__NeutrinoPoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NeutrinoPoint(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_NeutrinoPoint__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_NeutrinoPoint__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NeutrinoPoint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::NeutrinoPoint::NeutrinoPoint(int)\n"
    "    Pythia8::NeutrinoPoint::NeutrinoPoint()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NeutrinoPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::NeutrinoPoint *arg1 = (Pythia8::NeutrinoPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NeutrinoPoint",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__NeutrinoPoint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NeutrinoPoint" "', argument " "1"" of type '" "Pythia8::NeutrinoPoint *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::NeutrinoPoint * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NeutrinoPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__NeutrinoPoint, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NNPDF__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  std::string arg3 ;
  Pythia8::Info *arg4 = (Pythia8::Info *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::NNPDF *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_NNPDF",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NNPDF" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NNPDF" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_NNPDF" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_NNPDF" "', argument " "4"" of type '" "Pythia8::Info *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Info * >(argp4);
  result = (Pythia8::NNPDF *)new Pythia8::NNPDF(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__NNPDF, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NNPDF__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  std::string arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::NNPDF *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_NNPDF",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NNPDF" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NNPDF" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_NNPDF" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::NNPDF *)new Pythia8::NNPDF(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__NNPDF, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NNPDF__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::NNPDF *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_NNPDF",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NNPDF" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NNPDF" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::NNPDF *)new Pythia8::NNPDF(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__NNPDF, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NNPDF__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::NNPDF *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_NNPDF",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NNPDF" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::NNPDF *)new Pythia8::NNPDF(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__NNPDF, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NNPDF__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::NNPDF *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NNPDF")) SWIG_fail;
  result = (Pythia8::NNPDF *)new Pythia8::NNPDF();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__NNPDF, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NNPDF__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::istream *arg2 = 0 ;
  Pythia8::Info *arg3 = (Pythia8::Info *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::NNPDF *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_NNPDF",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NNPDF" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NNPDF" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NNPDF" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NNPDF" "', argument " "3"" of type '" "Pythia8::Info *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Info * >(argp3);
  result = (Pythia8::NNPDF *)new Pythia8::NNPDF(arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__NNPDF, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NNPDF__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::istream *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::NNPDF *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_NNPDF",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NNPDF" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NNPDF" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NNPDF" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  result = (Pythia8::NNPDF *)new Pythia8::NNPDF(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__NNPDF, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_NNPDF(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_NNPDF__SWIG_4(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_NNPDF__SWIG_3(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_NNPDF__SWIG_6(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_NNPDF__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_NNPDF__SWIG_5(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_NNPDF__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_NNPDF__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NNPDF'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::NNPDF::NNPDF(int,int,std::string,Pythia8::Info *)\n"
    "    Pythia8::NNPDF::NNPDF(int,int,std::string)\n"
    "    Pythia8::NNPDF::NNPDF(int,int)\n"
    "    Pythia8::NNPDF::NNPDF(int)\n"
    "    Pythia8::NNPDF::NNPDF()\n"
    "    Pythia8::NNPDF::NNPDF(int,std::istream &,Pythia8::Info *)\n"
    "    Pythia8::NNPDF::NNPDF(int,std::istream &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_NNPDF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::NNPDF *arg1 = (Pythia8::NNPDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NNPDF",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__NNPDF, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NNPDF" "', argument " "1"" of type '" "Pythia8::NNPDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::NNPDF * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NNPDF_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__NNPDF, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LHAPDF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  Pythia8::Info *arg3 = (Pythia8::Info *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::LHAPDF *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_LHAPDF",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LHAPDF" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_LHAPDF" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LHAPDF" "', argument " "3"" of type '" "Pythia8::Info *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Info * >(argp3);
  result = (Pythia8::LHAPDF *)new Pythia8::LHAPDF(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAPDF, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LHAPDF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAPDF *arg1 = (Pythia8::LHAPDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LHAPDF",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAPDF, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LHAPDF" "', argument " "1"" of type '" "Pythia8::LHAPDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAPDF * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAPDF_isSetup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAPDF *arg1 = (Pythia8::LHAPDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAPDF_isSetup",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAPDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAPDF_isSetup" "', argument " "1"" of type '" "Pythia8::LHAPDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAPDF * >(argp1);
  result = (bool)(arg1)->isSetup();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAPDF_newValenceContent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAPDF *arg1 = (Pythia8::LHAPDF *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:LHAPDF_newValenceContent",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAPDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAPDF_newValenceContent" "', argument " "1"" of type '" "Pythia8::LHAPDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAPDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAPDF_newValenceContent" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAPDF_newValenceContent" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->newValenceContent(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAPDF_setExtrapolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAPDF *arg1 = (Pythia8::LHAPDF *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAPDF_setExtrapolate",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAPDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAPDF_setExtrapolate" "', argument " "1"" of type '" "Pythia8::LHAPDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAPDF * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAPDF_setExtrapolate" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setExtrapolate(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAPDF_xf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAPDF *arg1 = (Pythia8::LHAPDF *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:LHAPDF_xf",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAPDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAPDF_xf" "', argument " "1"" of type '" "Pythia8::LHAPDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAPDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAPDF_xf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAPDF_xf" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAPDF_xf" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->xf(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAPDF_xfVal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAPDF *arg1 = (Pythia8::LHAPDF *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:LHAPDF_xfVal",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAPDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAPDF_xfVal" "', argument " "1"" of type '" "Pythia8::LHAPDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAPDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAPDF_xfVal" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAPDF_xfVal" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAPDF_xfVal" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->xfVal(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAPDF_xfSea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAPDF *arg1 = (Pythia8::LHAPDF *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:LHAPDF_xfSea",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAPDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAPDF_xfSea" "', argument " "1"" of type '" "Pythia8::LHAPDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAPDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAPDF_xfSea" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAPDF_xfSea" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAPDF_xfSea" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->xfSea(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAPDF_insideBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAPDF *arg1 = (Pythia8::LHAPDF *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:LHAPDF_insideBounds",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAPDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAPDF_insideBounds" "', argument " "1"" of type '" "Pythia8::LHAPDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAPDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAPDF_insideBounds" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAPDF_insideBounds" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (bool)(arg1)->insideBounds(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAPDF_alphaS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAPDF *arg1 = (Pythia8::LHAPDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAPDF_alphaS",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAPDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAPDF_alphaS" "', argument " "1"" of type '" "Pythia8::LHAPDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAPDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAPDF_alphaS" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->alphaS(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAPDF_mQuarkPDF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAPDF *arg1 = (Pythia8::LHAPDF *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAPDF_mQuarkPDF",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAPDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAPDF_mQuarkPDF" "', argument " "1"" of type '" "Pythia8::LHAPDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAPDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAPDF_mQuarkPDF" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->mQuarkPDF(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAPDF_nMembers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAPDF *arg1 = (Pythia8::LHAPDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAPDF_nMembers",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAPDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAPDF_nMembers" "', argument " "1"" of type '" "Pythia8::LHAPDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAPDF * >(argp1);
  result = (int)(arg1)->nMembers();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAPDF_calcPDFEnvelope__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAPDF *arg1 = (Pythia8::LHAPDF *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:LHAPDF_calcPDFEnvelope",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAPDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAPDF_calcPDFEnvelope" "', argument " "1"" of type '" "Pythia8::LHAPDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAPDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAPDF_calcPDFEnvelope" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAPDF_calcPDFEnvelope" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAPDF_calcPDFEnvelope" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "LHAPDF_calcPDFEnvelope" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  (arg1)->calcPDFEnvelope(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAPDF_calcPDFEnvelope__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAPDF *arg1 = (Pythia8::LHAPDF *) 0 ;
  std::pair< int,int > arg2 ;
  SwigValueWrapper< std::pair< double,double > > arg3 ;
  double arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:LHAPDF_calcPDFEnvelope",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAPDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAPDF_calcPDFEnvelope" "', argument " "1"" of type '" "Pythia8::LHAPDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAPDF * >(argp1);
  {
    std::pair< int,int > *ptr = (std::pair< int,int > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LHAPDF_calcPDFEnvelope" "', argument " "2"" of type '" "std::pair< int,int >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__pairT_double_double_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LHAPDF_calcPDFEnvelope" "', argument " "3"" of type '" "std::pair< double,double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LHAPDF_calcPDFEnvelope" "', argument " "3"" of type '" "std::pair< double,double >""'");
    } else {
      std::pair< double,double > * temp = reinterpret_cast< std::pair< double,double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAPDF_calcPDFEnvelope" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "LHAPDF_calcPDFEnvelope" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  (arg1)->calcPDFEnvelope(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAPDF_calcPDFEnvelope(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAPDF, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_LHAPDF_calcPDFEnvelope__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAPDF, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::pair< int,int >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__pairT_double_double_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_LHAPDF_calcPDFEnvelope__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LHAPDF_calcPDFEnvelope'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAPDF::calcPDFEnvelope(int,double,double,int)\n"
    "    Pythia8::LHAPDF::calcPDFEnvelope(std::pair< int,int >,std::pair< double,double >,double,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAPDF_getPDFEnvelope(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAPDF *arg1 = (Pythia8::LHAPDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::PDF::PDFEnvelope result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAPDF_getPDFEnvelope",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAPDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAPDF_getPDFEnvelope" "', argument " "1"" of type '" "Pythia8::LHAPDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAPDF * >(argp1);
  result = (arg1)->getPDFEnvelope();
  resultobj = SWIG_NewPointerObj((new Pythia8::PDF::PDFEnvelope(static_cast< const Pythia8::PDF::PDFEnvelope& >(result))), SWIGTYPE_p_Pythia8__PDF__PDFEnvelope, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LHAPDF_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__LHAPDF, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CJKL__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Pythia8::Rndm *arg2 = (Pythia8::Rndm *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::CJKL *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_CJKL",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CJKL" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CJKL" "', argument " "2"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Rndm * >(argp2);
  result = (Pythia8::CJKL *)new Pythia8::CJKL(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CJKL, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CJKL__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::CJKL *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CJKL",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CJKL" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::CJKL *)new Pythia8::CJKL(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CJKL, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CJKL__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CJKL *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CJKL")) SWIG_fail;
  result = (Pythia8::CJKL *)new Pythia8::CJKL();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CJKL, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CJKL(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_CJKL__SWIG_2(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_CJKL__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Rndm, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_CJKL__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CJKL'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::CJKL::CJKL(int,Pythia8::Rndm *)\n"
    "    Pythia8::CJKL::CJKL(int)\n"
    "    Pythia8::CJKL::CJKL()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CJKL_gammaPDFxDependence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CJKL *arg1 = (Pythia8::CJKL *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:CJKL_gammaPDFxDependence",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CJKL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CJKL_gammaPDFxDependence" "', argument " "1"" of type '" "Pythia8::CJKL *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CJKL * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CJKL_gammaPDFxDependence" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CJKL_gammaPDFxDependence" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)(arg1)->gammaPDFxDependence(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CJKL_gammaPDFRefScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CJKL *arg1 = (Pythia8::CJKL *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CJKL_gammaPDFRefScale",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CJKL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CJKL_gammaPDFRefScale" "', argument " "1"" of type '" "Pythia8::CJKL *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CJKL * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CJKL_gammaPDFRefScale" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->gammaPDFRefScale(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CJKL_sampleGammaValFlavor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CJKL *arg1 = (Pythia8::CJKL *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CJKL_sampleGammaValFlavor",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CJKL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CJKL_sampleGammaValFlavor" "', argument " "1"" of type '" "Pythia8::CJKL *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CJKL * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CJKL_sampleGammaValFlavor" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (int)(arg1)->sampleGammaValFlavor(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CJKL_xfIntegratedTotal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CJKL *arg1 = (Pythia8::CJKL *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CJKL_xfIntegratedTotal",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CJKL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CJKL_xfIntegratedTotal" "', argument " "1"" of type '" "Pythia8::CJKL *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CJKL * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CJKL_xfIntegratedTotal" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->xfIntegratedTotal(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CJKL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CJKL *arg1 = (Pythia8::CJKL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CJKL",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CJKL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CJKL" "', argument " "1"" of type '" "Pythia8::CJKL *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CJKL * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CJKL_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__CJKL, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LHAGrid1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  std::string arg3 ;
  Pythia8::Info *arg4 = (Pythia8::Info *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::LHAGrid1 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_LHAGrid1",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LHAGrid1" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_LHAGrid1" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_LHAGrid1" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LHAGrid1" "', argument " "4"" of type '" "Pythia8::Info *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Info * >(argp4);
  result = (Pythia8::LHAGrid1 *)new Pythia8::LHAGrid1(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAGrid1, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAGrid1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  std::string arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::LHAGrid1 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_LHAGrid1",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LHAGrid1" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_LHAGrid1" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_LHAGrid1" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::LHAGrid1 *)new Pythia8::LHAGrid1(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAGrid1, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAGrid1__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::LHAGrid1 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_LHAGrid1",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LHAGrid1" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_LHAGrid1" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::LHAGrid1 *)new Pythia8::LHAGrid1(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAGrid1, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAGrid1__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHAGrid1 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LHAGrid1",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LHAGrid1" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::LHAGrid1 *)new Pythia8::LHAGrid1(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAGrid1, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAGrid1__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAGrid1 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LHAGrid1")) SWIG_fail;
  result = (Pythia8::LHAGrid1 *)new Pythia8::LHAGrid1();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAGrid1, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAGrid1__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::istream *arg2 = 0 ;
  Pythia8::Info *arg3 = (Pythia8::Info *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::LHAGrid1 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_LHAGrid1",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LHAGrid1" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LHAGrid1" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LHAGrid1" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LHAGrid1" "', argument " "3"" of type '" "Pythia8::Info *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Info * >(argp3);
  result = (Pythia8::LHAGrid1 *)new Pythia8::LHAGrid1(arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAGrid1, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAGrid1__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::istream *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::LHAGrid1 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_LHAGrid1",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LHAGrid1" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LHAGrid1" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LHAGrid1" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  result = (Pythia8::LHAGrid1 *)new Pythia8::LHAGrid1(arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAGrid1, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAGrid1(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_LHAGrid1__SWIG_4(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_LHAGrid1__SWIG_3(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_LHAGrid1__SWIG_6(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_LHAGrid1__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_LHAGrid1__SWIG_5(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_LHAGrid1__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_LHAGrid1__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LHAGrid1'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAGrid1::LHAGrid1(int,std::string,std::string,Pythia8::Info *)\n"
    "    Pythia8::LHAGrid1::LHAGrid1(int,std::string,std::string)\n"
    "    Pythia8::LHAGrid1::LHAGrid1(int,std::string)\n"
    "    Pythia8::LHAGrid1::LHAGrid1(int)\n"
    "    Pythia8::LHAGrid1::LHAGrid1()\n"
    "    Pythia8::LHAGrid1::LHAGrid1(int,std::istream &,Pythia8::Info *)\n"
    "    Pythia8::LHAGrid1::LHAGrid1(int,std::istream &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LHAGrid1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAGrid1 *arg1 = (Pythia8::LHAGrid1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LHAGrid1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAGrid1, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LHAGrid1" "', argument " "1"" of type '" "Pythia8::LHAGrid1 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAGrid1 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAGrid1_setExtrapolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAGrid1 *arg1 = (Pythia8::LHAGrid1 *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAGrid1_setExtrapolate",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAGrid1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAGrid1_setExtrapolate" "', argument " "1"" of type '" "Pythia8::LHAGrid1 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAGrid1 * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAGrid1_setExtrapolate" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setExtrapolate(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LHAGrid1_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__LHAGrid1, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Lepton2gamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  Pythia8::PDF *arg4 = (Pythia8::PDF *) 0 ;
  Pythia8::Info *arg5 = (Pythia8::Info *) 0 ;
  Pythia8::Rndm *arg6 = (Pythia8::Rndm *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::Lepton2gamma *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_Lepton2gamma",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Lepton2gamma" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Lepton2gamma" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Lepton2gamma" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Lepton2gamma" "', argument " "4"" of type '" "Pythia8::PDF *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::PDF * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Lepton2gamma" "', argument " "5"" of type '" "Pythia8::Info *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Info * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Lepton2gamma" "', argument " "6"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::Rndm * >(argp6);
  result = (Pythia8::Lepton2gamma *)new Pythia8::Lepton2gamma(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Lepton2gamma, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Lepton2gamma_xfUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Lepton2gamma *arg1 = (Pythia8::Lepton2gamma *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Lepton2gamma_xfUpdate",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Lepton2gamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Lepton2gamma_xfUpdate" "', argument " "1"" of type '" "Pythia8::Lepton2gamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Lepton2gamma * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Lepton2gamma_xfUpdate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Lepton2gamma_xfUpdate" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Lepton2gamma_xfUpdate" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->xfUpdate(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Lepton2gamma_xGamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Lepton2gamma *arg1 = (Pythia8::Lepton2gamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Lepton2gamma_xGamma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Lepton2gamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Lepton2gamma_xGamma" "', argument " "1"" of type '" "Pythia8::Lepton2gamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Lepton2gamma * >(argp1);
  result = (double)(arg1)->xGamma();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Lepton2gamma_xfMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Lepton2gamma *arg1 = (Pythia8::Lepton2gamma *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Lepton2gamma_xfMax",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Lepton2gamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Lepton2gamma_xfMax" "', argument " "1"" of type '" "Pythia8::Lepton2gamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Lepton2gamma * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Lepton2gamma_xfMax" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Lepton2gamma_xfMax" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Lepton2gamma_xfMax" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->xfMax(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Lepton2gamma_xfSame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Lepton2gamma *arg1 = (Pythia8::Lepton2gamma *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Lepton2gamma_xfSame",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Lepton2gamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Lepton2gamma_xfSame" "', argument " "1"" of type '" "Pythia8::Lepton2gamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Lepton2gamma * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Lepton2gamma_xfSame" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Lepton2gamma_xfSame" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Lepton2gamma_xfSame" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->xfSame(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Lepton2gamma_sampleQ2gamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Lepton2gamma *arg1 = (Pythia8::Lepton2gamma *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Lepton2gamma_sampleQ2gamma",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Lepton2gamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Lepton2gamma_sampleQ2gamma" "', argument " "1"" of type '" "Pythia8::Lepton2gamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Lepton2gamma * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Lepton2gamma_sampleQ2gamma" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->sampleQ2gamma(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Lepton2gamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Lepton2gamma *arg1 = (Pythia8::Lepton2gamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Lepton2gamma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Lepton2gamma, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Lepton2gamma" "', argument " "1"" of type '" "Pythia8::Lepton2gamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Lepton2gamma * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Lepton2gamma_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Lepton2gamma, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_GammaPoint__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::GammaPoint *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_GammaPoint",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GammaPoint" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::GammaPoint *)new Pythia8::GammaPoint(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__GammaPoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GammaPoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaPoint *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_GammaPoint")) SWIG_fail;
  result = (Pythia8::GammaPoint *)new Pythia8::GammaPoint();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__GammaPoint, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GammaPoint(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_GammaPoint__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_GammaPoint__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GammaPoint'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::GammaPoint::GammaPoint(int)\n"
    "    Pythia8::GammaPoint::GammaPoint()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GammaPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaPoint *arg1 = (Pythia8::GammaPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_GammaPoint",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaPoint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GammaPoint" "', argument " "1"" of type '" "Pythia8::GammaPoint *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaPoint * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GammaPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__GammaPoint, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EPAexternal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  Pythia8::PDF *arg3 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg4 = (Pythia8::PDF *) 0 ;
  Pythia8::Settings *arg5 = (Pythia8::Settings *) 0 ;
  Pythia8::Info *arg6 = (Pythia8::Info *) 0 ;
  Pythia8::Rndm *arg7 = (Pythia8::Rndm *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Pythia8::EPAexternal *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_EPAexternal",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EPAexternal" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EPAexternal" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_EPAexternal" "', argument " "3"" of type '" "Pythia8::PDF *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PDF * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_EPAexternal" "', argument " "4"" of type '" "Pythia8::PDF *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::PDF * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_EPAexternal" "', argument " "5"" of type '" "Pythia8::Settings *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Settings * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_EPAexternal" "', argument " "6"" of type '" "Pythia8::Info *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::Info * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_EPAexternal" "', argument " "7"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::Rndm * >(argp7);
  result = (Pythia8::EPAexternal *)new Pythia8::EPAexternal(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__EPAexternal, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EPAexternal_xfUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EPAexternal *arg1 = (Pythia8::EPAexternal *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:EPAexternal_xfUpdate",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EPAexternal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EPAexternal_xfUpdate" "', argument " "1"" of type '" "Pythia8::EPAexternal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EPAexternal * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EPAexternal_xfUpdate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EPAexternal_xfUpdate" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EPAexternal_xfUpdate" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->xfUpdate(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EPAexternal_xfFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EPAexternal *arg1 = (Pythia8::EPAexternal *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:EPAexternal_xfFlux",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EPAexternal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EPAexternal_xfFlux" "', argument " "1"" of type '" "Pythia8::EPAexternal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EPAexternal * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EPAexternal_xfFlux" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EPAexternal_xfFlux" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EPAexternal_xfFlux" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->xfFlux(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EPAexternal_xfGamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EPAexternal *arg1 = (Pythia8::EPAexternal *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:EPAexternal_xfGamma",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EPAexternal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EPAexternal_xfGamma" "', argument " "1"" of type '" "Pythia8::EPAexternal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EPAexternal * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EPAexternal_xfGamma" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EPAexternal_xfGamma" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EPAexternal_xfGamma" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->xfGamma(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EPAexternal_xfApprox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EPAexternal *arg1 = (Pythia8::EPAexternal *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:EPAexternal_xfApprox",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EPAexternal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EPAexternal_xfApprox" "', argument " "1"" of type '" "Pythia8::EPAexternal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EPAexternal * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EPAexternal_xfApprox" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EPAexternal_xfApprox" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EPAexternal_xfApprox" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->xfApprox(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EPAexternal_getQ2min(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EPAexternal *arg1 = (Pythia8::EPAexternal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:EPAexternal_getQ2min",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EPAexternal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EPAexternal_getQ2min" "', argument " "1"" of type '" "Pythia8::EPAexternal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EPAexternal * >(argp1);
  result = (double)(arg1)->getQ2min();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EPAexternal_getXmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EPAexternal *arg1 = (Pythia8::EPAexternal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:EPAexternal_getXmin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EPAexternal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EPAexternal_getXmin" "', argument " "1"" of type '" "Pythia8::EPAexternal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EPAexternal * >(argp1);
  result = (double)(arg1)->getXmin();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EPAexternal_getXhadr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EPAexternal *arg1 = (Pythia8::EPAexternal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:EPAexternal_getXhadr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EPAexternal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EPAexternal_getXhadr" "', argument " "1"" of type '" "Pythia8::EPAexternal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EPAexternal * >(argp1);
  result = (double)(arg1)->getXhadr();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EPAexternal_getGammaFluxNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EPAexternal *arg1 = (Pythia8::EPAexternal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:EPAexternal_getGammaFluxNorm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EPAexternal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EPAexternal_getGammaFluxNorm" "', argument " "1"" of type '" "Pythia8::EPAexternal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EPAexternal * >(argp1);
  result = (double)(arg1)->getGammaFluxNorm();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EPAexternal_sampleXgamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EPAexternal *arg1 = (Pythia8::EPAexternal *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:EPAexternal_sampleXgamma",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EPAexternal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EPAexternal_sampleXgamma" "', argument " "1"" of type '" "Pythia8::EPAexternal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EPAexternal * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EPAexternal_sampleXgamma" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->sampleXgamma(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EPAexternal_sampleQ2gamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EPAexternal *arg1 = (Pythia8::EPAexternal *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:EPAexternal_sampleQ2gamma",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EPAexternal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EPAexternal_sampleQ2gamma" "', argument " "1"" of type '" "Pythia8::EPAexternal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EPAexternal * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EPAexternal_sampleQ2gamma" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->sampleQ2gamma(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_EPAexternal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EPAexternal *arg1 = (Pythia8::EPAexternal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EPAexternal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EPAexternal, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EPAexternal" "', argument " "1"" of type '" "Pythia8::EPAexternal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EPAexternal * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EPAexternal_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__EPAexternal, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_nPDF_xfUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::nPDF *arg1 = (Pythia8::nPDF *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:nPDF_xfUpdate",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__nPDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nPDF_xfUpdate" "', argument " "1"" of type '" "Pythia8::nPDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::nPDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "nPDF_xfUpdate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "nPDF_xfUpdate" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "nPDF_xfUpdate" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->xfUpdate(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nPDF_rUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::nPDF *arg1 = (Pythia8::nPDF *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:nPDF_rUpdate",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__nPDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nPDF_rUpdate" "', argument " "1"" of type '" "Pythia8::nPDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::nPDF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "nPDF_rUpdate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "nPDF_rUpdate" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "nPDF_rUpdate" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->rUpdate(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nPDF_initNPDF__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::nPDF *arg1 = (Pythia8::nPDF *) 0 ;
  Pythia8::PDF *arg2 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:nPDF_initNPDF",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__nPDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nPDF_initNPDF" "', argument " "1"" of type '" "Pythia8::nPDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::nPDF * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nPDF_initNPDF" "', argument " "2"" of type '" "Pythia8::PDF *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PDF * >(argp2);
  (arg1)->initNPDF(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nPDF_initNPDF__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::nPDF *arg1 = (Pythia8::nPDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:nPDF_initNPDF",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__nPDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nPDF_initNPDF" "', argument " "1"" of type '" "Pythia8::nPDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::nPDF * >(argp1);
  (arg1)->initNPDF();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nPDF_initNPDF(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__nPDF, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_nPDF_initNPDF__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__nPDF, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_nPDF_initNPDF__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'nPDF_initNPDF'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::nPDF::initNPDF(Pythia8::PDF *)\n"
    "    Pythia8::nPDF::initNPDF()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_nPDF_getA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::nPDF *arg1 = (Pythia8::nPDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:nPDF_getA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__nPDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nPDF_getA" "', argument " "1"" of type '" "Pythia8::nPDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::nPDF * >(argp1);
  result = (int)(arg1)->getA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nPDF_getZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::nPDF *arg1 = (Pythia8::nPDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:nPDF_getZ",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__nPDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nPDF_getZ" "', argument " "1"" of type '" "Pythia8::nPDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::nPDF * >(argp1);
  result = (int)(arg1)->getZ();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nPDF_setMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::nPDF *arg1 = (Pythia8::nPDF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:nPDF_setMode",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__nPDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nPDF_setMode" "', argument " "1"" of type '" "Pythia8::nPDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::nPDF * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "nPDF_setMode" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setMode(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nPDF_resetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::nPDF *arg1 = (Pythia8::nPDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:nPDF_resetMode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__nPDF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nPDF_resetMode" "', argument " "1"" of type '" "Pythia8::nPDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::nPDF * >(argp1);
  (arg1)->resetMode();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_nPDF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::nPDF *arg1 = (Pythia8::nPDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_nPDF",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__nPDF, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_nPDF" "', argument " "1"" of type '" "Pythia8::nPDF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::nPDF * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *nPDF_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__nPDF, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Isospin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Pythia8::PDF *arg2 = (Pythia8::PDF *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Isospin *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Isospin",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Isospin" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Isospin" "', argument " "2"" of type '" "Pythia8::PDF *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PDF * >(argp2);
  result = (Pythia8::Isospin *)new Pythia8::Isospin(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Isospin, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Isospin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Isospin *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Isospin",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Isospin" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Isospin *)new Pythia8::Isospin(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Isospin, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Isospin__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Isospin *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Isospin")) SWIG_fail;
  result = (Pythia8::Isospin *)new Pythia8::Isospin();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Isospin, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Isospin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Isospin__SWIG_2(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Isospin__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Isospin__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Isospin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Isospin::Isospin(int,Pythia8::PDF *)\n"
    "    Pythia8::Isospin::Isospin(int)\n"
    "    Pythia8::Isospin::Isospin()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Isospin_rUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Isospin *arg1 = (Pythia8::Isospin *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Isospin_rUpdate",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Isospin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Isospin_rUpdate" "', argument " "1"" of type '" "Pythia8::Isospin *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Isospin * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Isospin_rUpdate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Isospin_rUpdate" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Isospin_rUpdate" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->rUpdate(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Isospin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Isospin *arg1 = (Pythia8::Isospin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Isospin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Isospin, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Isospin" "', argument " "1"" of type '" "Pythia8::Isospin *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Isospin * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Isospin_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Isospin, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EPS09__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  std::string arg4 ;
  Pythia8::PDF *arg5 = (Pythia8::PDF *) 0 ;
  Pythia8::Info *arg6 = (Pythia8::Info *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::EPS09 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_EPS09",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EPS09" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EPS09" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EPS09" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_EPS09" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_EPS09" "', argument " "5"" of type '" "Pythia8::PDF *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::PDF * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_EPS09" "', argument " "6"" of type '" "Pythia8::Info *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::Info * >(argp6);
  result = (Pythia8::EPS09 *)new Pythia8::EPS09(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__EPS09, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EPS09__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  std::string arg4 ;
  Pythia8::PDF *arg5 = (Pythia8::PDF *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::EPS09 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_EPS09",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EPS09" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EPS09" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EPS09" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_EPS09" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_EPS09" "', argument " "5"" of type '" "Pythia8::PDF *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::PDF * >(argp5);
  result = (Pythia8::EPS09 *)new Pythia8::EPS09(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__EPS09, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EPS09__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  std::string arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::EPS09 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_EPS09",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EPS09" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EPS09" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EPS09" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_EPS09" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::EPS09 *)new Pythia8::EPS09(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__EPS09, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EPS09__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::EPS09 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_EPS09",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EPS09" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EPS09" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EPS09" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::EPS09 *)new Pythia8::EPS09(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__EPS09, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EPS09__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::EPS09 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_EPS09",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EPS09" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EPS09" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::EPS09 *)new Pythia8::EPS09(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__EPS09, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EPS09__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::EPS09 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EPS09",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EPS09" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::EPS09 *)new Pythia8::EPS09(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__EPS09, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EPS09__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EPS09 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EPS09")) SWIG_fail;
  result = (Pythia8::EPS09 *)new Pythia8::EPS09();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__EPS09, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EPS09(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_EPS09__SWIG_6(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_EPS09__SWIG_5(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_EPS09__SWIG_4(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_EPS09__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_EPS09__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_EPS09__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_EPS09__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EPS09'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::EPS09::EPS09(int,int,int,std::string,Pythia8::PDF *,Pythia8::Info *)\n"
    "    Pythia8::EPS09::EPS09(int,int,int,std::string,Pythia8::PDF *)\n"
    "    Pythia8::EPS09::EPS09(int,int,int,std::string)\n"
    "    Pythia8::EPS09::EPS09(int,int,int)\n"
    "    Pythia8::EPS09::EPS09(int,int)\n"
    "    Pythia8::EPS09::EPS09(int)\n"
    "    Pythia8::EPS09::EPS09()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_EPS09_rUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EPS09 *arg1 = (Pythia8::EPS09 *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:EPS09_rUpdate",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EPS09, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EPS09_rUpdate" "', argument " "1"" of type '" "Pythia8::EPS09 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EPS09 * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EPS09_rUpdate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EPS09_rUpdate" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EPS09_rUpdate" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->rUpdate(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EPS09_setErrorSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EPS09 *arg1 = (Pythia8::EPS09 *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:EPS09_setErrorSet",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EPS09, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EPS09_setErrorSet" "', argument " "1"" of type '" "Pythia8::EPS09 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EPS09 * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EPS09_setErrorSet" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setErrorSet(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_EPS09(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EPS09 *arg1 = (Pythia8::EPS09 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EPS09",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EPS09, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EPS09" "', argument " "1"" of type '" "Pythia8::EPS09 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EPS09 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EPS09_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__EPS09, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EPPS16__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  std::string arg3 ;
  Pythia8::PDF *arg4 = (Pythia8::PDF *) 0 ;
  Pythia8::Info *arg5 = (Pythia8::Info *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::EPPS16 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_EPPS16",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EPPS16" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EPPS16" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_EPPS16" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_EPPS16" "', argument " "4"" of type '" "Pythia8::PDF *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::PDF * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_EPPS16" "', argument " "5"" of type '" "Pythia8::Info *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Info * >(argp5);
  result = (Pythia8::EPPS16 *)new Pythia8::EPPS16(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__EPPS16, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EPPS16__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  std::string arg3 ;
  Pythia8::PDF *arg4 = (Pythia8::PDF *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::EPPS16 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_EPPS16",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EPPS16" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EPPS16" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_EPPS16" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_EPPS16" "', argument " "4"" of type '" "Pythia8::PDF *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::PDF * >(argp4);
  result = (Pythia8::EPPS16 *)new Pythia8::EPPS16(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__EPPS16, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EPPS16__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  std::string arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::EPPS16 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_EPPS16",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EPPS16" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EPPS16" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_EPPS16" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::EPPS16 *)new Pythia8::EPPS16(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__EPPS16, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EPPS16__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::EPPS16 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_EPPS16",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EPPS16" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EPPS16" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::EPPS16 *)new Pythia8::EPPS16(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__EPPS16, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EPPS16__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::EPPS16 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_EPPS16",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EPPS16" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::EPPS16 *)new Pythia8::EPPS16(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__EPPS16, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EPPS16__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EPPS16 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EPPS16")) SWIG_fail;
  result = (Pythia8::EPPS16 *)new Pythia8::EPPS16();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__EPPS16, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_EPPS16(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_EPPS16__SWIG_5(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_EPPS16__SWIG_4(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_EPPS16__SWIG_3(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_EPPS16__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_EPPS16__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_EPPS16__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EPPS16'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::EPPS16::EPPS16(int,int,std::string,Pythia8::PDF *,Pythia8::Info *)\n"
    "    Pythia8::EPPS16::EPPS16(int,int,std::string,Pythia8::PDF *)\n"
    "    Pythia8::EPPS16::EPPS16(int,int,std::string)\n"
    "    Pythia8::EPPS16::EPPS16(int,int)\n"
    "    Pythia8::EPPS16::EPPS16(int)\n"
    "    Pythia8::EPPS16::EPPS16()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_EPPS16_rUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EPPS16 *arg1 = (Pythia8::EPPS16 *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:EPPS16_rUpdate",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EPPS16, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EPPS16_rUpdate" "', argument " "1"" of type '" "Pythia8::EPPS16 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EPPS16 * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EPPS16_rUpdate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EPPS16_rUpdate" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EPPS16_rUpdate" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->rUpdate(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EPPS16_setErrorSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EPPS16 *arg1 = (Pythia8::EPPS16 *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:EPPS16_setErrorSet",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EPPS16, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EPPS16_setErrorSet" "', argument " "1"" of type '" "Pythia8::EPPS16 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EPPS16 * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EPPS16_setErrorSet" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setErrorSet(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_EPPS16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EPPS16 *arg1 = (Pythia8::EPPS16 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EPPS16",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EPPS16, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EPPS16" "', argument " "1"" of type '" "Pythia8::EPPS16 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EPPS16 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EPPS16_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__EPPS16, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_ResonanceWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceWidths",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceWidths" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_initBasic__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ResonanceWidths_initBasic",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_initBasic" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_initBasic" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ResonanceWidths_initBasic" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->initBasic(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_initBasic__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_initBasic",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_initBasic" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_initBasic" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->initBasic(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_initBasic(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResonanceWidths, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResonanceWidths_initBasic__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResonanceWidths, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ResonanceWidths_initBasic__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ResonanceWidths_initBasic'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ResonanceWidths::initBasic(int,bool)\n"
    "    Pythia8::ResonanceWidths::initBasic(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = (Pythia8::Settings *) 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Couplings *arg5 = (Pythia8::Couplings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ResonanceWidths_init",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_init" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ResonanceWidths_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ResonanceWidths_init" "', argument " "3"" of type '" "Pythia8::Settings *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ResonanceWidths_init" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ResonanceWidths_init" "', argument " "5"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Couplings * >(argp5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::ResonanceWidths::init(arg2,arg3,arg4,arg5);
    } else {
      result = (bool)(arg1)->init(arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_id",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_id" "', argument " "1"" of type '" "Pythia8::ResonanceWidths const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  result = (int)((Pythia8::ResonanceWidths const *)arg1)->id();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_width__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  bool arg5 ;
  bool arg6 ;
  int arg7 ;
  int arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:ResonanceWidths_width",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_width" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ResonanceWidths_width" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ResonanceWidths_width" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ResonanceWidths_width" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ResonanceWidths_width" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ResonanceWidths_width" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ResonanceWidths_width" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  result = (double)(arg1)->width(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_width__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  bool arg5 ;
  bool arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:ResonanceWidths_width",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_width" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ResonanceWidths_width" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ResonanceWidths_width" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ResonanceWidths_width" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ResonanceWidths_width" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ResonanceWidths_width" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  result = (double)(arg1)->width(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_width__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  bool arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ResonanceWidths_width",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_width" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ResonanceWidths_width" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ResonanceWidths_width" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ResonanceWidths_width" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ResonanceWidths_width" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  result = (double)(arg1)->width(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_width__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ResonanceWidths_width",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_width" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ResonanceWidths_width" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ResonanceWidths_width" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ResonanceWidths_width" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (double)(arg1)->width(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_width__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ResonanceWidths_width",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_width" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ResonanceWidths_width" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ResonanceWidths_width" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->width(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_width__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ResonanceWidths_width",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_width" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_width" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ResonanceWidths_width" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)(arg1)->width(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_width(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 8) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResonanceWidths, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ResonanceWidths_width__SWIG_5(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResonanceWidths, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ResonanceWidths_width__SWIG_4(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResonanceWidths, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ResonanceWidths_width__SWIG_3(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResonanceWidths, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_ResonanceWidths_width__SWIG_2(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResonanceWidths, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_ResonanceWidths_width__SWIG_1(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResonanceWidths, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_ResonanceWidths_width__SWIG_0(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ResonanceWidths_width'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ResonanceWidths::width(int,double,int,bool,bool,int,int)\n"
    "    Pythia8::ResonanceWidths::width(int,double,int,bool,bool,int)\n"
    "    Pythia8::ResonanceWidths::width(int,double,int,bool,bool)\n"
    "    Pythia8::ResonanceWidths::width(int,double,int,bool)\n"
    "    Pythia8::ResonanceWidths::width(int,double,int)\n"
    "    Pythia8::ResonanceWidths::width(int,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_widthOpen__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ResonanceWidths_widthOpen",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_widthOpen" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_widthOpen" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ResonanceWidths_widthOpen" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ResonanceWidths_widthOpen" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->widthOpen(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_widthOpen__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ResonanceWidths_widthOpen",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_widthOpen" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_widthOpen" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ResonanceWidths_widthOpen" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)(arg1)->widthOpen(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_widthOpen(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResonanceWidths, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ResonanceWidths_widthOpen__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResonanceWidths, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ResonanceWidths_widthOpen__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ResonanceWidths_widthOpen'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ResonanceWidths::widthOpen(int,double,int)\n"
    "    Pythia8::ResonanceWidths::widthOpen(int,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_widthStore__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ResonanceWidths_widthStore",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_widthStore" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_widthStore" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ResonanceWidths_widthStore" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ResonanceWidths_widthStore" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->widthStore(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_widthStore__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ResonanceWidths_widthStore",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_widthStore" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_widthStore" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ResonanceWidths_widthStore" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)(arg1)->widthStore(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_widthStore(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResonanceWidths, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ResonanceWidths_widthStore__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResonanceWidths, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ResonanceWidths_widthStore__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ResonanceWidths_widthStore'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ResonanceWidths::widthStore(int,double,int)\n"
    "    Pythia8::ResonanceWidths::widthStore(int,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_openFrac(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_openFrac",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_openFrac" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_openFrac" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->openFrac(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_widthRescaleFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_widthRescaleFactor",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_widthRescaleFactor" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  result = (double)(arg1)->widthRescaleFactor();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_widthChan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ResonanceWidths_widthChan",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_widthChan" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_widthChan" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ResonanceWidths_widthChan" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ResonanceWidths_widthChan" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->widthChan(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ResonanceWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceWidths *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceWidths",&obj0)) SWIG_fail;
  arg1 = obj0;
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (Pythia8::ResonanceWidths *)new SwigDirector_ResonanceWidths(arg1); 
  } else {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
    SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceWidths, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int Swig_var_ResonanceWidths_NPOINT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ResonanceWidths_NPOINT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ResonanceWidths_NPOINT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(SwigDirector_ResonanceWidths::NPOINT));
  return pyobj;
}


SWIGINTERN int Swig_var_ResonanceWidths_MASSMIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ResonanceWidths_MASSMIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ResonanceWidths_MASSMIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(SwigDirector_ResonanceWidths::MASSMIN));
  return pyobj;
}


SWIGINTERN int Swig_var_ResonanceWidths_MASSMARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ResonanceWidths_MASSMARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ResonanceWidths_MASSMARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(SwigDirector_ResonanceWidths::MASSMARGIN));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_idRes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_idRes_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_idRes_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_idRes_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->idRes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_idRes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_idRes_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_idRes_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (int) (darg->idRes);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_hasAntiRes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_hasAntiRes_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_hasAntiRes_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_hasAntiRes_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->hasAntiRes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_hasAntiRes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_hasAntiRes_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_hasAntiRes_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (int) (darg->hasAntiRes);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_doForceWidth_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_doForceWidth_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_doForceWidth_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_doForceWidth_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->doForceWidth = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_doForceWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_doForceWidth_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_doForceWidth_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (bool) (darg->doForceWidth);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_isGeneric_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_isGeneric_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_isGeneric_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_isGeneric_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->isGeneric = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_isGeneric_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_isGeneric_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_isGeneric_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (bool) (darg->isGeneric);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_allowCalcWidth_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_allowCalcWidth_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_allowCalcWidth_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_allowCalcWidth_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->allowCalcWidth = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_allowCalcWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_allowCalcWidth_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_allowCalcWidth_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (bool) (darg->allowCalcWidth);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_minWidth_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_minWidth_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_minWidth_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_minWidth_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->minWidth = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_minWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_minWidth_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_minWidth_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double) (darg->minWidth);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_minThreshold_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_minThreshold_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_minThreshold_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_minThreshold_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->minThreshold = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_minThreshold_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_minThreshold_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_minThreshold_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double) (darg->minThreshold);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_mRes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_mRes_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_mRes_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_mRes_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->mRes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_mRes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_mRes_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_mRes_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double) (darg->mRes);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_GammaRes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_GammaRes_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_GammaRes_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_GammaRes_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->GammaRes = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_GammaRes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_GammaRes_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_GammaRes_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double) (darg->GammaRes);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_m2Res_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_m2Res_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_m2Res_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_m2Res_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->m2Res = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_m2Res_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_m2Res_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_m2Res_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double) (darg->m2Res);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_GamMRat_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_GamMRat_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_GamMRat_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_GamMRat_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->GamMRat = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_GamMRat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_GamMRat_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_GamMRat_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double) (darg->GamMRat);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_openPos_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_openPos_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_openPos_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_openPos_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->openPos = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_openPos_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_openPos_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_openPos_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double) (darg->openPos);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_openNeg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_openNeg_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_openNeg_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_openNeg_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->openNeg = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_openNeg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_openNeg_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_openNeg_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double) (darg->openNeg);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_forceFactor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_forceFactor_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_forceFactor_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_forceFactor_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->forceFactor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_forceFactor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_forceFactor_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_forceFactor_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double) (darg->forceFactor);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_iChannel_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_iChannel_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_iChannel_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_iChannel_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->iChannel = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_iChannel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_iChannel_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_iChannel_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (int) (darg->iChannel);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_onMode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_onMode_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_onMode_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_onMode_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->onMode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_onMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_onMode_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_onMode_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (int) (darg->onMode);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_meMode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_meMode_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_meMode_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_meMode_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->meMode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_meMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_meMode_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_meMode_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (int) (darg->meMode);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_mult_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_mult_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_mult_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_mult_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->mult = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_mult_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_mult_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_mult_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (int) (darg->mult);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_id1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_id1_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_id1_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_id1_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->id1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_id1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_id1_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_id1_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (int) (darg->id1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_id2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_id2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_id2_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_id2_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->id2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_id2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_id2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_id2_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (int) (darg->id2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_id3_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_id3_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_id3_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_id3_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->id3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_id3_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_id3_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_id3_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (int) (darg->id3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_id1Abs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_id1Abs_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_id1Abs_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_id1Abs_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->id1Abs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_id1Abs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_id1Abs_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_id1Abs_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (int) (darg->id1Abs);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_id2Abs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_id2Abs_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_id2Abs_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_id2Abs_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->id2Abs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_id2Abs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_id2Abs_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_id2Abs_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (int) (darg->id2Abs);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_id3Abs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_id3Abs_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_id3Abs_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_id3Abs_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->id3Abs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_id3Abs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_id3Abs_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_id3Abs_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (int) (darg->id3Abs);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_idInFlav_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_idInFlav_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_idInFlav_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_idInFlav_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->idInFlav = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_idInFlav_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_idInFlav_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_idInFlav_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (int) (darg->idInFlav);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_widNow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_widNow_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_widNow_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_widNow_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->widNow = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_widNow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_widNow_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_widNow_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double) (darg->widNow);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_mHat_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_mHat_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_mHat_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_mHat_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->mHat = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_mHat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_mHat_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_mHat_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double) (darg->mHat);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_mf1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_mf1_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_mf1_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_mf1_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->mf1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_mf1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_mf1_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_mf1_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double) (darg->mf1);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_mf2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_mf2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_mf2_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_mf2_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->mf2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_mf2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_mf2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_mf2_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double) (darg->mf2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_mf3_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_mf3_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_mf3_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_mf3_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->mf3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_mf3_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_mf3_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_mf3_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double) (darg->mf3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_mr1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_mr1_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_mr1_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_mr1_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->mr1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_mr1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_mr1_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_mr1_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double) (darg->mr1);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_mr2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_mr2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_mr2_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_mr2_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->mr2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_mr2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_mr2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_mr2_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double) (darg->mr2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_mr3_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_mr3_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_mr3_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_mr3_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->mr3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_mr3_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_mr3_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_mr3_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double) (darg->mr3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_ps_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_ps_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_ps_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_ps_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->ps = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_ps_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_ps_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_ps_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double) (darg->ps);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_kinFac_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_kinFac_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_kinFac_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_kinFac_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->kinFac = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_kinFac_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_kinFac_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_kinFac_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double) (darg->kinFac);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_alpEM_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_alpEM_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_alpEM_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_alpEM_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->alpEM = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_alpEM_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_alpEM_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_alpEM_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double) (darg->alpEM);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_alpS_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_alpS_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_alpS_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_alpS_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->alpS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_alpS_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_alpS_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_alpS_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double) (darg->alpS);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_colQ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_colQ_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_colQ_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_colQ_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->colQ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_colQ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_colQ_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_colQ_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double) (darg->colQ);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_preFac_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_preFac_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_preFac_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_preFac_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->preFac = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_preFac_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_preFac_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_preFac_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double) (darg->preFac);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_particlePtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  Pythia8::ParticleDataEntry *arg2 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_particlePtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_particlePtr_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ParticleDataEntry, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ResonanceWidths_particlePtr_set" "', argument " "2"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->particlePtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_particlePtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  Pythia8::ParticleDataEntry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_particlePtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_particlePtr_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (Pythia8::ParticleDataEntry *) (darg->particlePtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_infoPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_infoPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_infoPtr_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ResonanceWidths_infoPtr_set" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->infoPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_infoPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  Pythia8::Info *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_infoPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_infoPtr_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (Pythia8::Info *) (darg->infoPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_settingsPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  Pythia8::Settings *arg2 = (Pythia8::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_settingsPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_settingsPtr_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Settings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ResonanceWidths_settingsPtr_set" "', argument " "2"" of type '" "Pythia8::Settings *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->settingsPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_settingsPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  Pythia8::Settings *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_settingsPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_settingsPtr_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (Pythia8::Settings *) (darg->settingsPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_particleDataPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  Pythia8::ParticleData *arg2 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_particleDataPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_particleDataPtr_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ParticleData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ResonanceWidths_particleDataPtr_set" "', argument " "2"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ParticleData * >(argp2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->particleDataPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_particleDataPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  Pythia8::ParticleData *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_particleDataPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_particleDataPtr_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (Pythia8::ParticleData *) (darg->particleDataPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_couplingsPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  Pythia8::Couplings *arg2 = (Pythia8::Couplings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_couplingsPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_couplingsPtr_set" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Couplings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ResonanceWidths_couplingsPtr_set" "', argument " "2"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Couplings * >(argp2);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  if (arg1) darg->couplingsPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_couplingsPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  Pythia8::Couplings *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_couplingsPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_couplingsPtr_get" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (Pythia8::Couplings *) (darg->couplingsPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_initConstants(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_initConstants",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_initConstants" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("initConstants"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member initConstants");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
    if (upcall) {
      (darg)->initConstantsSwigPublic();
    } else {
      (darg)->initConstants();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_initBSM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_ResonanceWidths *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_initBSM",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_initBSM" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("initBSM"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member initBSM");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
    if (upcall) {
      result = (bool)(darg)->initBSMSwigPublic();
    } else {
      result = (bool)(darg)->initBSM();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_allowCalc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_ResonanceWidths *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_allowCalc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_allowCalc" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("allowCalc"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member allowCalc");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
    if (upcall) {
      result = (bool)(darg)->allowCalcSwigPublic();
    } else {
      result = (bool)(darg)->allowCalc();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_calcPreFac__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_calcPreFac",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_calcPreFac" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_calcPreFac" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("calcPreFac"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member calcPreFac");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
    if (upcall) {
      (darg)->calcPreFacSwigPublic(arg2);
    } else {
      (darg)->calcPreFac(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_calcPreFac__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_calcPreFac",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_calcPreFac" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("calcPreFac"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member calcPreFac");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
    if (upcall) {
      (darg)->calcPreFacSwigPublic();
    } else {
      (darg)->calcPreFac();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_calcPreFac(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResonanceWidths, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResonanceWidths_calcPreFac__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResonanceWidths, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResonanceWidths_calcPreFac__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ResonanceWidths_calcPreFac'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ResonanceWidths::calcPreFac(bool)\n"
    "    Pythia8::ResonanceWidths::calcPreFac()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_calcWidth__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceWidths_calcWidth",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_calcWidth" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_calcWidth" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("calcWidth"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member calcWidth");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
    if (upcall) {
      (darg)->calcWidthSwigPublic(arg2);
    } else {
      (darg)->calcWidth(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_calcWidth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_ResonanceWidths *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceWidths_calcWidth",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_calcWidth" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("calcWidth"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member calcWidth");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
    if (upcall) {
      (darg)->calcWidthSwigPublic();
    } else {
      (darg)->calcWidth();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_calcWidth(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResonanceWidths, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResonanceWidths_calcWidth__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResonanceWidths, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResonanceWidths_calcWidth__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ResonanceWidths_calcWidth'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ResonanceWidths::calcWidth(bool)\n"
    "    Pythia8::ResonanceWidths::calcWidth()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_numInt1BW__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:ResonanceWidths_numInt1BW",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_numInt1BW" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_numInt1BW" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ResonanceWidths_numInt1BW" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ResonanceWidths_numInt1BW" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ResonanceWidths_numInt1BW" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ResonanceWidths_numInt1BW" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ResonanceWidths_numInt1BW" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double)(darg)->numInt1BW(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_numInt1BW__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ResonanceWidths_numInt1BW",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_numInt1BW" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_numInt1BW" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ResonanceWidths_numInt1BW" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ResonanceWidths_numInt1BW" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ResonanceWidths_numInt1BW" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ResonanceWidths_numInt1BW" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double)(darg)->numInt1BW(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_numInt1BW(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResonanceWidths, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_ResonanceWidths_numInt1BW__SWIG_1(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResonanceWidths, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_ResonanceWidths_numInt1BW__SWIG_0(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ResonanceWidths_numInt1BW'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ResonanceWidths::numInt1BW(double,double,double,double,double,int)\n"
    "    Pythia8::ResonanceWidths::numInt1BW(double,double,double,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_numInt2BW__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  int arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:ResonanceWidths_numInt2BW",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_numInt2BW" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_numInt2BW" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ResonanceWidths_numInt2BW" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ResonanceWidths_numInt2BW" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ResonanceWidths_numInt2BW" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ResonanceWidths_numInt2BW" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ResonanceWidths_numInt2BW" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ResonanceWidths_numInt2BW" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ResonanceWidths_numInt2BW" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double)(darg)->numInt2BW(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_numInt2BW__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  SwigDirector_ResonanceWidths *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:ResonanceWidths_numInt2BW",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceWidths_numInt2BW" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResonanceWidths_numInt2BW" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ResonanceWidths_numInt2BW" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ResonanceWidths_numInt2BW" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ResonanceWidths_numInt2BW" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ResonanceWidths_numInt2BW" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ResonanceWidths_numInt2BW" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ResonanceWidths_numInt2BW" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  darg = dynamic_cast<SwigDirector_ResonanceWidths *>(arg1);
  result = (double)(darg)->numInt2BW(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceWidths_numInt2BW(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 9) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResonanceWidths, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_ResonanceWidths_numInt2BW__SWIG_1(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResonanceWidths, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_ResonanceWidths_numInt2BW__SWIG_0(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ResonanceWidths_numInt2BW'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ResonanceWidths::numInt2BW(double,double,double,double,double,double,double,int)\n"
    "    Pythia8::ResonanceWidths::numInt2BW(double,double,double,double,double,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_disown_ResonanceWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWidths *arg1 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:disown_ResonanceWidths",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_ResonanceWidths" "', argument " "1"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceWidths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceWidths, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceGeneric *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceGeneric",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceGeneric" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResonanceGeneric *)new Pythia8::ResonanceGeneric(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceGeneric, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceGeneric_allowCalc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceGeneric *arg1 = (Pythia8::ResonanceGeneric *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResonanceGeneric_allowCalc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceGeneric, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceGeneric_allowCalc" "', argument " "1"" of type '" "Pythia8::ResonanceGeneric *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceGeneric * >(argp1);
  result = (bool)(arg1)->allowCalc();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceGeneric *arg1 = (Pythia8::ResonanceGeneric *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceGeneric",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceGeneric, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceGeneric" "', argument " "1"" of type '" "Pythia8::ResonanceGeneric *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceGeneric * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceGeneric_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceGeneric, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceGmZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceGmZ *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceGmZ",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceGmZ" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResonanceGmZ *)new Pythia8::ResonanceGmZ(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceGmZ, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceGmZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceGmZ *arg1 = (Pythia8::ResonanceGmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceGmZ",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceGmZ, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceGmZ" "', argument " "1"" of type '" "Pythia8::ResonanceGmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceGmZ * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceGmZ_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceGmZ, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceW *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceW",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceW" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResonanceW *)new Pythia8::ResonanceW(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceW, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceW *arg1 = (Pythia8::ResonanceW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceW",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceW, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceW" "', argument " "1"" of type '" "Pythia8::ResonanceW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceW * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceW_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceW, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceTop *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceTop",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceTop" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResonanceTop *)new Pythia8::ResonanceTop(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceTop, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceTop *arg1 = (Pythia8::ResonanceTop *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceTop",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceTop, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceTop" "', argument " "1"" of type '" "Pythia8::ResonanceTop *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceTop * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceTop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceTop, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceFour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceFour *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceFour",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceFour" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResonanceFour *)new Pythia8::ResonanceFour(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceFour, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceFour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceFour *arg1 = (Pythia8::ResonanceFour *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceFour",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceFour, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceFour" "', argument " "1"" of type '" "Pythia8::ResonanceFour *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceFour * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceFour_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceFour, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::ResonanceH *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_ResonanceH",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceH" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ResonanceH" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::ResonanceH *)new Pythia8::ResonanceH(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceH, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceH *arg1 = (Pythia8::ResonanceH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceH",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceH, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceH" "', argument " "1"" of type '" "Pythia8::ResonanceH *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceH * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceH_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceH, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceHchg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceHchg *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceHchg",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceHchg" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResonanceHchg *)new Pythia8::ResonanceHchg(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceHchg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceHchg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceHchg *arg1 = (Pythia8::ResonanceHchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceHchg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceHchg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceHchg" "', argument " "1"" of type '" "Pythia8::ResonanceHchg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceHchg * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceHchg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceHchg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceZprime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceZprime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceZprime",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceZprime" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResonanceZprime *)new Pythia8::ResonanceZprime(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceZprime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceZprime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceZprime *arg1 = (Pythia8::ResonanceZprime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceZprime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceZprime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceZprime" "', argument " "1"" of type '" "Pythia8::ResonanceZprime *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceZprime * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceZprime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceZprime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceWprime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceWprime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceWprime",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceWprime" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResonanceWprime *)new Pythia8::ResonanceWprime(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceWprime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceWprime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWprime *arg1 = (Pythia8::ResonanceWprime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceWprime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWprime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceWprime" "', argument " "1"" of type '" "Pythia8::ResonanceWprime *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWprime * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceWprime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceWprime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceRhorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceRhorizontal *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceRhorizontal",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceRhorizontal" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResonanceRhorizontal *)new Pythia8::ResonanceRhorizontal(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceRhorizontal, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceRhorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceRhorizontal *arg1 = (Pythia8::ResonanceRhorizontal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceRhorizontal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceRhorizontal, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceRhorizontal" "', argument " "1"" of type '" "Pythia8::ResonanceRhorizontal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceRhorizontal * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceRhorizontal_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceRhorizontal, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceExcited(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceExcited *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceExcited",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceExcited" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResonanceExcited *)new Pythia8::ResonanceExcited(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceExcited, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceExcited(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceExcited *arg1 = (Pythia8::ResonanceExcited *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceExcited",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceExcited, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceExcited" "', argument " "1"" of type '" "Pythia8::ResonanceExcited *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceExcited * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceExcited_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceExcited, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceGraviton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceGraviton *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceGraviton",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceGraviton" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResonanceGraviton *)new Pythia8::ResonanceGraviton(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceGraviton, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceGraviton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceGraviton *arg1 = (Pythia8::ResonanceGraviton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceGraviton",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceGraviton, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceGraviton" "', argument " "1"" of type '" "Pythia8::ResonanceGraviton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceGraviton * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceGraviton_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceGraviton, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceKKgluon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceKKgluon *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceKKgluon",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceKKgluon" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResonanceKKgluon *)new Pythia8::ResonanceKKgluon(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceKKgluon, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceKKgluon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceKKgluon *arg1 = (Pythia8::ResonanceKKgluon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceKKgluon",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceKKgluon, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceKKgluon" "', argument " "1"" of type '" "Pythia8::ResonanceKKgluon *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceKKgluon * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceKKgluon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceKKgluon, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceLeptoquark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceLeptoquark *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceLeptoquark",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceLeptoquark" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResonanceLeptoquark *)new Pythia8::ResonanceLeptoquark(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceLeptoquark, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceLeptoquark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceLeptoquark *arg1 = (Pythia8::ResonanceLeptoquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceLeptoquark",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceLeptoquark, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceLeptoquark" "', argument " "1"" of type '" "Pythia8::ResonanceLeptoquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceLeptoquark * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceLeptoquark_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceLeptoquark, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceNuRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceNuRight *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceNuRight",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceNuRight" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResonanceNuRight *)new Pythia8::ResonanceNuRight(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceNuRight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceNuRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceNuRight *arg1 = (Pythia8::ResonanceNuRight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceNuRight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceNuRight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceNuRight" "', argument " "1"" of type '" "Pythia8::ResonanceNuRight *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceNuRight * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceNuRight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceNuRight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceZRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceZRight *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceZRight",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceZRight" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResonanceZRight *)new Pythia8::ResonanceZRight(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceZRight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceZRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceZRight *arg1 = (Pythia8::ResonanceZRight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceZRight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceZRight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceZRight" "', argument " "1"" of type '" "Pythia8::ResonanceZRight *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceZRight * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceZRight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceZRight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceWRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceWRight *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceWRight",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceWRight" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResonanceWRight *)new Pythia8::ResonanceWRight(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceWRight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceWRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceWRight *arg1 = (Pythia8::ResonanceWRight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceWRight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceWRight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceWRight" "', argument " "1"" of type '" "Pythia8::ResonanceWRight *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceWRight * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceWRight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceWRight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceHchgchgLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceHchgchgLeft *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceHchgchgLeft",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceHchgchgLeft" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResonanceHchgchgLeft *)new Pythia8::ResonanceHchgchgLeft(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceHchgchgLeft, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceHchgchgLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceHchgchgLeft *arg1 = (Pythia8::ResonanceHchgchgLeft *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceHchgchgLeft",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceHchgchgLeft, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceHchgchgLeft" "', argument " "1"" of type '" "Pythia8::ResonanceHchgchgLeft *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceHchgchgLeft * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceHchgchgLeft_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceHchgchgLeft, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceHchgchgRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceHchgchgRight *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceHchgchgRight",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceHchgchgRight" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResonanceHchgchgRight *)new Pythia8::ResonanceHchgchgRight(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceHchgchgRight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceHchgchgRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceHchgchgRight *arg1 = (Pythia8::ResonanceHchgchgRight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceHchgchgRight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceHchgchgRight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceHchgchgRight" "', argument " "1"" of type '" "Pythia8::ResonanceHchgchgRight *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceHchgchgRight * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceHchgchgRight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceHchgchgRight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_SigmaTotAux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SigmaTotAux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SigmaTotAux" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaTotAux_init",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_init" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaTotAux_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SigmaTotAux_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaTotAux_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SigmaTotAux_init" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SigmaTotAux_init" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  (arg1)->init(arg2,*arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_calcTotEl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SigmaTotAux_calcTotEl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_calcTotEl" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_calcTotEl" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotAux_calcTotEl" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotAux_calcTotEl" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaTotAux_calcTotEl" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaTotAux_calcTotEl" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (bool)(arg1)->calcTotEl(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_isExpEl_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaTotAux_isExpEl_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_isExpEl_set" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_isExpEl_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isExpEl = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_isExpEl_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotAux_isExpEl_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_isExpEl_get" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  result = (bool) ((arg1)->isExpEl);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_hasCou_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaTotAux_hasCou_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_hasCou_set" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_hasCou_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->hasCou = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_hasCou_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotAux_hasCou_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_hasCou_get" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  result = (bool) ((arg1)->hasCou);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_sigTot_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaTotAux_sigTot_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_sigTot_set" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_sigTot_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->sigTot = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_sigTot_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotAux_sigTot_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_sigTot_get" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  result = (double) ((arg1)->sigTot);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_rhoOwn_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaTotAux_rhoOwn_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_rhoOwn_set" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_rhoOwn_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->rhoOwn = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_rhoOwn_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotAux_rhoOwn_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_rhoOwn_get" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  result = (double) ((arg1)->rhoOwn);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_sigEl_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaTotAux_sigEl_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_sigEl_set" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_sigEl_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->sigEl = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_sigEl_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotAux_sigEl_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_sigEl_get" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  result = (double) ((arg1)->sigEl);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_bEl_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaTotAux_bEl_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_bEl_set" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_bEl_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->bEl = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_bEl_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotAux_bEl_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_bEl_get" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  result = (double) ((arg1)->bEl);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_sigTotCou_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaTotAux_sigTotCou_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_sigTotCou_set" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_sigTotCou_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->sigTotCou = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_sigTotCou_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotAux_sigTotCou_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_sigTotCou_get" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  result = (double) ((arg1)->sigTotCou);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_sigElCou_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaTotAux_sigElCou_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_sigElCou_set" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_sigElCou_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->sigElCou = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_sigElCou_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotAux_sigElCou_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_sigElCou_get" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  result = (double) ((arg1)->sigElCou);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_dsigmaEl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  double arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaTotAux_dsigmaEl",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_dsigmaEl" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_dsigmaEl" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotAux_dsigmaEl" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotAux_dsigmaEl" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (double)(arg1)->dsigmaEl(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_dsigmaEl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  double arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaTotAux_dsigmaEl",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_dsigmaEl" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_dsigmaEl" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotAux_dsigmaEl" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (double)(arg1)->dsigmaEl(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_dsigmaEl__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaTotAux_dsigmaEl",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_dsigmaEl" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_dsigmaEl" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->dsigmaEl(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_dsigmaEl(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotAux, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SigmaTotAux_dsigmaEl__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotAux, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SigmaTotAux_dsigmaEl__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotAux, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SigmaTotAux_dsigmaEl__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaTotAux_dsigmaEl'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaTotAux::dsigmaEl(double,bool,bool)\n"
    "    Pythia8::SigmaTotAux::dsigmaEl(double,bool)\n"
    "    Pythia8::SigmaTotAux::dsigmaEl(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_calcDiff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SigmaTotAux_calcDiff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_calcDiff" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_calcDiff" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotAux_calcDiff" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotAux_calcDiff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaTotAux_calcDiff" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaTotAux_calcDiff" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (bool)(arg1)->calcDiff(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_sigXB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaTotAux_sigXB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_sigXB_set" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_sigXB_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->sigXB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_sigXB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotAux_sigXB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_sigXB_get" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  result = (double) ((arg1)->sigXB);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_sigAX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaTotAux_sigAX_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_sigAX_set" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_sigAX_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->sigAX = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_sigAX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotAux_sigAX_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_sigAX_get" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  result = (double) ((arg1)->sigAX);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_sigXX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaTotAux_sigXX_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_sigXX_set" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_sigXX_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->sigXX = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_sigXX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotAux_sigXX_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_sigXX_get" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  result = (double) ((arg1)->sigXX);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_sigAXB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaTotAux_sigAXB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_sigAXB_set" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_sigAXB_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->sigAXB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_sigAXB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotAux_sigAXB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_sigAXB_get" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  result = (double) ((arg1)->sigAXB);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_dsigmaSD__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  double arg2 ;
  double arg3 ;
  bool arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaTotAux_dsigmaSD",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_dsigmaSD" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_dsigmaSD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotAux_dsigmaSD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotAux_dsigmaSD" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaTotAux_dsigmaSD" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (double)(arg1)->dsigmaSD(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_dsigmaSD__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  double arg2 ;
  double arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaTotAux_dsigmaSD",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_dsigmaSD" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_dsigmaSD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotAux_dsigmaSD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotAux_dsigmaSD" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (double)(arg1)->dsigmaSD(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_dsigmaSD__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaTotAux_dsigmaSD",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_dsigmaSD" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_dsigmaSD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotAux_dsigmaSD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)(arg1)->dsigmaSD(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_dsigmaSD(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotAux, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SigmaTotAux_dsigmaSD__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotAux, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SigmaTotAux_dsigmaSD__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotAux, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SigmaTotAux_dsigmaSD__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaTotAux_dsigmaSD'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaTotAux::dsigmaSD(double,double,bool,int)\n"
    "    Pythia8::SigmaTotAux::dsigmaSD(double,double,bool)\n"
    "    Pythia8::SigmaTotAux::dsigmaSD(double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_splitDiff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotAux_splitDiff",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_splitDiff" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  result = (bool)(arg1)->splitDiff();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_dsigmaDD__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaTotAux_dsigmaDD",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_dsigmaDD" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_dsigmaDD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotAux_dsigmaDD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotAux_dsigmaDD" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaTotAux_dsigmaDD" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (double)(arg1)->dsigmaDD(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_dsigmaDD__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaTotAux_dsigmaDD",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_dsigmaDD" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_dsigmaDD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotAux_dsigmaDD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotAux_dsigmaDD" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->dsigmaDD(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_dsigmaDD(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotAux, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SigmaTotAux_dsigmaDD__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotAux, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SigmaTotAux_dsigmaDD__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaTotAux_dsigmaDD'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaTotAux::dsigmaDD(double,double,double,int)\n"
    "    Pythia8::SigmaTotAux::dsigmaDD(double,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_dsigmaCD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SigmaTotAux_dsigmaCD",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_dsigmaCD" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_dsigmaCD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotAux_dsigmaCD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotAux_dsigmaCD" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaTotAux_dsigmaCD" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaTotAux_dsigmaCD" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (double)(arg1)->dsigmaCD(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_mMinCD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotAux_mMinCD",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_mMinCD" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  result = (double)(arg1)->mMinCD();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_tRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  SwigValueWrapper< std::pair< double,double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SigmaTotAux_tRange",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_tRange" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_tRange" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotAux_tRange" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotAux_tRange" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaTotAux_tRange" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaTotAux_tRange" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (arg1)->tRange(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj((new std::pair< double,double >(static_cast< const std::pair< double,double >& >(result))), SWIGTYPE_p_std__pairT_double_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_tInRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:SigmaTotAux_tInRange",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_tInRange" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_tInRange" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotAux_tInRange" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotAux_tInRange" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaTotAux_tInRange" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaTotAux_tInRange" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SigmaTotAux_tInRange" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (bool)(arg1)->tInRange(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotAux_pFormFac(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *arg1 = (Pythia8::SigmaTotAux *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaTotAux_pFormFac",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotAux, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotAux_pFormFac" "', argument " "1"" of type '" "Pythia8::SigmaTotAux *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotAux * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotAux_pFormFac" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->pFormFac(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SigmaTotAux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotAux *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SigmaTotAux")) SWIG_fail;
  result = (Pythia8::SigmaTotAux *)new Pythia8::SigmaTotAux();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SigmaTotAux, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SigmaTotAux_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SigmaTotAux, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SigmaTotal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SigmaTotal")) SWIG_fail;
  result = (Pythia8::SigmaTotal *)new Pythia8::SigmaTotal();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SigmaTotal, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SigmaTotal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SigmaTotal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SigmaTotal" "', argument " "1"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaTotal_init",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_init" "', argument " "1"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaTotal_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SigmaTotal_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaTotal_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SigmaTotal_init" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SigmaTotal_init" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  (arg1)->init(arg2,*arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_calc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaTotal_calc",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_calc" "', argument " "1"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotal_calc" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotal_calc" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotal_calc" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->calc(arg2,arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_hasSigmaTot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotal_hasSigmaTot",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_hasSigmaTot" "', argument " "1"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  result = (bool)(arg1)->hasSigmaTot();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_sigmaTot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotal_sigmaTot",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_sigmaTot" "', argument " "1"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  result = (double)(arg1)->sigmaTot();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_rho(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotal_rho",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_rho" "', argument " "1"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  result = (double)(arg1)->rho();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_sigmaEl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotal_sigmaEl",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_sigmaEl" "', argument " "1"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  result = (double)(arg1)->sigmaEl();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_bElIsExp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotal_bElIsExp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_bElIsExp" "', argument " "1"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  result = (bool)(arg1)->bElIsExp();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_bSlopeEl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotal_bSlopeEl",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_bSlopeEl" "', argument " "1"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  result = (double)(arg1)->bSlopeEl();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_hasCoulomb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotal_hasCoulomb",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_hasCoulomb" "', argument " "1"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  result = (bool)(arg1)->hasCoulomb();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_dsigmaEl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  double arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaTotal_dsigmaEl",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_dsigmaEl" "', argument " "1"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotal_dsigmaEl" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotal_dsigmaEl" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotal_dsigmaEl" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (double)(arg1)->dsigmaEl(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_dsigmaEl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  double arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaTotal_dsigmaEl",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_dsigmaEl" "', argument " "1"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotal_dsigmaEl" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotal_dsigmaEl" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (double)(arg1)->dsigmaEl(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_dsigmaEl__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaTotal_dsigmaEl",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_dsigmaEl" "', argument " "1"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotal_dsigmaEl" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->dsigmaEl(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_dsigmaEl(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotal, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SigmaTotal_dsigmaEl__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotal, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SigmaTotal_dsigmaEl__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotal, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SigmaTotal_dsigmaEl__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaTotal_dsigmaEl'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaTotal::dsigmaEl(double,bool,bool)\n"
    "    Pythia8::SigmaTotal::dsigmaEl(double,bool)\n"
    "    Pythia8::SigmaTotal::dsigmaEl(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_sigmaXB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotal_sigmaXB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_sigmaXB" "', argument " "1"" of type '" "Pythia8::SigmaTotal const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  result = (double)((Pythia8::SigmaTotal const *)arg1)->sigmaXB();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_sigmaAX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotal_sigmaAX",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_sigmaAX" "', argument " "1"" of type '" "Pythia8::SigmaTotal const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  result = (double)((Pythia8::SigmaTotal const *)arg1)->sigmaAX();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_sigmaXX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotal_sigmaXX",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_sigmaXX" "', argument " "1"" of type '" "Pythia8::SigmaTotal const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  result = (double)((Pythia8::SigmaTotal const *)arg1)->sigmaXX();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_sigmaAXB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotal_sigmaAXB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_sigmaAXB" "', argument " "1"" of type '" "Pythia8::SigmaTotal const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  result = (double)((Pythia8::SigmaTotal const *)arg1)->sigmaAXB();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_sigmaND(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotal_sigmaND",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_sigmaND" "', argument " "1"" of type '" "Pythia8::SigmaTotal const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  result = (double)((Pythia8::SigmaTotal const *)arg1)->sigmaND();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_dsigmaSD__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  double arg2 ;
  double arg3 ;
  bool arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaTotal_dsigmaSD",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_dsigmaSD" "', argument " "1"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotal_dsigmaSD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotal_dsigmaSD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotal_dsigmaSD" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaTotal_dsigmaSD" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (double)(arg1)->dsigmaSD(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_dsigmaSD__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  double arg2 ;
  double arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaTotal_dsigmaSD",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_dsigmaSD" "', argument " "1"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotal_dsigmaSD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotal_dsigmaSD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotal_dsigmaSD" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (double)(arg1)->dsigmaSD(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_dsigmaSD__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaTotal_dsigmaSD",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_dsigmaSD" "', argument " "1"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotal_dsigmaSD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotal_dsigmaSD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)(arg1)->dsigmaSD(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_dsigmaSD(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotal, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SigmaTotal_dsigmaSD__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotal, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SigmaTotal_dsigmaSD__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotal, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SigmaTotal_dsigmaSD__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaTotal_dsigmaSD'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaTotal::dsigmaSD(double,double,bool,int)\n"
    "    Pythia8::SigmaTotal::dsigmaSD(double,double,bool)\n"
    "    Pythia8::SigmaTotal::dsigmaSD(double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_splitDiff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotal_splitDiff",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_splitDiff" "', argument " "1"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  result = (bool)(arg1)->splitDiff();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_dsigmaDD__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaTotal_dsigmaDD",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_dsigmaDD" "', argument " "1"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotal_dsigmaDD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotal_dsigmaDD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotal_dsigmaDD" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaTotal_dsigmaDD" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (double)(arg1)->dsigmaDD(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_dsigmaDD__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaTotal_dsigmaDD",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_dsigmaDD" "', argument " "1"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotal_dsigmaDD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotal_dsigmaDD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotal_dsigmaDD" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->dsigmaDD(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_dsigmaDD(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotal, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SigmaTotal_dsigmaDD__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotal, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SigmaTotal_dsigmaDD__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaTotal_dsigmaDD'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaTotal::dsigmaDD(double,double,double,int)\n"
    "    Pythia8::SigmaTotal::dsigmaDD(double,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_dsigmaCD__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SigmaTotal_dsigmaCD",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_dsigmaCD" "', argument " "1"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotal_dsigmaCD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotal_dsigmaCD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotal_dsigmaCD" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaTotal_dsigmaCD" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaTotal_dsigmaCD" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (double)(arg1)->dsigmaCD(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_dsigmaCD__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaTotal_dsigmaCD",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_dsigmaCD" "', argument " "1"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotal_dsigmaCD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotal_dsigmaCD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotal_dsigmaCD" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaTotal_dsigmaCD" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)(arg1)->dsigmaCD(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_dsigmaCD(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotal, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SigmaTotal_dsigmaCD__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotal, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SigmaTotal_dsigmaCD__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaTotal_dsigmaCD'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaTotal::dsigmaCD(double,double,double,double,int)\n"
    "    Pythia8::SigmaTotal::dsigmaCD(double,double,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_mMinCD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotal_mMinCD",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_mMinCD" "', argument " "1"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  result = (double)(arg1)->mMinCD();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_tRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  SwigValueWrapper< std::pair< double,double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SigmaTotal_tRange",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_tRange" "', argument " "1"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotal_tRange" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotal_tRange" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotal_tRange" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaTotal_tRange" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaTotal_tRange" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (arg1)->tRange(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj((new std::pair< double,double >(static_cast< const std::pair< double,double >& >(result))), SWIGTYPE_p_std__pairT_double_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotal_tInRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotal *arg1 = (Pythia8::SigmaTotal *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:SigmaTotal_tInRange",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotal_tInRange" "', argument " "1"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotal * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotal_tInRange" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotal_tInRange" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotal_tInRange" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaTotal_tInRange" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaTotal_tInRange" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SigmaTotal_tInRange" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (bool)(arg1)->tInRange(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SigmaTotal_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SigmaTotal, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SigmaTotOwn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotOwn *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SigmaTotOwn")) SWIG_fail;
  result = (Pythia8::SigmaTotOwn *)new Pythia8::SigmaTotOwn();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SigmaTotOwn, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotOwn_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotOwn *arg1 = (Pythia8::SigmaTotOwn *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaTotOwn_init",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotOwn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotOwn_init" "', argument " "1"" of type '" "Pythia8::SigmaTotOwn *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotOwn * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaTotOwn_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SigmaTotOwn_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaTotOwn_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SigmaTotOwn_init" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SigmaTotOwn_init" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  (arg1)->init(arg2,*arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotOwn_calcTotEl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotOwn *arg1 = (Pythia8::SigmaTotOwn *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SigmaTotOwn_calcTotEl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotOwn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotOwn_calcTotEl" "', argument " "1"" of type '" "Pythia8::SigmaTotOwn *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotOwn * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotOwn_calcTotEl" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotOwn_calcTotEl" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotOwn_calcTotEl" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaTotOwn_calcTotEl" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaTotOwn_calcTotEl" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (bool)(arg1)->calcTotEl(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotOwn_dsigmaEl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotOwn *arg1 = (Pythia8::SigmaTotOwn *) 0 ;
  double arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaTotOwn_dsigmaEl",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotOwn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotOwn_dsigmaEl" "', argument " "1"" of type '" "Pythia8::SigmaTotOwn *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotOwn * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotOwn_dsigmaEl" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotOwn_dsigmaEl" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotOwn_dsigmaEl" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (double)(arg1)->dsigmaEl(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotOwn_dsigmaEl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotOwn *arg1 = (Pythia8::SigmaTotOwn *) 0 ;
  double arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaTotOwn_dsigmaEl",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotOwn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotOwn_dsigmaEl" "', argument " "1"" of type '" "Pythia8::SigmaTotOwn *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotOwn * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotOwn_dsigmaEl" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotOwn_dsigmaEl" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (double)(arg1)->dsigmaEl(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotOwn_dsigmaEl__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotOwn *arg1 = (Pythia8::SigmaTotOwn *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaTotOwn_dsigmaEl",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotOwn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotOwn_dsigmaEl" "', argument " "1"" of type '" "Pythia8::SigmaTotOwn *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotOwn * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotOwn_dsigmaEl" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->dsigmaEl(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotOwn_dsigmaEl(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotOwn, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SigmaTotOwn_dsigmaEl__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotOwn, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SigmaTotOwn_dsigmaEl__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotOwn, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SigmaTotOwn_dsigmaEl__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaTotOwn_dsigmaEl'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaTotOwn::dsigmaEl(double,bool,bool)\n"
    "    Pythia8::SigmaTotOwn::dsigmaEl(double,bool)\n"
    "    Pythia8::SigmaTotOwn::dsigmaEl(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaTotOwn_calcDiff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotOwn *arg1 = (Pythia8::SigmaTotOwn *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SigmaTotOwn_calcDiff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotOwn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotOwn_calcDiff" "', argument " "1"" of type '" "Pythia8::SigmaTotOwn *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotOwn * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotOwn_calcDiff" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotOwn_calcDiff" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotOwn_calcDiff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaTotOwn_calcDiff" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaTotOwn_calcDiff" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (bool)(arg1)->calcDiff(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotOwn_dsigmaSD__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotOwn *arg1 = (Pythia8::SigmaTotOwn *) 0 ;
  double arg2 ;
  double arg3 ;
  bool arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaTotOwn_dsigmaSD",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotOwn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotOwn_dsigmaSD" "', argument " "1"" of type '" "Pythia8::SigmaTotOwn *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotOwn * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotOwn_dsigmaSD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotOwn_dsigmaSD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotOwn_dsigmaSD" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaTotOwn_dsigmaSD" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (double)(arg1)->dsigmaSD(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotOwn_dsigmaSD__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotOwn *arg1 = (Pythia8::SigmaTotOwn *) 0 ;
  double arg2 ;
  double arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaTotOwn_dsigmaSD",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotOwn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotOwn_dsigmaSD" "', argument " "1"" of type '" "Pythia8::SigmaTotOwn *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotOwn * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotOwn_dsigmaSD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotOwn_dsigmaSD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotOwn_dsigmaSD" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (double)(arg1)->dsigmaSD(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotOwn_dsigmaSD__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotOwn *arg1 = (Pythia8::SigmaTotOwn *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaTotOwn_dsigmaSD",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotOwn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotOwn_dsigmaSD" "', argument " "1"" of type '" "Pythia8::SigmaTotOwn *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotOwn * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotOwn_dsigmaSD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotOwn_dsigmaSD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)(arg1)->dsigmaSD(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotOwn_dsigmaSD(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotOwn, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SigmaTotOwn_dsigmaSD__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotOwn, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SigmaTotOwn_dsigmaSD__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotOwn, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SigmaTotOwn_dsigmaSD__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaTotOwn_dsigmaSD'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaTotOwn::dsigmaSD(double,double,bool,int)\n"
    "    Pythia8::SigmaTotOwn::dsigmaSD(double,double,bool)\n"
    "    Pythia8::SigmaTotOwn::dsigmaSD(double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaTotOwn_dsigmaDD__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotOwn *arg1 = (Pythia8::SigmaTotOwn *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaTotOwn_dsigmaDD",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotOwn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotOwn_dsigmaDD" "', argument " "1"" of type '" "Pythia8::SigmaTotOwn *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotOwn * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotOwn_dsigmaDD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotOwn_dsigmaDD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotOwn_dsigmaDD" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaTotOwn_dsigmaDD" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (double)(arg1)->dsigmaDD(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotOwn_dsigmaDD__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotOwn *arg1 = (Pythia8::SigmaTotOwn *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaTotOwn_dsigmaDD",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotOwn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotOwn_dsigmaDD" "', argument " "1"" of type '" "Pythia8::SigmaTotOwn *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotOwn * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotOwn_dsigmaDD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotOwn_dsigmaDD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotOwn_dsigmaDD" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->dsigmaDD(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotOwn_dsigmaDD(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotOwn, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SigmaTotOwn_dsigmaDD__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotOwn, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SigmaTotOwn_dsigmaDD__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaTotOwn_dsigmaDD'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaTotOwn::dsigmaDD(double,double,double,int)\n"
    "    Pythia8::SigmaTotOwn::dsigmaDD(double,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaTotOwn_dsigmaCD__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotOwn *arg1 = (Pythia8::SigmaTotOwn *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SigmaTotOwn_dsigmaCD",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotOwn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotOwn_dsigmaCD" "', argument " "1"" of type '" "Pythia8::SigmaTotOwn *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotOwn * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotOwn_dsigmaCD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotOwn_dsigmaCD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotOwn_dsigmaCD" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaTotOwn_dsigmaCD" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaTotOwn_dsigmaCD" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (double)(arg1)->dsigmaCD(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotOwn_dsigmaCD__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotOwn *arg1 = (Pythia8::SigmaTotOwn *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaTotOwn_dsigmaCD",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotOwn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotOwn_dsigmaCD" "', argument " "1"" of type '" "Pythia8::SigmaTotOwn *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotOwn * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaTotOwn_dsigmaCD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaTotOwn_dsigmaCD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaTotOwn_dsigmaCD" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaTotOwn_dsigmaCD" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)(arg1)->dsigmaCD(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaTotOwn_dsigmaCD(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotOwn, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SigmaTotOwn_dsigmaCD__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaTotOwn, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SigmaTotOwn_dsigmaCD__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaTotOwn_dsigmaCD'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaTotOwn::dsigmaCD(double,double,double,double,int)\n"
    "    Pythia8::SigmaTotOwn::dsigmaCD(double,double,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaTotOwn_mMinCD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotOwn *arg1 = (Pythia8::SigmaTotOwn *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaTotOwn_mMinCD",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotOwn, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaTotOwn_mMinCD" "', argument " "1"" of type '" "Pythia8::SigmaTotOwn *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotOwn * >(argp1);
  result = (double)(arg1)->mMinCD();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SigmaTotOwn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaTotOwn *arg1 = (Pythia8::SigmaTotOwn *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SigmaTotOwn",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaTotOwn, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SigmaTotOwn" "', argument " "1"" of type '" "Pythia8::SigmaTotOwn *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaTotOwn * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SigmaTotOwn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SigmaTotOwn, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SigmaSaSDL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaSaSDL *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SigmaSaSDL")) SWIG_fail;
  result = (Pythia8::SigmaSaSDL *)new Pythia8::SigmaSaSDL();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SigmaSaSDL, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaSaSDL_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaSaSDL *arg1 = (Pythia8::SigmaSaSDL *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaSaSDL_init",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaSaSDL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaSaSDL_init" "', argument " "1"" of type '" "Pythia8::SigmaSaSDL *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaSaSDL * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaSaSDL_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SigmaSaSDL_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaSaSDL_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SigmaSaSDL_init" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SigmaSaSDL_init" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  (arg1)->init(arg2,*arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaSaSDL_calcTotEl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaSaSDL *arg1 = (Pythia8::SigmaSaSDL *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SigmaSaSDL_calcTotEl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaSaSDL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaSaSDL_calcTotEl" "', argument " "1"" of type '" "Pythia8::SigmaSaSDL *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaSaSDL * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaSaSDL_calcTotEl" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaSaSDL_calcTotEl" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaSaSDL_calcTotEl" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaSaSDL_calcTotEl" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaSaSDL_calcTotEl" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (bool)(arg1)->calcTotEl(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaSaSDL_dsigmaEl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaSaSDL *arg1 = (Pythia8::SigmaSaSDL *) 0 ;
  double arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaSaSDL_dsigmaEl",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaSaSDL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaSaSDL_dsigmaEl" "', argument " "1"" of type '" "Pythia8::SigmaSaSDL *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaSaSDL * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaSaSDL_dsigmaEl" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaSaSDL_dsigmaEl" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaSaSDL_dsigmaEl" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (double)(arg1)->dsigmaEl(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaSaSDL_dsigmaEl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaSaSDL *arg1 = (Pythia8::SigmaSaSDL *) 0 ;
  double arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaSaSDL_dsigmaEl",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaSaSDL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaSaSDL_dsigmaEl" "', argument " "1"" of type '" "Pythia8::SigmaSaSDL *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaSaSDL * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaSaSDL_dsigmaEl" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaSaSDL_dsigmaEl" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (double)(arg1)->dsigmaEl(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaSaSDL_dsigmaEl__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaSaSDL *arg1 = (Pythia8::SigmaSaSDL *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaSaSDL_dsigmaEl",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaSaSDL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaSaSDL_dsigmaEl" "', argument " "1"" of type '" "Pythia8::SigmaSaSDL *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaSaSDL * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaSaSDL_dsigmaEl" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->dsigmaEl(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaSaSDL_dsigmaEl(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaSaSDL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SigmaSaSDL_dsigmaEl__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaSaSDL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SigmaSaSDL_dsigmaEl__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaSaSDL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SigmaSaSDL_dsigmaEl__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaSaSDL_dsigmaEl'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaSaSDL::dsigmaEl(double,bool,bool)\n"
    "    Pythia8::SigmaSaSDL::dsigmaEl(double,bool)\n"
    "    Pythia8::SigmaSaSDL::dsigmaEl(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaSaSDL_calcDiff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaSaSDL *arg1 = (Pythia8::SigmaSaSDL *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SigmaSaSDL_calcDiff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaSaSDL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaSaSDL_calcDiff" "', argument " "1"" of type '" "Pythia8::SigmaSaSDL *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaSaSDL * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaSaSDL_calcDiff" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaSaSDL_calcDiff" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaSaSDL_calcDiff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaSaSDL_calcDiff" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaSaSDL_calcDiff" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (bool)(arg1)->calcDiff(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaSaSDL_dsigmaSD__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaSaSDL *arg1 = (Pythia8::SigmaSaSDL *) 0 ;
  double arg2 ;
  double arg3 ;
  bool arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaSaSDL_dsigmaSD",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaSaSDL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaSaSDL_dsigmaSD" "', argument " "1"" of type '" "Pythia8::SigmaSaSDL *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaSaSDL * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaSaSDL_dsigmaSD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaSaSDL_dsigmaSD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaSaSDL_dsigmaSD" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaSaSDL_dsigmaSD" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (double)(arg1)->dsigmaSD(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaSaSDL_dsigmaSD__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaSaSDL *arg1 = (Pythia8::SigmaSaSDL *) 0 ;
  double arg2 ;
  double arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaSaSDL_dsigmaSD",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaSaSDL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaSaSDL_dsigmaSD" "', argument " "1"" of type '" "Pythia8::SigmaSaSDL *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaSaSDL * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaSaSDL_dsigmaSD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaSaSDL_dsigmaSD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaSaSDL_dsigmaSD" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (double)(arg1)->dsigmaSD(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaSaSDL_dsigmaSD(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaSaSDL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SigmaSaSDL_dsigmaSD__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaSaSDL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SigmaSaSDL_dsigmaSD__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaSaSDL_dsigmaSD'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaSaSDL::dsigmaSD(double,double,bool,int)\n"
    "    Pythia8::SigmaSaSDL::dsigmaSD(double,double,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaSaSDL_dsigmaDD__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaSaSDL *arg1 = (Pythia8::SigmaSaSDL *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaSaSDL_dsigmaDD",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaSaSDL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaSaSDL_dsigmaDD" "', argument " "1"" of type '" "Pythia8::SigmaSaSDL *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaSaSDL * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaSaSDL_dsigmaDD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaSaSDL_dsigmaDD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaSaSDL_dsigmaDD" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaSaSDL_dsigmaDD" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (double)(arg1)->dsigmaDD(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaSaSDL_dsigmaDD__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaSaSDL *arg1 = (Pythia8::SigmaSaSDL *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaSaSDL_dsigmaDD",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaSaSDL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaSaSDL_dsigmaDD" "', argument " "1"" of type '" "Pythia8::SigmaSaSDL *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaSaSDL * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaSaSDL_dsigmaDD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaSaSDL_dsigmaDD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaSaSDL_dsigmaDD" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->dsigmaDD(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaSaSDL_dsigmaDD(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaSaSDL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SigmaSaSDL_dsigmaDD__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaSaSDL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SigmaSaSDL_dsigmaDD__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaSaSDL_dsigmaDD'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaSaSDL::dsigmaDD(double,double,double,int)\n"
    "    Pythia8::SigmaSaSDL::dsigmaDD(double,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaSaSDL_dsigmaCD__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaSaSDL *arg1 = (Pythia8::SigmaSaSDL *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SigmaSaSDL_dsigmaCD",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaSaSDL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaSaSDL_dsigmaCD" "', argument " "1"" of type '" "Pythia8::SigmaSaSDL *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaSaSDL * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaSaSDL_dsigmaCD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaSaSDL_dsigmaCD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaSaSDL_dsigmaCD" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaSaSDL_dsigmaCD" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaSaSDL_dsigmaCD" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (double)(arg1)->dsigmaCD(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaSaSDL_dsigmaCD__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaSaSDL *arg1 = (Pythia8::SigmaSaSDL *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaSaSDL_dsigmaCD",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaSaSDL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaSaSDL_dsigmaCD" "', argument " "1"" of type '" "Pythia8::SigmaSaSDL *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaSaSDL * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaSaSDL_dsigmaCD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaSaSDL_dsigmaCD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaSaSDL_dsigmaCD" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaSaSDL_dsigmaCD" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)(arg1)->dsigmaCD(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaSaSDL_dsigmaCD(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaSaSDL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SigmaSaSDL_dsigmaCD__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaSaSDL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SigmaSaSDL_dsigmaCD__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaSaSDL_dsigmaCD'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaSaSDL::dsigmaCD(double,double,double,double,int)\n"
    "    Pythia8::SigmaSaSDL::dsigmaCD(double,double,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaSaSDL_mMinCD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaSaSDL *arg1 = (Pythia8::SigmaSaSDL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaSaSDL_mMinCD",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaSaSDL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaSaSDL_mMinCD" "', argument " "1"" of type '" "Pythia8::SigmaSaSDL *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaSaSDL * >(argp1);
  result = (double)(arg1)->mMinCD();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SigmaSaSDL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaSaSDL *arg1 = (Pythia8::SigmaSaSDL *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SigmaSaSDL",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaSaSDL, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SigmaSaSDL" "', argument " "1"" of type '" "Pythia8::SigmaSaSDL *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaSaSDL * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SigmaSaSDL_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SigmaSaSDL, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SigmaMBR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMBR *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SigmaMBR")) SWIG_fail;
  result = (Pythia8::SigmaMBR *)new Pythia8::SigmaMBR();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SigmaMBR, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaMBR_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMBR *arg1 = (Pythia8::SigmaMBR *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaMBR_init",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMBR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaMBR_init" "', argument " "1"" of type '" "Pythia8::SigmaMBR *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMBR * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaMBR_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SigmaMBR_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaMBR_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SigmaMBR_init" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SigmaMBR_init" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  (arg1)->init(arg2,*arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaMBR_calcTotEl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMBR *arg1 = (Pythia8::SigmaMBR *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SigmaMBR_calcTotEl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMBR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaMBR_calcTotEl" "', argument " "1"" of type '" "Pythia8::SigmaMBR *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMBR * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaMBR_calcTotEl" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaMBR_calcTotEl" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaMBR_calcTotEl" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaMBR_calcTotEl" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaMBR_calcTotEl" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (bool)(arg1)->calcTotEl(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaMBR_dsigmaEl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMBR *arg1 = (Pythia8::SigmaMBR *) 0 ;
  double arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaMBR_dsigmaEl",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMBR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaMBR_dsigmaEl" "', argument " "1"" of type '" "Pythia8::SigmaMBR *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMBR * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaMBR_dsigmaEl" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaMBR_dsigmaEl" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaMBR_dsigmaEl" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (double)(arg1)->dsigmaEl(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaMBR_dsigmaEl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMBR *arg1 = (Pythia8::SigmaMBR *) 0 ;
  double arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaMBR_dsigmaEl",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMBR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaMBR_dsigmaEl" "', argument " "1"" of type '" "Pythia8::SigmaMBR *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMBR * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaMBR_dsigmaEl" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaMBR_dsigmaEl" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (double)(arg1)->dsigmaEl(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaMBR_dsigmaEl__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMBR *arg1 = (Pythia8::SigmaMBR *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaMBR_dsigmaEl",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMBR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaMBR_dsigmaEl" "', argument " "1"" of type '" "Pythia8::SigmaMBR *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMBR * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaMBR_dsigmaEl" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->dsigmaEl(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaMBR_dsigmaEl(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaMBR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SigmaMBR_dsigmaEl__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaMBR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SigmaMBR_dsigmaEl__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaMBR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SigmaMBR_dsigmaEl__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaMBR_dsigmaEl'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaMBR::dsigmaEl(double,bool,bool)\n"
    "    Pythia8::SigmaMBR::dsigmaEl(double,bool)\n"
    "    Pythia8::SigmaMBR::dsigmaEl(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaMBR_calcDiff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMBR *arg1 = (Pythia8::SigmaMBR *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SigmaMBR_calcDiff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMBR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaMBR_calcDiff" "', argument " "1"" of type '" "Pythia8::SigmaMBR *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMBR * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaMBR_calcDiff" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaMBR_calcDiff" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaMBR_calcDiff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaMBR_calcDiff" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaMBR_calcDiff" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (bool)(arg1)->calcDiff(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaMBR_splitDiff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMBR *arg1 = (Pythia8::SigmaMBR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaMBR_splitDiff",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMBR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaMBR_splitDiff" "', argument " "1"" of type '" "Pythia8::SigmaMBR *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMBR * >(argp1);
  result = (bool)(arg1)->splitDiff();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaMBR_dsigmaSD__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMBR *arg1 = (Pythia8::SigmaMBR *) 0 ;
  double arg2 ;
  double arg3 ;
  bool arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaMBR_dsigmaSD",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMBR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaMBR_dsigmaSD" "', argument " "1"" of type '" "Pythia8::SigmaMBR *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMBR * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaMBR_dsigmaSD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaMBR_dsigmaSD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaMBR_dsigmaSD" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaMBR_dsigmaSD" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (double)(arg1)->dsigmaSD(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaMBR_dsigmaSD__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMBR *arg1 = (Pythia8::SigmaMBR *) 0 ;
  double arg2 ;
  double arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaMBR_dsigmaSD",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMBR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaMBR_dsigmaSD" "', argument " "1"" of type '" "Pythia8::SigmaMBR *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMBR * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaMBR_dsigmaSD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaMBR_dsigmaSD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaMBR_dsigmaSD" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (double)(arg1)->dsigmaSD(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaMBR_dsigmaSD__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMBR *arg1 = (Pythia8::SigmaMBR *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaMBR_dsigmaSD",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMBR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaMBR_dsigmaSD" "', argument " "1"" of type '" "Pythia8::SigmaMBR *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMBR * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaMBR_dsigmaSD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaMBR_dsigmaSD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)(arg1)->dsigmaSD(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaMBR_dsigmaSD(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaMBR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SigmaMBR_dsigmaSD__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaMBR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SigmaMBR_dsigmaSD__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaMBR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SigmaMBR_dsigmaSD__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaMBR_dsigmaSD'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaMBR::dsigmaSD(double,double,bool,int)\n"
    "    Pythia8::SigmaMBR::dsigmaSD(double,double,bool)\n"
    "    Pythia8::SigmaMBR::dsigmaSD(double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaMBR_dsigmaDD__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMBR *arg1 = (Pythia8::SigmaMBR *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaMBR_dsigmaDD",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMBR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaMBR_dsigmaDD" "', argument " "1"" of type '" "Pythia8::SigmaMBR *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMBR * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaMBR_dsigmaDD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaMBR_dsigmaDD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaMBR_dsigmaDD" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaMBR_dsigmaDD" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (double)(arg1)->dsigmaDD(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaMBR_dsigmaDD__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMBR *arg1 = (Pythia8::SigmaMBR *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaMBR_dsigmaDD",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMBR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaMBR_dsigmaDD" "', argument " "1"" of type '" "Pythia8::SigmaMBR *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMBR * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaMBR_dsigmaDD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaMBR_dsigmaDD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaMBR_dsigmaDD" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->dsigmaDD(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaMBR_dsigmaDD(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaMBR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SigmaMBR_dsigmaDD__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaMBR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SigmaMBR_dsigmaDD__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaMBR_dsigmaDD'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaMBR::dsigmaDD(double,double,double,int)\n"
    "    Pythia8::SigmaMBR::dsigmaDD(double,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaMBR_dsigmaCD__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMBR *arg1 = (Pythia8::SigmaMBR *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SigmaMBR_dsigmaCD",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMBR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaMBR_dsigmaCD" "', argument " "1"" of type '" "Pythia8::SigmaMBR *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMBR * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaMBR_dsigmaCD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaMBR_dsigmaCD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaMBR_dsigmaCD" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaMBR_dsigmaCD" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaMBR_dsigmaCD" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (double)(arg1)->dsigmaCD(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaMBR_dsigmaCD__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMBR *arg1 = (Pythia8::SigmaMBR *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaMBR_dsigmaCD",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMBR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaMBR_dsigmaCD" "', argument " "1"" of type '" "Pythia8::SigmaMBR *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMBR * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaMBR_dsigmaCD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaMBR_dsigmaCD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaMBR_dsigmaCD" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaMBR_dsigmaCD" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)(arg1)->dsigmaCD(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaMBR_dsigmaCD(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaMBR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SigmaMBR_dsigmaCD__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaMBR, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SigmaMBR_dsigmaCD__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaMBR_dsigmaCD'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaMBR::dsigmaCD(double,double,double,double,int)\n"
    "    Pythia8::SigmaMBR::dsigmaCD(double,double,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaMBR_mMinCD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMBR *arg1 = (Pythia8::SigmaMBR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaMBR_mMinCD",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMBR, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaMBR_mMinCD" "', argument " "1"" of type '" "Pythia8::SigmaMBR *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMBR * >(argp1);
  result = (double)(arg1)->mMinCD();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SigmaMBR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMBR *arg1 = (Pythia8::SigmaMBR *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SigmaMBR",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMBR, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SigmaMBR" "', argument " "1"" of type '" "Pythia8::SigmaMBR *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMBR * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SigmaMBR_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SigmaMBR, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SigmaABMST(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaABMST *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SigmaABMST")) SWIG_fail;
  result = (Pythia8::SigmaABMST *)new Pythia8::SigmaABMST();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SigmaABMST, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaABMST_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaABMST *arg1 = (Pythia8::SigmaABMST *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaABMST_init",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaABMST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaABMST_init" "', argument " "1"" of type '" "Pythia8::SigmaABMST *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaABMST * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaABMST_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SigmaABMST_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaABMST_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SigmaABMST_init" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SigmaABMST_init" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  (arg1)->init(arg2,*arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaABMST_calcTotEl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaABMST *arg1 = (Pythia8::SigmaABMST *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SigmaABMST_calcTotEl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaABMST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaABMST_calcTotEl" "', argument " "1"" of type '" "Pythia8::SigmaABMST *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaABMST * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaABMST_calcTotEl" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaABMST_calcTotEl" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaABMST_calcTotEl" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaABMST_calcTotEl" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaABMST_calcTotEl" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (bool)(arg1)->calcTotEl(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaABMST_dsigmaEl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaABMST *arg1 = (Pythia8::SigmaABMST *) 0 ;
  double arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaABMST_dsigmaEl",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaABMST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaABMST_dsigmaEl" "', argument " "1"" of type '" "Pythia8::SigmaABMST *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaABMST * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaABMST_dsigmaEl" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaABMST_dsigmaEl" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaABMST_dsigmaEl" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (double)(arg1)->dsigmaEl(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaABMST_dsigmaEl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaABMST *arg1 = (Pythia8::SigmaABMST *) 0 ;
  double arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaABMST_dsigmaEl",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaABMST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaABMST_dsigmaEl" "', argument " "1"" of type '" "Pythia8::SigmaABMST *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaABMST * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaABMST_dsigmaEl" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaABMST_dsigmaEl" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (double)(arg1)->dsigmaEl(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaABMST_dsigmaEl__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaABMST *arg1 = (Pythia8::SigmaABMST *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaABMST_dsigmaEl",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaABMST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaABMST_dsigmaEl" "', argument " "1"" of type '" "Pythia8::SigmaABMST *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaABMST * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaABMST_dsigmaEl" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->dsigmaEl(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaABMST_dsigmaEl(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaABMST, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SigmaABMST_dsigmaEl__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaABMST, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SigmaABMST_dsigmaEl__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaABMST, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SigmaABMST_dsigmaEl__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaABMST_dsigmaEl'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaABMST::dsigmaEl(double,bool,bool)\n"
    "    Pythia8::SigmaABMST::dsigmaEl(double,bool)\n"
    "    Pythia8::SigmaABMST::dsigmaEl(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaABMST_calcDiff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaABMST *arg1 = (Pythia8::SigmaABMST *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SigmaABMST_calcDiff",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaABMST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaABMST_calcDiff" "', argument " "1"" of type '" "Pythia8::SigmaABMST *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaABMST * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaABMST_calcDiff" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaABMST_calcDiff" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaABMST_calcDiff" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaABMST_calcDiff" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaABMST_calcDiff" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (bool)(arg1)->calcDiff(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaABMST_dsigmaSD__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaABMST *arg1 = (Pythia8::SigmaABMST *) 0 ;
  double arg2 ;
  double arg3 ;
  bool arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaABMST_dsigmaSD",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaABMST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaABMST_dsigmaSD" "', argument " "1"" of type '" "Pythia8::SigmaABMST *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaABMST * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaABMST_dsigmaSD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaABMST_dsigmaSD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaABMST_dsigmaSD" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaABMST_dsigmaSD" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (double)(arg1)->dsigmaSD(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaABMST_dsigmaSD__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaABMST *arg1 = (Pythia8::SigmaABMST *) 0 ;
  double arg2 ;
  double arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaABMST_dsigmaSD",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaABMST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaABMST_dsigmaSD" "', argument " "1"" of type '" "Pythia8::SigmaABMST *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaABMST * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaABMST_dsigmaSD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaABMST_dsigmaSD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaABMST_dsigmaSD" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (double)(arg1)->dsigmaSD(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaABMST_dsigmaSD__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaABMST *arg1 = (Pythia8::SigmaABMST *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaABMST_dsigmaSD",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaABMST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaABMST_dsigmaSD" "', argument " "1"" of type '" "Pythia8::SigmaABMST *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaABMST * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaABMST_dsigmaSD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaABMST_dsigmaSD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)(arg1)->dsigmaSD(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaABMST_dsigmaSD(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaABMST, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SigmaABMST_dsigmaSD__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaABMST, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SigmaABMST_dsigmaSD__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaABMST, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SigmaABMST_dsigmaSD__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaABMST_dsigmaSD'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaABMST::dsigmaSD(double,double,bool,int)\n"
    "    Pythia8::SigmaABMST::dsigmaSD(double,double,bool)\n"
    "    Pythia8::SigmaABMST::dsigmaSD(double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaABMST_dsigmaDD__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaABMST *arg1 = (Pythia8::SigmaABMST *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaABMST_dsigmaDD",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaABMST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaABMST_dsigmaDD" "', argument " "1"" of type '" "Pythia8::SigmaABMST *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaABMST * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaABMST_dsigmaDD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaABMST_dsigmaDD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaABMST_dsigmaDD" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaABMST_dsigmaDD" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (double)(arg1)->dsigmaDD(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaABMST_dsigmaDD__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaABMST *arg1 = (Pythia8::SigmaABMST *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaABMST_dsigmaDD",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaABMST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaABMST_dsigmaDD" "', argument " "1"" of type '" "Pythia8::SigmaABMST *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaABMST * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaABMST_dsigmaDD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaABMST_dsigmaDD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaABMST_dsigmaDD" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->dsigmaDD(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaABMST_dsigmaDD(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaABMST, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SigmaABMST_dsigmaDD__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaABMST, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SigmaABMST_dsigmaDD__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaABMST_dsigmaDD'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaABMST::dsigmaDD(double,double,double,int)\n"
    "    Pythia8::SigmaABMST::dsigmaDD(double,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaABMST_dsigmaCD__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaABMST *arg1 = (Pythia8::SigmaABMST *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SigmaABMST_dsigmaCD",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaABMST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaABMST_dsigmaCD" "', argument " "1"" of type '" "Pythia8::SigmaABMST *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaABMST * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaABMST_dsigmaCD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaABMST_dsigmaCD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaABMST_dsigmaCD" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaABMST_dsigmaCD" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaABMST_dsigmaCD" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (double)(arg1)->dsigmaCD(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaABMST_dsigmaCD__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaABMST *arg1 = (Pythia8::SigmaABMST *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaABMST_dsigmaCD",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaABMST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaABMST_dsigmaCD" "', argument " "1"" of type '" "Pythia8::SigmaABMST *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaABMST * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaABMST_dsigmaCD" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaABMST_dsigmaCD" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaABMST_dsigmaCD" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaABMST_dsigmaCD" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)(arg1)->dsigmaCD(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaABMST_dsigmaCD(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaABMST, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SigmaABMST_dsigmaCD__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaABMST, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SigmaABMST_dsigmaCD__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaABMST_dsigmaCD'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaABMST::dsigmaCD(double,double,double,double,int)\n"
    "    Pythia8::SigmaABMST::dsigmaCD(double,double,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaABMST_mMinCD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaABMST *arg1 = (Pythia8::SigmaABMST *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaABMST_mMinCD",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaABMST, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaABMST_mMinCD" "', argument " "1"" of type '" "Pythia8::SigmaABMST *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaABMST * >(argp1);
  result = (double)(arg1)->mMinCD();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SigmaABMST(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaABMST *arg1 = (Pythia8::SigmaABMST *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SigmaABMST",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaABMST, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SigmaABMST" "', argument " "1"" of type '" "Pythia8::SigmaABMST *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaABMST * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SigmaABMST_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SigmaABMST, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SigmaRPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaRPP *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SigmaRPP")) SWIG_fail;
  result = (Pythia8::SigmaRPP *)new Pythia8::SigmaRPP();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SigmaRPP, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaRPP_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaRPP *arg1 = (Pythia8::SigmaRPP *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaRPP_init",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaRPP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaRPP_init" "', argument " "1"" of type '" "Pythia8::SigmaRPP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaRPP * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaRPP_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SigmaRPP_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaRPP_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SigmaRPP_init" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SigmaRPP_init" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  (arg1)->init(arg2,*arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaRPP_calcTotEl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaRPP *arg1 = (Pythia8::SigmaRPP *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SigmaRPP_calcTotEl",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaRPP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaRPP_calcTotEl" "', argument " "1"" of type '" "Pythia8::SigmaRPP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaRPP * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaRPP_calcTotEl" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaRPP_calcTotEl" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaRPP_calcTotEl" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaRPP_calcTotEl" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaRPP_calcTotEl" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (bool)(arg1)->calcTotEl(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaRPP_dsigmaEl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaRPP *arg1 = (Pythia8::SigmaRPP *) 0 ;
  double arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaRPP_dsigmaEl",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaRPP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaRPP_dsigmaEl" "', argument " "1"" of type '" "Pythia8::SigmaRPP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaRPP * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaRPP_dsigmaEl" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaRPP_dsigmaEl" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaRPP_dsigmaEl" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (double)(arg1)->dsigmaEl(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaRPP_dsigmaEl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaRPP *arg1 = (Pythia8::SigmaRPP *) 0 ;
  double arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaRPP_dsigmaEl",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaRPP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaRPP_dsigmaEl" "', argument " "1"" of type '" "Pythia8::SigmaRPP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaRPP * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaRPP_dsigmaEl" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaRPP_dsigmaEl" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (double)(arg1)->dsigmaEl(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaRPP_dsigmaEl__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaRPP *arg1 = (Pythia8::SigmaRPP *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaRPP_dsigmaEl",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaRPP, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaRPP_dsigmaEl" "', argument " "1"" of type '" "Pythia8::SigmaRPP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaRPP * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaRPP_dsigmaEl" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->dsigmaEl(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaRPP_dsigmaEl(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaRPP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SigmaRPP_dsigmaEl__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaRPP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SigmaRPP_dsigmaEl__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaRPP, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SigmaRPP_dsigmaEl__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaRPP_dsigmaEl'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaRPP::dsigmaEl(double,bool,bool)\n"
    "    Pythia8::SigmaRPP::dsigmaEl(double,bool)\n"
    "    Pythia8::SigmaRPP::dsigmaEl(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SigmaRPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaRPP *arg1 = (Pythia8::SigmaRPP *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SigmaRPP",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaRPP, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SigmaRPP" "', argument " "1"" of type '" "Pythia8::SigmaRPP *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaRPP * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SigmaRPP_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SigmaRPP, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SLHAinterface(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SLHAinterface *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SLHAinterface")) SWIG_fail;
  result = (Pythia8::SLHAinterface *)new Pythia8::SLHAinterface();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SLHAinterface, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLHAinterface_setPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SLHAinterface *arg1 = (Pythia8::SLHAinterface *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SLHAinterface_setPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SLHAinterface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLHAinterface_setPtr" "', argument " "1"" of type '" "Pythia8::SLHAinterface *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SLHAinterface * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLHAinterface_setPtr" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  (arg1)->setPtr(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLHAinterface_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SLHAinterface *arg1 = (Pythia8::SLHAinterface *) 0 ;
  Pythia8::Settings *arg2 = 0 ;
  Pythia8::Rndm *arg3 = (Pythia8::Rndm *) 0 ;
  Pythia8::Couplings *arg4 = (Pythia8::Couplings *) 0 ;
  Pythia8::ParticleData *arg5 = (Pythia8::ParticleData *) 0 ;
  bool *arg6 = 0 ;
  stringstream *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:SLHAinterface_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SLHAinterface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLHAinterface_init" "', argument " "1"" of type '" "Pythia8::SLHAinterface *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SLHAinterface * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLHAinterface_init" "', argument " "2"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLHAinterface_init" "', argument " "2"" of type '" "Pythia8::Settings &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLHAinterface_init" "', argument " "3"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Rndm * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLHAinterface_init" "', argument " "4"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Couplings * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SLHAinterface_init" "', argument " "5"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::ParticleData * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SLHAinterface_init" "', argument " "6"" of type '" "bool &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLHAinterface_init" "', argument " "6"" of type '" "bool &""'"); 
  }
  arg6 = reinterpret_cast< bool * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_stringstream,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SLHAinterface_init" "', argument " "7"" of type '" "stringstream &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLHAinterface_init" "', argument " "7"" of type '" "stringstream &""'"); 
  }
  arg7 = reinterpret_cast< stringstream * >(argp7);
  (arg1)->init(*arg2,arg3,arg4,arg5,*arg6,*arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLHAinterface_initSLHA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SLHAinterface *arg1 = (Pythia8::SLHAinterface *) 0 ;
  Pythia8::Settings *arg2 = 0 ;
  Pythia8::ParticleData *arg3 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SLHAinterface_initSLHA",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SLHAinterface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLHAinterface_initSLHA" "', argument " "1"" of type '" "Pythia8::SLHAinterface *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SLHAinterface * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLHAinterface_initSLHA" "', argument " "2"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLHAinterface_initSLHA" "', argument " "2"" of type '" "Pythia8::Settings &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLHAinterface_initSLHA" "', argument " "3"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ParticleData * >(argp3);
  result = (bool)(arg1)->initSLHA(*arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLHAinterface_pythia2slha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SLHAinterface *arg1 = (Pythia8::SLHAinterface *) 0 ;
  Pythia8::ParticleData *arg2 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SLHAinterface_pythia2slha",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SLHAinterface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLHAinterface_pythia2slha" "', argument " "1"" of type '" "Pythia8::SLHAinterface *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SLHAinterface * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLHAinterface_pythia2slha" "', argument " "2"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ParticleData * >(argp2);
  (arg1)->pythia2slha(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLHAinterface_slha_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SLHAinterface *arg1 = (Pythia8::SLHAinterface *) 0 ;
  Pythia8::SusyLesHouches *arg2 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SLHAinterface_slha_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SLHAinterface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLHAinterface_slha_set" "', argument " "1"" of type '" "Pythia8::SLHAinterface *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SLHAinterface * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLHAinterface_slha_set" "', argument " "2"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp2);
  if (arg1) (arg1)->slha = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLHAinterface_slha_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SLHAinterface *arg1 = (Pythia8::SLHAinterface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::SusyLesHouches *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SLHAinterface_slha_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SLHAinterface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLHAinterface_slha_get" "', argument " "1"" of type '" "Pythia8::SLHAinterface *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SLHAinterface * >(argp1);
  result = (Pythia8::SusyLesHouches *)& ((arg1)->slha);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLHAinterface_coupSUSY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SLHAinterface *arg1 = (Pythia8::SLHAinterface *) 0 ;
  Pythia8::CoupSUSY *arg2 = (Pythia8::CoupSUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SLHAinterface_coupSUSY_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SLHAinterface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLHAinterface_coupSUSY_set" "', argument " "1"" of type '" "Pythia8::SLHAinterface *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SLHAinterface * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLHAinterface_coupSUSY_set" "', argument " "2"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::CoupSUSY * >(argp2);
  if (arg1) (arg1)->coupSUSY = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLHAinterface_coupSUSY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SLHAinterface *arg1 = (Pythia8::SLHAinterface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::CoupSUSY *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SLHAinterface_coupSUSY_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SLHAinterface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLHAinterface_coupSUSY_get" "', argument " "1"" of type '" "Pythia8::SLHAinterface *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SLHAinterface * >(argp1);
  result = (Pythia8::CoupSUSY *)& ((arg1)->coupSUSY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLHAinterface_couplingsPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SLHAinterface *arg1 = (Pythia8::SLHAinterface *) 0 ;
  Pythia8::Couplings *arg2 = (Pythia8::Couplings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SLHAinterface_couplingsPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SLHAinterface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLHAinterface_couplingsPtr_set" "', argument " "1"" of type '" "Pythia8::SLHAinterface *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SLHAinterface * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Couplings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLHAinterface_couplingsPtr_set" "', argument " "2"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Couplings * >(argp2);
  if (arg1) (arg1)->couplingsPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLHAinterface_couplingsPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SLHAinterface *arg1 = (Pythia8::SLHAinterface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Couplings *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SLHAinterface_couplingsPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SLHAinterface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLHAinterface_couplingsPtr_get" "', argument " "1"" of type '" "Pythia8::SLHAinterface *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SLHAinterface * >(argp1);
  result = (Pythia8::Couplings *) ((arg1)->couplingsPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLHAinterface_infoPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SLHAinterface *arg1 = (Pythia8::SLHAinterface *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SLHAinterface_infoPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SLHAinterface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLHAinterface_infoPtr_set" "', argument " "1"" of type '" "Pythia8::SLHAinterface *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SLHAinterface * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLHAinterface_infoPtr_set" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  if (arg1) (arg1)->infoPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLHAinterface_infoPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SLHAinterface *arg1 = (Pythia8::SLHAinterface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Info *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SLHAinterface_infoPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SLHAinterface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLHAinterface_infoPtr_get" "', argument " "1"" of type '" "Pythia8::SLHAinterface *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SLHAinterface * >(argp1);
  result = (Pythia8::Info *) ((arg1)->infoPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLHAinterface_settingsPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SLHAinterface *arg1 = (Pythia8::SLHAinterface *) 0 ;
  Pythia8::Settings *arg2 = (Pythia8::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SLHAinterface_settingsPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SLHAinterface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLHAinterface_settingsPtr_set" "', argument " "1"" of type '" "Pythia8::SLHAinterface *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SLHAinterface * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Settings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLHAinterface_settingsPtr_set" "', argument " "2"" of type '" "Pythia8::Settings *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  if (arg1) (arg1)->settingsPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLHAinterface_settingsPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SLHAinterface *arg1 = (Pythia8::SLHAinterface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Settings *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SLHAinterface_settingsPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SLHAinterface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLHAinterface_settingsPtr_get" "', argument " "1"" of type '" "Pythia8::SLHAinterface *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SLHAinterface * >(argp1);
  result = (Pythia8::Settings *) ((arg1)->settingsPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLHAinterface_meMode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SLHAinterface *arg1 = (Pythia8::SLHAinterface *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SLHAinterface_meMode_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SLHAinterface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLHAinterface_meMode_set" "', argument " "1"" of type '" "Pythia8::SLHAinterface *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SLHAinterface * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SLHAinterface_meMode_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->meMode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SLHAinterface_meMode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SLHAinterface *arg1 = (Pythia8::SLHAinterface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SLHAinterface_meMode_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SLHAinterface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLHAinterface_meMode_get" "', argument " "1"" of type '" "Pythia8::SLHAinterface *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SLHAinterface * >(argp1);
  result = (int) ((arg1)->meMode);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SLHAinterface(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SLHAinterface *arg1 = (Pythia8::SLHAinterface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SLHAinterface",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SLHAinterface, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SLHAinterface" "', argument " "1"" of type '" "Pythia8::SLHAinterface *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SLHAinterface * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SLHAinterface_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SLHAinterface, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_WidthFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::WidthFunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_WidthFunction")) SWIG_fail;
  result = (Pythia8::WidthFunction *)new Pythia8::WidthFunction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__WidthFunction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_WidthFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::WidthFunction *arg1 = (Pythia8::WidthFunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_WidthFunction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__WidthFunction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WidthFunction" "', argument " "1"" of type '" "Pythia8::WidthFunction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::WidthFunction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WidthFunction_setPointers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::WidthFunction *arg1 = (Pythia8::WidthFunction *) 0 ;
  Pythia8::ParticleData *arg2 = (Pythia8::ParticleData *) 0 ;
  Pythia8::CoupSUSY *arg3 = (Pythia8::CoupSUSY *) 0 ;
  Pythia8::Info *arg4 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:WidthFunction_setPointers",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__WidthFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WidthFunction_setPointers" "', argument " "1"" of type '" "Pythia8::WidthFunction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::WidthFunction * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WidthFunction_setPointers" "', argument " "2"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ParticleData * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__CoupSUSY, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "WidthFunction_setPointers" "', argument " "3"" of type '" "Pythia8::CoupSUSY *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::CoupSUSY * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "WidthFunction_setPointers" "', argument " "4"" of type '" "Pythia8::Info *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Info * >(argp4);
  (arg1)->setPointers(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WidthFunction_getWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::WidthFunction *arg1 = (Pythia8::WidthFunction *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:WidthFunction_getWidth",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__WidthFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WidthFunction_getWidth" "', argument " "1"" of type '" "Pythia8::WidthFunction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::WidthFunction * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WidthFunction_getWidth" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "WidthFunction_getWidth" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)(arg1)->getWidth(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_WidthFunction_f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::WidthFunction *arg1 = (Pythia8::WidthFunction *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:WidthFunction_f",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__WidthFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WidthFunction_f" "', argument " "1"" of type '" "Pythia8::WidthFunction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::WidthFunction * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WidthFunction_f" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->f(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *WidthFunction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__WidthFunction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_StauWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StauWidths *arg1 = (Pythia8::StauWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StauWidths",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StauWidths, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StauWidths" "', argument " "1"" of type '" "Pythia8::StauWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StauWidths * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StauWidths_getWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StauWidths *arg1 = (Pythia8::StauWidths *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:StauWidths_getWidth",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StauWidths, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StauWidths_getWidth" "', argument " "1"" of type '" "Pythia8::StauWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StauWidths * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StauWidths_getWidth" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StauWidths_getWidth" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)(arg1)->getWidth(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StauWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StauWidths *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StauWidths")) SWIG_fail;
  result = (Pythia8::StauWidths *)new Pythia8::StauWidths();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__StauWidths, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StauWidths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__StauWidths, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Particle__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Particle")) SWIG_fail;
  result = (Pythia8::Particle *)new Pythia8::Particle();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Particle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:new_Particle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Particle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Particle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Particle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Particle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Particle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Particle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Particle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Particle" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Particle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_Particle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_Particle" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_Particle" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_Particle" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_Particle" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_Particle" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  result = (Pythia8::Particle *)new Pythia8::Particle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Particle__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:new_Particle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Particle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Particle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Particle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Particle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Particle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Particle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Particle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Particle" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Particle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_Particle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_Particle" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_Particle" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_Particle" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_Particle" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  result = (Pythia8::Particle *)new Pythia8::Particle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Particle__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:new_Particle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Particle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Particle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Particle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Particle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Particle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Particle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Particle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Particle" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Particle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_Particle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_Particle" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_Particle" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_Particle" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  result = (Pythia8::Particle *)new Pythia8::Particle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Particle__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:new_Particle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Particle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Particle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Particle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Particle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Particle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Particle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Particle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Particle" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Particle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_Particle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_Particle" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_Particle" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  result = (Pythia8::Particle *)new Pythia8::Particle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Particle__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:new_Particle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Particle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Particle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Particle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Particle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Particle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Particle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Particle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Particle" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Particle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_Particle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_Particle" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  result = (Pythia8::Particle *)new Pythia8::Particle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Particle__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  double arg9 ;
  double arg10 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:new_Particle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Particle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Particle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Particle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Particle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Particle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Particle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Particle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Particle" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Particle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_Particle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (Pythia8::Particle *)new Pythia8::Particle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Particle__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  double arg9 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_Particle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Particle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Particle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Particle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Particle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Particle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Particle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Particle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Particle" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Particle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (Pythia8::Particle *)new Pythia8::Particle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Particle__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:new_Particle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Particle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Particle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Particle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Particle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Particle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Particle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Particle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Particle" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  result = (Pythia8::Particle *)new Pythia8::Particle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Particle__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_Particle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Particle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Particle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Particle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Particle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Particle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Particle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Particle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  result = (Pythia8::Particle *)new Pythia8::Particle(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Particle__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_Particle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Particle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Particle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Particle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Particle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Particle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Particle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (Pythia8::Particle *)new Pythia8::Particle(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Particle__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Particle",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Particle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Particle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Particle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Particle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Particle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (Pythia8::Particle *)new Pythia8::Particle(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Particle__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Particle",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Particle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Particle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Particle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Particle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (Pythia8::Particle *)new Pythia8::Particle(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Particle__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Particle",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Particle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Particle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Particle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::Particle *)new Pythia8::Particle(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Particle__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Particle",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Particle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Particle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::Particle *)new Pythia8::Particle(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Particle__SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Particle",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Particle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Particle *)new Pythia8::Particle(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Particle__SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  Pythia8::Vec4 arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:new_Particle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Particle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Particle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Particle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Particle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Particle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Particle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Particle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Particle" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_Particle" "', argument " "9"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Particle" "', argument " "9"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_Particle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_Particle" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_Particle" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  result = (Pythia8::Particle *)new Pythia8::Particle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Particle__SWIG_17(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  Pythia8::Vec4 arg9 ;
  double arg10 ;
  double arg11 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:new_Particle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Particle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Particle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Particle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Particle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Particle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Particle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Particle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Particle" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_Particle" "', argument " "9"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Particle" "', argument " "9"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_Particle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_Particle" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  result = (Pythia8::Particle *)new Pythia8::Particle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Particle__SWIG_18(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  Pythia8::Vec4 arg9 ;
  double arg10 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:new_Particle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Particle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Particle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Particle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Particle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Particle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Particle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Particle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Particle" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_Particle" "', argument " "9"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Particle" "', argument " "9"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_Particle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (Pythia8::Particle *)new Pythia8::Particle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Particle__SWIG_19(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  Pythia8::Vec4 arg9 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_Particle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Particle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Particle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Particle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Particle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Particle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Particle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Particle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Particle" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_Particle" "', argument " "9"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Particle" "', argument " "9"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  result = (Pythia8::Particle *)new Pythia8::Particle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Particle__SWIG_20(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Particle",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Particle,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Particle" "', argument " "1"" of type '" "Pythia8::Particle const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Particle" "', argument " "1"" of type '" "Pythia8::Particle const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (Pythia8::Particle *)new Pythia8::Particle((Pythia8::Particle const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Particle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[16] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 15) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Particle__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Particle__SWIG_20(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Particle__SWIG_15(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Particle__SWIG_14(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Particle__SWIG_13(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Particle__SWIG_12(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Particle__SWIG_11(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_Particle__SWIG_10(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_Particle__SWIG_9(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_Particle__SWIG_8(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_Particle__SWIG_19(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_Particle__SWIG_7(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_Particle__SWIG_18(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_Particle__SWIG_6(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_Particle__SWIG_17(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_Particle__SWIG_5(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_Particle__SWIG_16(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_Particle__SWIG_4(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_Particle__SWIG_3(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_Particle__SWIG_2(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_new_Particle__SWIG_1(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Particle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::Particle()\n"
    "    Pythia8::Particle::Particle(int,int,int,int,int,int,int,int,double,double,double,double,double,double,double)\n"
    "    Pythia8::Particle::Particle(int,int,int,int,int,int,int,int,double,double,double,double,double,double)\n"
    "    Pythia8::Particle::Particle(int,int,int,int,int,int,int,int,double,double,double,double,double)\n"
    "    Pythia8::Particle::Particle(int,int,int,int,int,int,int,int,double,double,double,double)\n"
    "    Pythia8::Particle::Particle(int,int,int,int,int,int,int,int,double,double,double)\n"
    "    Pythia8::Particle::Particle(int,int,int,int,int,int,int,int,double,double)\n"
    "    Pythia8::Particle::Particle(int,int,int,int,int,int,int,int,double)\n"
    "    Pythia8::Particle::Particle(int,int,int,int,int,int,int,int)\n"
    "    Pythia8::Particle::Particle(int,int,int,int,int,int,int)\n"
    "    Pythia8::Particle::Particle(int,int,int,int,int,int)\n"
    "    Pythia8::Particle::Particle(int,int,int,int,int)\n"
    "    Pythia8::Particle::Particle(int,int,int,int)\n"
    "    Pythia8::Particle::Particle(int,int,int)\n"
    "    Pythia8::Particle::Particle(int,int)\n"
    "    Pythia8::Particle::Particle(int)\n"
    "    Pythia8::Particle::Particle(int,int,int,int,int,int,int,int,Pythia8::Vec4,double,double,double)\n"
    "    Pythia8::Particle::Particle(int,int,int,int,int,int,int,int,Pythia8::Vec4,double,double)\n"
    "    Pythia8::Particle::Particle(int,int,int,int,int,int,int,int,Pythia8::Vec4,double)\n"
    "    Pythia8::Particle::Particle(int,int,int,int,int,int,int,int,Pythia8::Vec4)\n"
    "    Pythia8::Particle::Particle(Pythia8::Particle const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_setEvtPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  Pythia8::Event *arg2 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_setEvtPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_setEvtPtr" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Particle_setEvtPtr" "', argument " "2"" of type '" "Pythia8::Event *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  (arg1)->setEvtPtr(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_setPDEPtr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  Pythia8::ParticleDataEntry *arg2 = (Pythia8::ParticleDataEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_setPDEPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_setPDEPtr" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Particle_setPDEPtr" "', argument " "2"" of type '" "Pythia8::ParticleDataEntry *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ParticleDataEntry * >(argp2);
  (arg1)->setPDEPtr(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_setPDEPtr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_setPDEPtr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_setPDEPtr" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  (arg1)->setPDEPtr();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_setPDEPtr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_setPDEPtr__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__ParticleDataEntry, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Particle_setPDEPtr__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_setPDEPtr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::setPDEPtr(Pythia8::ParticleDataEntry *)\n"
    "    Pythia8::Particle::setPDEPtr()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_id__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_id",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_id" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_id" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->id(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_status__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_status",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_status" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_status" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->status(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_statusPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_statusPos",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_statusPos" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  (arg1)->statusPos();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_statusNeg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_statusNeg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_statusNeg" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  (arg1)->statusNeg();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_statusCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_statusCode",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_statusCode" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_statusCode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->statusCode(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_mother1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_mother1",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_mother1" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_mother1" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->mother1(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_mother2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_mother2",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_mother2" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_mother2" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->mother2(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_mothers__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Particle_mothers",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_mothers" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_mothers" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Particle_mothers" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->mothers(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_mothers__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_mothers",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_mothers" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_mothers" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->mothers(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_mothers__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_mothers",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_mothers" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  (arg1)->mothers();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_mothers(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_mothers__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_mothers__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Particle_mothers__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_mothers'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::mothers(int,int)\n"
    "    Pythia8::Particle::mothers(int)\n"
    "    Pythia8::Particle::mothers()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_daughter1__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_daughter1",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_daughter1" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_daughter1" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->daughter1(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_daughter2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_daughter2",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_daughter2" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_daughter2" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->daughter2(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_daughters__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Particle_daughters",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_daughters" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_daughters" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Particle_daughters" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->daughters(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_daughters__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_daughters",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_daughters" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_daughters" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->daughters(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_daughters__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_daughters",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_daughters" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  (arg1)->daughters();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_daughters(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_daughters__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_daughters__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Particle_daughters__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_daughters'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::daughters(int,int)\n"
    "    Pythia8::Particle::daughters(int)\n"
    "    Pythia8::Particle::daughters()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_col__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_col",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_col" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_col" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->col(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_acol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_acol",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_acol" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_acol" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->acol(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_cols__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Particle_cols",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_cols" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_cols" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Particle_cols" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->cols(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_cols__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_cols",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_cols" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_cols" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->cols(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_cols__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_cols",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_cols" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  (arg1)->cols();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_cols(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_cols__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_cols__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Particle_cols__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_cols'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::cols(int,int)\n"
    "    Pythia8::Particle::cols(int)\n"
    "    Pythia8::Particle::cols()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_p__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  Pythia8::Vec4 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_p",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_p" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Particle_p" "', argument " "2"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Particle_p" "', argument " "2"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->p(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_p__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Particle_p",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_p" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_p" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Particle_p" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Particle_p" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Particle_p" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  (arg1)->p(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_px__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_px",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_px" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_px" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->px(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_py__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_py",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_py" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_py" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->py(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_pz__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_pz",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_pz" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_pz" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->pz(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_e__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_e",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_e" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_e" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->e(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_m__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_m",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_m" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_m" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->m(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_scale",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_scale" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_scale" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->scale(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_pol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_pol",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_pol" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_pol" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->pol(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_vProd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  Pythia8::Vec4 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_vProd",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_vProd" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Particle_vProd" "', argument " "2"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Particle_vProd" "', argument " "2"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->vProd(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_vProd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Particle_vProd",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_vProd" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_vProd" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Particle_vProd" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Particle_vProd" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Particle_vProd" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  (arg1)->vProd(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_xProd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_xProd",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_xProd" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_xProd" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->xProd(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_yProd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_yProd",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_yProd" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_yProd" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->yProd(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_zProd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_zProd",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_zProd" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_zProd" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->zProd(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_tProd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_tProd",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_tProd" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_tProd" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->tProd(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_tau__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_tau",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_tau" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_tau" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->tau(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_id__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_id",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_id" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (int)((Pythia8::Particle const *)arg1)->id();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_id(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_id__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_id__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_id'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::id(int)\n"
    "    Pythia8::Particle::id() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_status__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_status",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_status" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (int)((Pythia8::Particle const *)arg1)->status();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_status(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_status__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_status__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_status'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::status(int)\n"
    "    Pythia8::Particle::status() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_mother1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_mother1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_mother1" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (int)((Pythia8::Particle const *)arg1)->mother1();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_mother1(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_mother1__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_mother1__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_mother1'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::mother1(int)\n"
    "    Pythia8::Particle::mother1() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_mother2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_mother2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_mother2" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (int)((Pythia8::Particle const *)arg1)->mother2();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_mother2(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_mother2__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_mother2__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_mother2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::mother2(int)\n"
    "    Pythia8::Particle::mother2() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_daughter1__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_daughter1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_daughter1" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (int)((Pythia8::Particle const *)arg1)->daughter1();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_daughter1(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_daughter1__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_daughter1__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_daughter1'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::daughter1(int)\n"
    "    Pythia8::Particle::daughter1() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_daughter2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_daughter2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_daughter2" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (int)((Pythia8::Particle const *)arg1)->daughter2();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_daughter2(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_daughter2__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_daughter2__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_daughter2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::daughter2(int)\n"
    "    Pythia8::Particle::daughter2() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_col__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_col",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_col" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (int)((Pythia8::Particle const *)arg1)->col();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_col(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_col__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_col__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_col'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::col(int)\n"
    "    Pythia8::Particle::col() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_acol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_acol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_acol" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (int)((Pythia8::Particle const *)arg1)->acol();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_acol(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_acol__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_acol__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_acol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::acol(int)\n"
    "    Pythia8::Particle::acol() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_p__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_p",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_p" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = ((Pythia8::Particle const *)arg1)->p();
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_p(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_p__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Particle_p__SWIG_0(self, args);
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Particle_p__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_p'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::p(Pythia8::Vec4)\n"
    "    Pythia8::Particle::p(double,double,double,double)\n"
    "    Pythia8::Particle::p() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_px__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_px",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_px" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->px();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_px(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_px__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_px__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_px'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::px(double)\n"
    "    Pythia8::Particle::px() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_py__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_py",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_py" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->py();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_py(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_py__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_py__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_py'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::py(double)\n"
    "    Pythia8::Particle::py() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_pz__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_pz",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_pz" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->pz();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_pz(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_pz__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_pz__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_pz'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::pz(double)\n"
    "    Pythia8::Particle::pz() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_e__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_e",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_e" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->e();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_e(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_e__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_e__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_e'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::e(double)\n"
    "    Pythia8::Particle::e() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_m__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_m",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_m" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->m();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_m(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_m__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_m__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_m'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::m(double)\n"
    "    Pythia8::Particle::m() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_scale",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_scale" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->scale();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_scale(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_scale__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_scale__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_scale'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::scale(double)\n"
    "    Pythia8::Particle::scale() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_pol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_pol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_pol" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->pol();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_pol(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_pol__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_pol__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_pol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::pol(double)\n"
    "    Pythia8::Particle::pol() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_hasVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_hasVertex",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_hasVertex" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (bool)((Pythia8::Particle const *)arg1)->hasVertex();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_vProd__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_vProd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_vProd" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = ((Pythia8::Particle const *)arg1)->vProd();
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_vProd(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_vProd__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Particle_vProd__SWIG_0(self, args);
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Particle_vProd__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_vProd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::vProd(Pythia8::Vec4)\n"
    "    Pythia8::Particle::vProd(double,double,double,double)\n"
    "    Pythia8::Particle::vProd() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_xProd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_xProd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_xProd" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->xProd();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_xProd(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_xProd__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_xProd__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_xProd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::xProd(double)\n"
    "    Pythia8::Particle::xProd() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_yProd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_yProd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_yProd" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->yProd();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_yProd(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_yProd__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_yProd__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_yProd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::yProd(double)\n"
    "    Pythia8::Particle::yProd() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_zProd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_zProd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_zProd" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->zProd();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_zProd(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_zProd__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_zProd__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_zProd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::zProd(double)\n"
    "    Pythia8::Particle::zProd() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_tProd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_tProd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_tProd" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->tProd();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_tProd(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_tProd__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_tProd__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_tProd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::tProd(double)\n"
    "    Pythia8::Particle::tProd() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_tau__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_tau",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_tau" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->tau();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_tau(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_tau__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_tau__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_tau'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::tau(double)\n"
    "    Pythia8::Particle::tau() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_idAbs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_idAbs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_idAbs" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (int)((Pythia8::Particle const *)arg1)->idAbs();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_statusAbs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_statusAbs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_statusAbs" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (int)((Pythia8::Particle const *)arg1)->statusAbs();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_isFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_isFinal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_isFinal" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (bool)((Pythia8::Particle const *)arg1)->isFinal();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_intPol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_intPol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_intPol" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (int)((Pythia8::Particle const *)arg1)->intPol();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_isRescatteredIncoming(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_isRescatteredIncoming",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_isRescatteredIncoming" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (bool)((Pythia8::Particle const *)arg1)->isRescatteredIncoming();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_m2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_m2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_m2" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->m2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_mCalc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_mCalc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_mCalc" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->mCalc();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_m2Calc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_m2Calc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_m2Calc" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->m2Calc();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_eCalc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_eCalc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_eCalc" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->eCalc();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_pT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_pT",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_pT" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->pT();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_pT2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_pT2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_pT2" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->pT2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_mT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_mT",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_mT" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->mT();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_mT2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_mT2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_mT2" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->mT2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_pAbs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_pAbs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_pAbs" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->pAbs();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_pAbs2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_pAbs2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_pAbs2" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->pAbs2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_eT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_eT",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_eT" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->eT();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_eT2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_eT2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_eT2" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->eT2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_theta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_theta",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_theta" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->theta();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_phi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_phi",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_phi" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->phi();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_thetaXZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_thetaXZ",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_thetaXZ" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->thetaXZ();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_pPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_pPos",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_pPos" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->pPos();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_pNeg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_pNeg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_pNeg" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->pNeg();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_y__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_y",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_y" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->y();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_eta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_eta",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_eta" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->eta();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_y__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_y",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_y" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_y" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((Pythia8::Particle const *)arg1)->y(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_y__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  double arg2 ;
  Pythia8::RotBstMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Particle_y",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_y" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_y" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__RotBstMatrix,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Particle_y" "', argument " "3"" of type '" "Pythia8::RotBstMatrix &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Particle_y" "', argument " "3"" of type '" "Pythia8::RotBstMatrix &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp3);
  result = (double)((Pythia8::Particle const *)arg1)->y(arg2,*arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_y(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_y__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_y__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__RotBstMatrix, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Particle_y__SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_y'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::y() const\n"
    "    Pythia8::Particle::y(double) const\n"
    "    Pythia8::Particle::y(double,Pythia8::RotBstMatrix &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_vDec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_vDec",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_vDec" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = ((Pythia8::Particle const *)arg1)->vDec();
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_xDec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_xDec",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_xDec" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->xDec();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_yDec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_yDec",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_yDec" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->yDec();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_zDec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_zDec",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_zDec" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->zDec();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_tDec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_tDec",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_tDec" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->tDec();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_index(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_index",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_index" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (int)((Pythia8::Particle const *)arg1)->index();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_iTopCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_iTopCopy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_iTopCopy" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (int)((Pythia8::Particle const *)arg1)->iTopCopy();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_iBotCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_iBotCopy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_iBotCopy" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (int)((Pythia8::Particle const *)arg1)->iBotCopy();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_iTopCopyId__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_iTopCopyId",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_iTopCopyId" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_iTopCopyId" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (int)((Pythia8::Particle const *)arg1)->iTopCopyId(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_iTopCopyId__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_iTopCopyId",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_iTopCopyId" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (int)((Pythia8::Particle const *)arg1)->iTopCopyId();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_iTopCopyId(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_iTopCopyId__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_iTopCopyId__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_iTopCopyId'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::iTopCopyId(bool) const\n"
    "    Pythia8::Particle::iTopCopyId() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_iBotCopyId__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_iBotCopyId",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_iBotCopyId" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_iBotCopyId" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (int)((Pythia8::Particle const *)arg1)->iBotCopyId(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_iBotCopyId__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_iBotCopyId",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_iBotCopyId" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (int)((Pythia8::Particle const *)arg1)->iBotCopyId();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_iBotCopyId(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_iBotCopyId__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_iBotCopyId__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_iBotCopyId'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::iBotCopyId(bool) const\n"
    "    Pythia8::Particle::iBotCopyId() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_motherList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int,std::allocator< int > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_motherList",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_motherList" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = ((Pythia8::Particle const *)arg1)->motherList();
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_daughterList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int,std::allocator< int > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_daughterList",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_daughterList" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = ((Pythia8::Particle const *)arg1)->daughterList();
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_daughterListRecursive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int,std::allocator< int > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_daughterListRecursive",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_daughterListRecursive" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = ((Pythia8::Particle const *)arg1)->daughterListRecursive();
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_sisterList__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< int,std::allocator< int > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_sisterList",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_sisterList" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_sisterList" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = ((Pythia8::Particle const *)arg1)->sisterList(arg2);
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_sisterList__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int,std::allocator< int > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_sisterList",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_sisterList" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = ((Pythia8::Particle const *)arg1)->sisterList();
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_sisterList(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_sisterList__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_sisterList__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_sisterList'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::sisterList(bool) const\n"
    "    Pythia8::Particle::sisterList() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_isAncestor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_isAncestor",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_isAncestor" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_isAncestor" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)((Pythia8::Particle const *)arg1)->isAncestor(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_statusHepMC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_statusHepMC",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_statusHepMC" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (int)((Pythia8::Particle const *)arg1)->statusHepMC();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_isFinalPartonLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_isFinalPartonLevel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_isFinalPartonLevel" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (bool)((Pythia8::Particle const *)arg1)->isFinalPartonLevel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_undoDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_undoDecay",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_undoDecay" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (bool)(arg1)->undoDecay();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_name" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = ((Pythia8::Particle const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_nameWithStatus__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_nameWithStatus",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_nameWithStatus" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_nameWithStatus" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((Pythia8::Particle const *)arg1)->nameWithStatus(arg2);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_nameWithStatus__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_nameWithStatus",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_nameWithStatus" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = ((Pythia8::Particle const *)arg1)->nameWithStatus();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_nameWithStatus(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Particle_nameWithStatus__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Particle_nameWithStatus__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_nameWithStatus'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::nameWithStatus(int) const\n"
    "    Pythia8::Particle::nameWithStatus() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_spinType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_spinType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_spinType" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (int)((Pythia8::Particle const *)arg1)->spinType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_chargeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_chargeType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_chargeType" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (int)((Pythia8::Particle const *)arg1)->chargeType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_charge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_charge",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_charge" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->charge();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_isCharged(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_isCharged",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_isCharged" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (bool)((Pythia8::Particle const *)arg1)->isCharged();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_isNeutral(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_isNeutral",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_isNeutral" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (bool)((Pythia8::Particle const *)arg1)->isNeutral();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_colType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_colType",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_colType" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (int)((Pythia8::Particle const *)arg1)->colType();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_m0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_m0",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_m0" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->m0();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_mWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_mWidth",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_mWidth" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->mWidth();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_mMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_mMin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_mMin" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->mMin();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_mMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_mMax",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_mMax" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->mMax();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_mSel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_mSel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_mSel" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->mSel();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_constituentMass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_constituentMass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_constituentMass" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->constituentMass();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_tau0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_tau0",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_tau0" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (double)((Pythia8::Particle const *)arg1)->tau0();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_mayDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_mayDecay",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_mayDecay" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (bool)((Pythia8::Particle const *)arg1)->mayDecay();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_canDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_canDecay",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_canDecay" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (bool)((Pythia8::Particle const *)arg1)->canDecay();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_doExternalDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_doExternalDecay",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_doExternalDecay" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (bool)((Pythia8::Particle const *)arg1)->doExternalDecay();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_isResonance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_isResonance",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_isResonance" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (bool)((Pythia8::Particle const *)arg1)->isResonance();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_isVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_isVisible",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_isVisible" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (bool)((Pythia8::Particle const *)arg1)->isVisible();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_isLepton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_isLepton",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_isLepton" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (bool)((Pythia8::Particle const *)arg1)->isLepton();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_isQuark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_isQuark",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_isQuark" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (bool)((Pythia8::Particle const *)arg1)->isQuark();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_isGluon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_isGluon",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_isGluon" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (bool)((Pythia8::Particle const *)arg1)->isGluon();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_isDiquark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_isDiquark",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_isDiquark" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (bool)((Pythia8::Particle const *)arg1)->isDiquark();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_isParton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_isParton",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_isParton" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (bool)((Pythia8::Particle const *)arg1)->isParton();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_isHadron(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_isHadron",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_isHadron" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (bool)((Pythia8::Particle const *)arg1)->isHadron();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_particleDataEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ParticleDataEntry *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Particle_particleDataEntry",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_particleDataEntry" "', argument " "1"" of type '" "Pythia8::Particle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (Pythia8::ParticleDataEntry *) &((Pythia8::Particle const *)arg1)->particleDataEntry();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDataEntry, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_rescale3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_rescale3",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_rescale3" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_rescale3" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->rescale3(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_rescale4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_rescale4",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_rescale4" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_rescale4" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->rescale4(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_rescale5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_rescale5",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_rescale5" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_rescale5" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->rescale5(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_rot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Particle_rot",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_rot" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_rot" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Particle_rot" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->rot(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_bst__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Particle_bst",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_bst" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_bst" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Particle_bst" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Particle_bst" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->bst(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_bst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Particle_bst",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_bst" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_bst" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Particle_bst" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Particle_bst" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Particle_bst" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  (arg1)->bst(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_bst__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_bst",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_bst" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Particle_bst" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Particle_bst" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  (arg1)->bst((Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_bst__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Particle_bst",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_bst" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Particle_bst" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Particle_bst" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Particle_bst" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->bst((Pythia8::Vec4 const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_bst(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Particle_bst__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Particle_bst__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Particle_bst__SWIG_0(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Particle_bst__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_bst'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::bst(double,double,double)\n"
    "    Pythia8::Particle::bst(double,double,double,double)\n"
    "    Pythia8::Particle::bst(Pythia8::Vec4 const &)\n"
    "    Pythia8::Particle::bst(Pythia8::Vec4 const &,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_bstback__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_bstback",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_bstback" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Particle_bstback" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Particle_bstback" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  (arg1)->bstback((Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_bstback__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Particle_bstback",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_bstback" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Particle_bstback" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Particle_bstback" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Particle_bstback" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->bstback((Pythia8::Vec4 const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_bstback(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Particle_bstback__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Particle_bstback__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Particle_bstback'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Particle::bstback(Pythia8::Vec4 const &)\n"
    "    Pythia8::Particle::bstback(Pythia8::Vec4 const &,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Particle_rotbst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  Pythia8::RotBstMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_rotbst",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_rotbst" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__RotBstMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Particle_rotbst" "', argument " "2"" of type '" "Pythia8::RotBstMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Particle_rotbst" "', argument " "2"" of type '" "Pythia8::RotBstMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp2);
  (arg1)->rotbst((Pythia8::RotBstMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_offsetHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Particle_offsetHistory",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_offsetHistory" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_offsetHistory" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Particle_offsetHistory" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Particle_offsetHistory" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Particle_offsetHistory" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  (arg1)->offsetHistory(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Particle_offsetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Particle_offsetCol",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Particle_offsetCol" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Particle_offsetCol" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->offsetCol(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Particle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Particle",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Particle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Particle" "', argument " "1"" of type '" "Pythia8::Particle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Particle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Particle, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_m__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = 0 ;
  Pythia8::Particle *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:m",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Particle,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "m" "', argument " "1"" of type '" "Pythia8::Particle const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "m" "', argument " "1"" of type '" "Pythia8::Particle const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Particle,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "m" "', argument " "2"" of type '" "Pythia8::Particle const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "m" "', argument " "2"" of type '" "Pythia8::Particle const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Particle * >(argp2);
  result = (double)Pythia8::m((Pythia8::Particle const &)*arg1,(Pythia8::Particle const &)*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_m(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_m__SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Particle, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_m__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::m(Pythia8::Vec4 const &,Pythia8::Vec4 const &)\n"
    "    Pythia8::m(Pythia8::Particle const &,Pythia8::Particle const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_m2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = 0 ;
  Pythia8::Particle *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:m2",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Particle,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "m2" "', argument " "1"" of type '" "Pythia8::Particle const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "m2" "', argument " "1"" of type '" "Pythia8::Particle const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Particle,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "m2" "', argument " "2"" of type '" "Pythia8::Particle const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "m2" "', argument " "2"" of type '" "Pythia8::Particle const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Particle * >(argp2);
  result = (double)Pythia8::m2((Pythia8::Particle const &)*arg1,(Pythia8::Particle const &)*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Junction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Junction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Junction")) SWIG_fail;
  result = (Pythia8::Junction *)new Pythia8::Junction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Junction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Junction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::Junction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Junction",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Junction" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Junction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Junction" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Junction" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (Pythia8::Junction *)new Pythia8::Junction(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Junction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Junction__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Junction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Junction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Junction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Junction,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Junction" "', argument " "1"" of type '" "Pythia8::Junction const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Junction" "', argument " "1"" of type '" "Pythia8::Junction const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Junction * >(argp1);
  result = (Pythia8::Junction *)new Pythia8::Junction((Pythia8::Junction const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Junction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Junction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Junction__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Junction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Junction__SWIG_2(self, args);
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Junction__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Junction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Junction::Junction()\n"
    "    Pythia8::Junction::Junction(int,int,int,int)\n"
    "    Pythia8::Junction::Junction(Pythia8::Junction const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Junction_remains__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Junction *arg1 = (Pythia8::Junction *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Junction_remains",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Junction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Junction_remains" "', argument " "1"" of type '" "Pythia8::Junction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Junction * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Junction_remains" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->remains(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Junction_col__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Junction *arg1 = (Pythia8::Junction *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Junction_col",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Junction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Junction_col" "', argument " "1"" of type '" "Pythia8::Junction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Junction * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Junction_col" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Junction_col" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->col(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Junction_cols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Junction *arg1 = (Pythia8::Junction *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Junction_cols",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Junction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Junction_cols" "', argument " "1"" of type '" "Pythia8::Junction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Junction * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Junction_cols" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Junction_cols" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Junction_cols" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->cols(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Junction_endCol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Junction *arg1 = (Pythia8::Junction *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Junction_endCol",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Junction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Junction_endCol" "', argument " "1"" of type '" "Pythia8::Junction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Junction * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Junction_endCol" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Junction_endCol" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->endCol(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Junction_status__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Junction *arg1 = (Pythia8::Junction *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Junction_status",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Junction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Junction_status" "', argument " "1"" of type '" "Pythia8::Junction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Junction * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Junction_status" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Junction_status" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->status(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Junction_remains__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Junction *arg1 = (Pythia8::Junction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Junction_remains",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Junction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Junction_remains" "', argument " "1"" of type '" "Pythia8::Junction const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Junction * >(argp1);
  result = (bool)((Pythia8::Junction const *)arg1)->remains();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Junction_remains(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Junction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Junction_remains__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Junction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Junction_remains__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Junction_remains'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Junction::remains(bool)\n"
    "    Pythia8::Junction::remains() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Junction_kind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Junction *arg1 = (Pythia8::Junction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Junction_kind",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Junction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Junction_kind" "', argument " "1"" of type '" "Pythia8::Junction const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Junction * >(argp1);
  result = (int)((Pythia8::Junction const *)arg1)->kind();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Junction_col__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Junction *arg1 = (Pythia8::Junction *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Junction_col",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Junction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Junction_col" "', argument " "1"" of type '" "Pythia8::Junction const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Junction * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Junction_col" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::Junction const *)arg1)->col(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Junction_col(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Junction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Junction_col__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Junction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Junction_col__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Junction_col'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Junction::col(int,int)\n"
    "    Pythia8::Junction::col(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Junction_endCol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Junction *arg1 = (Pythia8::Junction *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Junction_endCol",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Junction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Junction_endCol" "', argument " "1"" of type '" "Pythia8::Junction const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Junction * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Junction_endCol" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::Junction const *)arg1)->endCol(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Junction_endCol(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Junction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Junction_endCol__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Junction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Junction_endCol__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Junction_endCol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Junction::endCol(int,int)\n"
    "    Pythia8::Junction::endCol(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Junction_status__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Junction *arg1 = (Pythia8::Junction *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Junction_status",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Junction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Junction_status" "', argument " "1"" of type '" "Pythia8::Junction const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Junction * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Junction_status" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::Junction const *)arg1)->status(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Junction_status(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Junction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Junction_status__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Junction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Junction_status__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Junction_status'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Junction::status(int,int)\n"
    "    Pythia8::Junction::status(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Junction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Junction *arg1 = (Pythia8::Junction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Junction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Junction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Junction" "', argument " "1"" of type '" "Pythia8::Junction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Junction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Junction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Junction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Event__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Event *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Event",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Event" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Event *)new Pythia8::Event(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Event, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Event__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Event")) SWIG_fail;
  result = (Pythia8::Event *)new Pythia8::Event();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Event, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Event__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Event *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Event",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Event" "', argument " "1"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Event" "', argument " "1"" of type '" "Pythia8::Event const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  result = (Pythia8::Event *)new Pythia8::Event((Pythia8::Event const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Event, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Event(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Event__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Event__SWIG_2(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Event__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Event'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Event::Event(int)\n"
    "    Pythia8::Event::Event()\n"
    "    Pythia8::Event::Event(Pythia8::Event const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Event_init__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  std::string arg2 ;
  Pythia8::ParticleData *arg3 = (Pythia8::ParticleData *) 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Event_init",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_init" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Event_init" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Event_init" "', argument " "3"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ParticleData * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_init" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->init(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_init__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  std::string arg2 ;
  Pythia8::ParticleData *arg3 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Event_init",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_init" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Event_init" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Event_init" "', argument " "3"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ParticleData * >(argp3);
  (arg1)->init(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_init__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Event_init",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_init" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Event_init" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_init__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Event_init",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_init" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  (arg1)->init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_init(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Event_init__SWIG_3(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Event_init__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Event_init__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Event_init__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Event_init'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Event::init(std::string,Pythia8::ParticleData *,int)\n"
    "    Pythia8::Event::init(std::string,Pythia8::ParticleData *)\n"
    "    Pythia8::Event::init(std::string)\n"
    "    Pythia8::Event::init()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Event_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Event_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_clear" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Event_reset",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_reset" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  (arg1)->reset();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Event_front",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_front" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  result = (Pythia8::Particle *) &(arg1)->front();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_at(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Event_at",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_at" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_at" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::Particle *) &(arg1)->at(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Event_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_back" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  result = (Pythia8::Particle *) &(arg1)->back();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Event_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_size" "', argument " "1"" of type '" "Pythia8::Event const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  result = (int)((Pythia8::Event const *)arg1)->size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_append__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  Pythia8::Particle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Event_append",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_append" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Particle,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_append" "', argument " "2"" of type '" "Pythia8::Particle""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_append" "', argument " "2"" of type '" "Pythia8::Particle""'");
    } else {
      Pythia8::Particle * temp = reinterpret_cast< Pythia8::Particle * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (int)(arg1)->append(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_append__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  double arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:Event_append",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_append" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_append" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_append" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_append" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Event_append" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Event_append" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Event_append" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Event_append" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Event_append" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Event_append" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Event_append" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Event_append" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Event_append" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Event_append" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Event_append" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "Event_append" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  result = (int)(arg1)->append(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_append__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:Event_append",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_append" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_append" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_append" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_append" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Event_append" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Event_append" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Event_append" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Event_append" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Event_append" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Event_append" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Event_append" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Event_append" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Event_append" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Event_append" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "Event_append" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  result = (int)(arg1)->append(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_append__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Event_append",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_append" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_append" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_append" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_append" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Event_append" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Event_append" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Event_append" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Event_append" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Event_append" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Event_append" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Event_append" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Event_append" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Event_append" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "Event_append" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  result = (int)(arg1)->append(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_append__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Event_append",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_append" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_append" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_append" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_append" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Event_append" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Event_append" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Event_append" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Event_append" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Event_append" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Event_append" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Event_append" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Event_append" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Event_append" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  result = (int)(arg1)->append(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_append__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  Pythia8::Vec4 arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Event_append",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_append" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_append" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_append" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_append" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Event_append" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Event_append" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Event_append" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Event_append" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Event_append" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Event_append" "', argument " "10"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_append" "', argument " "10"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Event_append" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Event_append" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Event_append" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  result = (int)(arg1)->append(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_append__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  Pythia8::Vec4 arg10 ;
  double arg11 ;
  double arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Event_append",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_append" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_append" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_append" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_append" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Event_append" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Event_append" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Event_append" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Event_append" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Event_append" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Event_append" "', argument " "10"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_append" "', argument " "10"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Event_append" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Event_append" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  result = (int)(arg1)->append(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_append__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  Pythia8::Vec4 arg10 ;
  double arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Event_append",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_append" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_append" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_append" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_append" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Event_append" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Event_append" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Event_append" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Event_append" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Event_append" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Event_append" "', argument " "10"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_append" "', argument " "10"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Event_append" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  result = (int)(arg1)->append(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_append__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  Pythia8::Vec4 arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 ;
  int res10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Event_append",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_append" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_append" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_append" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_append" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Event_append" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Event_append" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Event_append" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Event_append" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Event_append" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  {
    res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Event_append" "', argument " "10"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp10) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_append" "', argument " "10"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp10);
      arg10 = *temp;
      if (SWIG_IsNewObj(res10)) delete temp;
    }
  }
  result = (int)(arg1)->append(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_append__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Event_append",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_append" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_append" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_append" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_append" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Event_append" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Event_append" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Event_append" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Event_append" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Event_append" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Event_append" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Event_append" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Event_append" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  result = (int)(arg1)->append(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_append__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Event_append",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_append" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_append" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_append" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_append" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Event_append" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Event_append" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Event_append" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Event_append" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Event_append" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Event_append" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Event_append" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  result = (int)(arg1)->append(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_append__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Event_append",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_append" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_append" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_append" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_append" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Event_append" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Event_append" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Event_append" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Event_append" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Event_append" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Event_append" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (int)(arg1)->append(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_append__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Event_append",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_append" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_append" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_append" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_append" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Event_append" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Event_append" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Event_append" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Event_append" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Event_append" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (int)(arg1)->append(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_append__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  Pythia8::Vec4 arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Event_append",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_append" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_append" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_append" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_append" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Event_append" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Event_append" "', argument " "6"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_append" "', argument " "6"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Event_append" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Event_append" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Event_append" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (int)(arg1)->append(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_append__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  Pythia8::Vec4 arg6 ;
  double arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Event_append",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_append" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_append" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_append" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_append" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Event_append" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Event_append" "', argument " "6"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_append" "', argument " "6"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Event_append" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Event_append" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (int)(arg1)->append(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_append__SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  Pythia8::Vec4 arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Event_append",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_append" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_append" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_append" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_append" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Event_append" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Event_append" "', argument " "6"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_append" "', argument " "6"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Event_append" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (int)(arg1)->append(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_append__SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  Pythia8::Vec4 arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Event_append",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_append" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_append" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_append" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_append" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Event_append" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Event_append" "', argument " "6"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_append" "', argument " "6"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  result = (int)(arg1)->append(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_append(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[17] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 16) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Particle, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Event_append__SWIG_0(self, args);
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Event_append__SWIG_16(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Event_append__SWIG_15(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Event_append__SWIG_14(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Event_append__SWIG_13(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Event_append__SWIG_12(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_Event_append__SWIG_8(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_Event_append__SWIG_11(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_Event_append__SWIG_7(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_Event_append__SWIG_10(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Event_append__SWIG_6(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_Event_append__SWIG_9(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Event_append__SWIG_5(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_Event_append__SWIG_4(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_Event_append__SWIG_3(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_Event_append__SWIG_2(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_Event_append__SWIG_1(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Event_append'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Event::append(Pythia8::Particle)\n"
    "    Pythia8::Event::append(int,int,int,int,int,int,int,int,double,double,double,double,double,double,double)\n"
    "    Pythia8::Event::append(int,int,int,int,int,int,int,int,double,double,double,double,double,double)\n"
    "    Pythia8::Event::append(int,int,int,int,int,int,int,int,double,double,double,double,double)\n"
    "    Pythia8::Event::append(int,int,int,int,int,int,int,int,double,double,double,double)\n"
    "    Pythia8::Event::append(int,int,int,int,int,int,int,int,Pythia8::Vec4,double,double,double)\n"
    "    Pythia8::Event::append(int,int,int,int,int,int,int,int,Pythia8::Vec4,double,double)\n"
    "    Pythia8::Event::append(int,int,int,int,int,int,int,int,Pythia8::Vec4,double)\n"
    "    Pythia8::Event::append(int,int,int,int,int,int,int,int,Pythia8::Vec4)\n"
    "    Pythia8::Event::append(int,int,int,int,double,double,double,double,double,double,double)\n"
    "    Pythia8::Event::append(int,int,int,int,double,double,double,double,double,double)\n"
    "    Pythia8::Event::append(int,int,int,int,double,double,double,double,double)\n"
    "    Pythia8::Event::append(int,int,int,int,double,double,double,double)\n"
    "    Pythia8::Event::append(int,int,int,int,Pythia8::Vec4,double,double,double)\n"
    "    Pythia8::Event::append(int,int,int,int,Pythia8::Vec4,double,double)\n"
    "    Pythia8::Event::append(int,int,int,int,Pythia8::Vec4,double)\n"
    "    Pythia8::Event::append(int,int,int,int,Pythia8::Vec4)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Event_setEvtPtr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Event_setEvtPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_setEvtPtr" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_setEvtPtr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setEvtPtr(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_setEvtPtr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Event_setEvtPtr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_setEvtPtr" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  (arg1)->setEvtPtr();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_setEvtPtr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Event_setEvtPtr__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Event_setEvtPtr__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Event_setEvtPtr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Event::setEvtPtr(int)\n"
    "    Pythia8::Event::setEvtPtr()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Event_copy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Event_copy",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_copy" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_copy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_copy" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->copy(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_copy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Event_copy",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_copy" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_copy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->copy(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_copy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Event_copy__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Event_copy__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Event_copy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Event::copy(int,int)\n"
    "    Pythia8::Event::copy(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Event_popBack__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Event_popBack",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_popBack" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_popBack" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->popBack(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_popBack__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Event_popBack",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_popBack" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  (arg1)->popBack();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_popBack(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Event_popBack__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Event_popBack__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Event_popBack'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Event::popBack(int)\n"
    "    Pythia8::Event::popBack()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Event_remove__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Event_remove",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_remove" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_remove" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_remove" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_remove" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->remove(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_remove__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Event_remove",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_remove" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_remove" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_remove" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->remove(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_remove(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Event_remove__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Event_remove__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Event_remove'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Event::remove(int,int,bool)\n"
    "    Pythia8::Event::remove(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Event_restorePtrs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Event_restorePtrs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_restorePtrs" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  (arg1)->restorePtrs();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_saveSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Event_saveSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_saveSize" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  (arg1)->saveSize();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_restoreSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Event_restoreSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_restoreSize" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  (arg1)->restoreSize();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_savedSizeValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Event_savedSizeValue",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_savedSizeValue" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  result = (int)(arg1)->savedSizeValue();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_initColTag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Event_initColTag",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_initColTag" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_initColTag" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->initColTag(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_initColTag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Event_initColTag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_initColTag" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  (arg1)->initColTag();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_initColTag(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Event_initColTag__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Event_initColTag__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Event_initColTag'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Event::initColTag(int)\n"
    "    Pythia8::Event::initColTag()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Event_lastColTag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Event_lastColTag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_lastColTag" "', argument " "1"" of type '" "Pythia8::Event const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  result = (int)((Pythia8::Event const *)arg1)->lastColTag();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_nextColTag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Event_nextColTag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_nextColTag" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  result = (int)(arg1)->nextColTag();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Event_scale",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_scale" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_scale" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->scale(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Event_scale",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_scale" "', argument " "1"" of type '" "Pythia8::Event const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  result = (double)((Pythia8::Event const *)arg1)->scale();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_scale(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Event_scale__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Event_scale__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Event_scale'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Event::scale(double)\n"
    "    Pythia8::Event::scale() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Event_scaleSecond__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Event_scaleSecond",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_scaleSecond" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_scaleSecond" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->scaleSecond(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_scaleSecond__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Event_scaleSecond",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_scaleSecond" "', argument " "1"" of type '" "Pythia8::Event const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  result = (double)((Pythia8::Event const *)arg1)->scaleSecond();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_scaleSecond(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Event_scaleSecond__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Event_scaleSecond__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Event_scaleSecond'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Event::scaleSecond(double)\n"
    "    Pythia8::Event::scaleSecond() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Event_daughterList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< int,std::allocator< int > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Event_daughterList",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_daughterList" "', argument " "1"" of type '" "Pythia8::Event const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_daughterList" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((Pythia8::Event const *)arg1)->daughterList(arg2);
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_rot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Event_rot",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_rot" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_rot" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_rot" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->rot(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_bst__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Event_bst",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_bst" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_bst" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_bst" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_bst" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->bst(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_bst__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Event_bst",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_bst" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_bst" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_bst" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_bst" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Event_bst" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  (arg1)->bst(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_bst__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Event_bst",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_bst" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_bst" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_bst" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  (arg1)->bst((Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_bst(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Event_bst__SWIG_2(self, args);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Event_bst__SWIG_0(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Event_bst__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Event_bst'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Event::bst(double,double,double)\n"
    "    Pythia8::Event::bst(double,double,double,double)\n"
    "    Pythia8::Event::bst(Pythia8::Vec4 const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Event_rotbst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  Pythia8::RotBstMatrix *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Event_rotbst",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_rotbst" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__RotBstMatrix,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_rotbst" "', argument " "2"" of type '" "Pythia8::RotBstMatrix const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_rotbst" "', argument " "2"" of type '" "Pythia8::RotBstMatrix const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp2);
  (arg1)->rotbst((Pythia8::RotBstMatrix const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_clearJunctions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Event_clearJunctions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_clearJunctions" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  (arg1)->clearJunctions();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_appendJunction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Event_appendJunction",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_appendJunction" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_appendJunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_appendJunction" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_appendJunction" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Event_appendJunction" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (int)(arg1)->appendJunction(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_appendJunction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  Pythia8::Junction arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Event_appendJunction",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_appendJunction" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Junction,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_appendJunction" "', argument " "2"" of type '" "Pythia8::Junction""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event_appendJunction" "', argument " "2"" of type '" "Pythia8::Junction""'");
    } else {
      Pythia8::Junction * temp = reinterpret_cast< Pythia8::Junction * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (int)(arg1)->appendJunction(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_appendJunction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Junction, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Event_appendJunction__SWIG_1(self, args);
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Event_appendJunction__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Event_appendJunction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Event::appendJunction(int,int,int,int)\n"
    "    Pythia8::Event::appendJunction(Pythia8::Junction)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Event_sizeJunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Event_sizeJunction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_sizeJunction" "', argument " "1"" of type '" "Pythia8::Event const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  result = (int)((Pythia8::Event const *)arg1)->sizeJunction();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_remainsJunction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Event_remainsJunction",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_remainsJunction" "', argument " "1"" of type '" "Pythia8::Event const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_remainsJunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)((Pythia8::Event const *)arg1)->remainsJunction(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_remainsJunction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Event_remainsJunction",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_remainsJunction" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_remainsJunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_remainsJunction" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->remainsJunction(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_remainsJunction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Event_remainsJunction__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Event_remainsJunction__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Event_remainsJunction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Event::remainsJunction(int) const\n"
    "    Pythia8::Event::remainsJunction(int,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Event_kindJunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Event_kindJunction",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_kindJunction" "', argument " "1"" of type '" "Pythia8::Event const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_kindJunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::Event const *)arg1)->kindJunction(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_colJunction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Event_colJunction",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_colJunction" "', argument " "1"" of type '" "Pythia8::Event const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_colJunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_colJunction" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)((Pythia8::Event const *)arg1)->colJunction(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_colJunction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Event_colJunction",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_colJunction" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_colJunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_colJunction" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_colJunction" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->colJunction(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_colJunction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Event_colJunction__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Event_colJunction__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Event_colJunction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Event::colJunction(int,int) const\n"
    "    Pythia8::Event::colJunction(int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Event_endColJunction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Event_endColJunction",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_endColJunction" "', argument " "1"" of type '" "Pythia8::Event const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_endColJunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_endColJunction" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)((Pythia8::Event const *)arg1)->endColJunction(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_endColJunction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Event_endColJunction",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_endColJunction" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_endColJunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_endColJunction" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_endColJunction" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->endColJunction(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_endColJunction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Event_endColJunction__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Event_endColJunction__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Event_endColJunction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Event::endColJunction(int,int) const\n"
    "    Pythia8::Event::endColJunction(int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Event_statusJunction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Event_statusJunction",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_statusJunction" "', argument " "1"" of type '" "Pythia8::Event const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_statusJunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_statusJunction" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)((Pythia8::Event const *)arg1)->statusJunction(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_statusJunction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Event_statusJunction",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_statusJunction" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_statusJunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Event_statusJunction" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Event_statusJunction" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->statusJunction(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_statusJunction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Event_statusJunction__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Event_statusJunction__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Event_statusJunction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Event::statusJunction(int,int) const\n"
    "    Pythia8::Event::statusJunction(int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Event_getJunction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Junction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Event_getJunction",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_getJunction" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_getJunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::Junction *) &(arg1)->getJunction(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Junction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_getJunction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Junction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Event_getJunction",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_getJunction" "', argument " "1"" of type '" "Pythia8::Event const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_getJunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::Junction *) &((Pythia8::Event const *)arg1)->getJunction(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Junction, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_getJunction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Event_getJunction__SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Event_getJunction__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Event_getJunction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Event::getJunction(int)\n"
    "    Pythia8::Event::getJunction(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Event_eraseJunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Event_eraseJunction",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_eraseJunction" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_eraseJunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->eraseJunction(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_saveJunctionSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Event_saveJunctionSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_saveJunctionSize" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  (arg1)->saveJunctionSize();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_restoreJunctionSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Event_restoreJunctionSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_restoreJunctionSize" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  (arg1)->restoreJunctionSize();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_listJunctions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Event_listJunctions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_listJunctions" "', argument " "1"" of type '" "Pythia8::Event const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ((Pythia8::Event const *)arg1)->listJunctions();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event_savePartonLevelSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Event_savePartonLevelSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_savePartonLevelSize" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  (arg1)->savePartonLevelSize();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Event *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Event___iadd__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event___iadd__" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event___iadd__" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event___iadd__" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (Pythia8::Event *) &(arg1)->operator +=((Pythia8::Event const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Event, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Event___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event___str__" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  result = Pythia8_Event___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Event___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Event___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event___getitem__" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    assert(!EVENT_ERROR); result = (Pythia8::Particle *)Pythia8_Event___getitem__(arg1,arg2);
    if (EVENT_ERROR) {
      EVENT_ERROR = 0;
      SWIG_exception(SWIG_IndexError, "Index out of bounds");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Event",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Event, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FlavContainer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::FlavContainer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_FlavContainer",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlavContainer" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlavContainer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlavContainer" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlavContainer" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FlavContainer" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (Pythia8::FlavContainer *)new Pythia8::FlavContainer(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__FlavContainer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlavContainer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::FlavContainer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_FlavContainer",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlavContainer" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlavContainer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlavContainer" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlavContainer" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (Pythia8::FlavContainer *)new Pythia8::FlavContainer(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__FlavContainer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlavContainer__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::FlavContainer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_FlavContainer",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlavContainer" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlavContainer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlavContainer" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::FlavContainer *)new Pythia8::FlavContainer(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__FlavContainer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlavContainer__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::FlavContainer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_FlavContainer",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlavContainer" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlavContainer" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::FlavContainer *)new Pythia8::FlavContainer(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__FlavContainer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlavContainer__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::FlavContainer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_FlavContainer",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlavContainer" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::FlavContainer *)new Pythia8::FlavContainer(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__FlavContainer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlavContainer__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FlavContainer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FlavContainer")) SWIG_fail;
  result = (Pythia8::FlavContainer *)new Pythia8::FlavContainer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__FlavContainer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_FlavContainer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_FlavContainer__SWIG_5(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_FlavContainer__SWIG_4(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_FlavContainer__SWIG_3(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FlavContainer__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FlavContainer__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_FlavContainer__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FlavContainer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::FlavContainer::FlavContainer(int,int,int,int,int)\n"
    "    Pythia8::FlavContainer::FlavContainer(int,int,int,int)\n"
    "    Pythia8::FlavContainer::FlavContainer(int,int,int)\n"
    "    Pythia8::FlavContainer::FlavContainer(int,int)\n"
    "    Pythia8::FlavContainer::FlavContainer(int)\n"
    "    Pythia8::FlavContainer::FlavContainer()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FlavContainer_anti__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FlavContainer *arg1 = (Pythia8::FlavContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::FlavContainer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FlavContainer_anti",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FlavContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlavContainer_anti" "', argument " "1"" of type '" "Pythia8::FlavContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FlavContainer * >(argp1);
  result = (Pythia8::FlavContainer *) &(arg1)->anti();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__FlavContainer, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FlavContainer_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FlavContainer *arg1 = (Pythia8::FlavContainer *) 0 ;
  Pythia8::FlavContainer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::FlavContainer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FlavContainer_copy",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FlavContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlavContainer_copy" "', argument " "1"" of type '" "Pythia8::FlavContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FlavContainer * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__FlavContainer,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FlavContainer_copy" "', argument " "2"" of type '" "Pythia8::FlavContainer const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FlavContainer_copy" "', argument " "2"" of type '" "Pythia8::FlavContainer const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::FlavContainer * >(argp2);
  result = (Pythia8::FlavContainer *) &(arg1)->copy((Pythia8::FlavContainer const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__FlavContainer, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FlavContainer_anti__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FlavContainer *arg1 = (Pythia8::FlavContainer *) 0 ;
  Pythia8::FlavContainer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::FlavContainer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FlavContainer_anti",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FlavContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlavContainer_anti" "', argument " "1"" of type '" "Pythia8::FlavContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FlavContainer * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__FlavContainer,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FlavContainer_anti" "', argument " "2"" of type '" "Pythia8::FlavContainer const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FlavContainer_anti" "', argument " "2"" of type '" "Pythia8::FlavContainer const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::FlavContainer * >(argp2);
  result = (Pythia8::FlavContainer *) &(arg1)->anti((Pythia8::FlavContainer const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__FlavContainer, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FlavContainer_anti(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__FlavContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FlavContainer_anti__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__FlavContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__FlavContainer, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FlavContainer_anti__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FlavContainer_anti'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::FlavContainer::anti()\n"
    "    Pythia8::FlavContainer::anti(Pythia8::FlavContainer const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_FlavContainer_isDiquark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FlavContainer *arg1 = (Pythia8::FlavContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FlavContainer_isDiquark",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FlavContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlavContainer_isDiquark" "', argument " "1"" of type '" "Pythia8::FlavContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FlavContainer * >(argp1);
  result = (bool)(arg1)->isDiquark();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FlavContainer_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FlavContainer *arg1 = (Pythia8::FlavContainer *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FlavContainer_id_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FlavContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlavContainer_id_set" "', argument " "1"" of type '" "Pythia8::FlavContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FlavContainer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlavContainer_id_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FlavContainer_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FlavContainer *arg1 = (Pythia8::FlavContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FlavContainer_id_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FlavContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlavContainer_id_get" "', argument " "1"" of type '" "Pythia8::FlavContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FlavContainer * >(argp1);
  result = (int) ((arg1)->id);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FlavContainer_rank_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FlavContainer *arg1 = (Pythia8::FlavContainer *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FlavContainer_rank_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FlavContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlavContainer_rank_set" "', argument " "1"" of type '" "Pythia8::FlavContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FlavContainer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlavContainer_rank_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->rank = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FlavContainer_rank_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FlavContainer *arg1 = (Pythia8::FlavContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FlavContainer_rank_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FlavContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlavContainer_rank_get" "', argument " "1"" of type '" "Pythia8::FlavContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FlavContainer * >(argp1);
  result = (int) ((arg1)->rank);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FlavContainer_nPop_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FlavContainer *arg1 = (Pythia8::FlavContainer *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FlavContainer_nPop_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FlavContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlavContainer_nPop_set" "', argument " "1"" of type '" "Pythia8::FlavContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FlavContainer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlavContainer_nPop_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->nPop = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FlavContainer_nPop_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FlavContainer *arg1 = (Pythia8::FlavContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FlavContainer_nPop_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FlavContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlavContainer_nPop_get" "', argument " "1"" of type '" "Pythia8::FlavContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FlavContainer * >(argp1);
  result = (int) ((arg1)->nPop);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FlavContainer_idPop_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FlavContainer *arg1 = (Pythia8::FlavContainer *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FlavContainer_idPop_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FlavContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlavContainer_idPop_set" "', argument " "1"" of type '" "Pythia8::FlavContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FlavContainer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlavContainer_idPop_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->idPop = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FlavContainer_idPop_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FlavContainer *arg1 = (Pythia8::FlavContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FlavContainer_idPop_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FlavContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlavContainer_idPop_get" "', argument " "1"" of type '" "Pythia8::FlavContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FlavContainer * >(argp1);
  result = (int) ((arg1)->idPop);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FlavContainer_idVtx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FlavContainer *arg1 = (Pythia8::FlavContainer *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FlavContainer_idVtx_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FlavContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlavContainer_idVtx_set" "', argument " "1"" of type '" "Pythia8::FlavContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FlavContainer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlavContainer_idVtx_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->idVtx = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FlavContainer_idVtx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FlavContainer *arg1 = (Pythia8::FlavContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:FlavContainer_idVtx_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FlavContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlavContainer_idVtx_get" "', argument " "1"" of type '" "Pythia8::FlavContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FlavContainer * >(argp1);
  result = (int) ((arg1)->idVtx);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FlavContainer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FlavContainer *arg1 = (Pythia8::FlavContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FlavContainer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FlavContainer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FlavContainer" "', argument " "1"" of type '" "Pythia8::FlavContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FlavContainer * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FlavContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__FlavContainer, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_StringFlav(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFlav *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StringFlav")) SWIG_fail;
  result = (Pythia8::StringFlav *)new Pythia8::StringFlav();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__StringFlav, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StringFlav(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFlav *arg1 = (Pythia8::StringFlav *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StringFlav",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFlav, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StringFlav" "', argument " "1"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFlav * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFlav_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFlav *arg1 = (Pythia8::StringFlav *) 0 ;
  Pythia8::Settings *arg2 = 0 ;
  Pythia8::ParticleData *arg3 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg4 = (Pythia8::Rndm *) 0 ;
  Pythia8::Info *arg5 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:StringFlav_init",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFlav_init" "', argument " "1"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFlav * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringFlav_init" "', argument " "2"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFlav_init" "', argument " "2"" of type '" "Pythia8::Settings &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringFlav_init" "', argument " "3"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ParticleData * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StringFlav_init" "', argument " "4"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Rndm * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "StringFlav_init" "', argument " "5"" of type '" "Pythia8::Info *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Info * >(argp5);
  (arg1)->init(*arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFlav_pickLightQ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFlav *arg1 = (Pythia8::StringFlav *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringFlav_pickLightQ",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFlav_pickLightQ" "', argument " "1"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFlav * >(argp1);
  result = (int)(arg1)->pickLightQ();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFlav_pick__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFlav *arg1 = (Pythia8::StringFlav *) 0 ;
  Pythia8::FlavContainer *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::FlavContainer result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:StringFlav_pick",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFlav_pick" "', argument " "1"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFlav * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__FlavContainer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringFlav_pick" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFlav_pick" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::FlavContainer * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringFlav_pick" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StringFlav_pick" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (arg1)->pick(*arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj((new Pythia8::FlavContainer(static_cast< const Pythia8::FlavContainer& >(result))), SWIGTYPE_p_Pythia8__FlavContainer, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFlav_pick__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFlav *arg1 = (Pythia8::StringFlav *) 0 ;
  Pythia8::FlavContainer *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::FlavContainer result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:StringFlav_pick",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFlav_pick" "', argument " "1"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFlav * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__FlavContainer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringFlav_pick" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFlav_pick" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::FlavContainer * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringFlav_pick" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (arg1)->pick(*arg2,arg3);
  resultobj = SWIG_NewPointerObj((new Pythia8::FlavContainer(static_cast< const Pythia8::FlavContainer& >(result))), SWIGTYPE_p_Pythia8__FlavContainer, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFlav_pick__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFlav *arg1 = (Pythia8::StringFlav *) 0 ;
  Pythia8::FlavContainer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::FlavContainer result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringFlav_pick",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFlav_pick" "', argument " "1"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFlav * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__FlavContainer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringFlav_pick" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFlav_pick" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::FlavContainer * >(argp2);
  result = (arg1)->pick(*arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::FlavContainer(static_cast< const Pythia8::FlavContainer& >(result))), SWIGTYPE_p_Pythia8__FlavContainer, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFlav_pick(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringFlav, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__FlavContainer, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StringFlav_pick__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringFlav, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__FlavContainer, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StringFlav_pick__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringFlav, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__FlavContainer, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_StringFlav_pick__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'StringFlav_pick'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::StringFlav::pick(Pythia8::FlavContainer &,double,double)\n"
    "    Pythia8::StringFlav::pick(Pythia8::FlavContainer &,double)\n"
    "    Pythia8::StringFlav::pick(Pythia8::FlavContainer &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringFlav_pickGauss(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFlav *arg1 = (Pythia8::StringFlav *) 0 ;
  Pythia8::FlavContainer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::FlavContainer result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringFlav_pickGauss",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFlav_pickGauss" "', argument " "1"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFlav * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__FlavContainer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringFlav_pickGauss" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFlav_pickGauss" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::FlavContainer * >(argp2);
  result = (arg1)->pickGauss(*arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::FlavContainer(static_cast< const Pythia8::FlavContainer& >(result))), SWIGTYPE_p_Pythia8__FlavContainer, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFlav_pickThermal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFlav *arg1 = (Pythia8::StringFlav *) 0 ;
  Pythia8::FlavContainer *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::FlavContainer result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:StringFlav_pickThermal",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFlav_pickThermal" "', argument " "1"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFlav * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__FlavContainer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringFlav_pickThermal" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFlav_pickThermal" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::FlavContainer * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringFlav_pickThermal" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StringFlav_pickThermal" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (arg1)->pickThermal(*arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj((new Pythia8::FlavContainer(static_cast< const Pythia8::FlavContainer& >(result))), SWIGTYPE_p_Pythia8__FlavContainer, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFlav_combine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFlav *arg1 = (Pythia8::StringFlav *) 0 ;
  Pythia8::FlavContainer *arg2 = 0 ;
  Pythia8::FlavContainer *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:StringFlav_combine",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFlav_combine" "', argument " "1"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFlav * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__FlavContainer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringFlav_combine" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFlav_combine" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::FlavContainer * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__FlavContainer,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringFlav_combine" "', argument " "3"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFlav_combine" "', argument " "3"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::FlavContainer * >(argp3);
  result = (int)(arg1)->combine(*arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFlav_combineId__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFlav *arg1 = (Pythia8::StringFlav *) 0 ;
  int arg2 ;
  int arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:StringFlav_combineId",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFlav_combineId" "', argument " "1"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFlav * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringFlav_combineId" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringFlav_combineId" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StringFlav_combineId" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (int)(arg1)->combineId(arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFlav_combineId__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFlav *arg1 = (Pythia8::StringFlav *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:StringFlav_combineId",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFlav_combineId" "', argument " "1"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFlav * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringFlav_combineId" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringFlav_combineId" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->combineId(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFlav_combineId(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringFlav, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StringFlav_combineId__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringFlav, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_StringFlav_combineId__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'StringFlav_combineId'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::StringFlav::combineId(int,int,bool)\n"
    "    Pythia8::StringFlav::combineId(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringFlav_getHadronIDwin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFlav *arg1 = (Pythia8::StringFlav *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringFlav_getHadronIDwin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFlav_getHadronIDwin" "', argument " "1"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFlav * >(argp1);
  result = (int)(arg1)->getHadronIDwin();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFlav_combineLastThermal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFlav *arg1 = (Pythia8::StringFlav *) 0 ;
  Pythia8::FlavContainer *arg2 = 0 ;
  Pythia8::FlavContainer *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:StringFlav_combineLastThermal",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFlav_combineLastThermal" "', argument " "1"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFlav * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__FlavContainer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringFlav_combineLastThermal" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFlav_combineLastThermal" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::FlavContainer * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__FlavContainer,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringFlav_combineLastThermal" "', argument " "3"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFlav_combineLastThermal" "', argument " "3"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::FlavContainer * >(argp3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StringFlav_combineLastThermal" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "StringFlav_combineLastThermal" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (int)(arg1)->combineLastThermal(*arg2,*arg3,arg4,arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFlav_getHadronID__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFlav *arg1 = (Pythia8::StringFlav *) 0 ;
  Pythia8::FlavContainer *arg2 = 0 ;
  Pythia8::FlavContainer *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:StringFlav_getHadronID",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFlav_getHadronID" "', argument " "1"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFlav * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__FlavContainer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringFlav_getHadronID" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFlav_getHadronID" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::FlavContainer * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__FlavContainer,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringFlav_getHadronID" "', argument " "3"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFlav_getHadronID" "', argument " "3"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::FlavContainer * >(argp3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StringFlav_getHadronID" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "StringFlav_getHadronID" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "StringFlav_getHadronID" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  result = (int)(arg1)->getHadronID(*arg2,*arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFlav_getHadronID__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFlav *arg1 = (Pythia8::StringFlav *) 0 ;
  Pythia8::FlavContainer *arg2 = 0 ;
  Pythia8::FlavContainer *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:StringFlav_getHadronID",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFlav_getHadronID" "', argument " "1"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFlav * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__FlavContainer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringFlav_getHadronID" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFlav_getHadronID" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::FlavContainer * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__FlavContainer,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringFlav_getHadronID" "', argument " "3"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFlav_getHadronID" "', argument " "3"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::FlavContainer * >(argp3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StringFlav_getHadronID" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "StringFlav_getHadronID" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (int)(arg1)->getHadronID(*arg2,*arg3,arg4,arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFlav_getHadronID__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFlav *arg1 = (Pythia8::StringFlav *) 0 ;
  Pythia8::FlavContainer *arg2 = 0 ;
  Pythia8::FlavContainer *arg3 = 0 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:StringFlav_getHadronID",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFlav_getHadronID" "', argument " "1"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFlav * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__FlavContainer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringFlav_getHadronID" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFlav_getHadronID" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::FlavContainer * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__FlavContainer,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringFlav_getHadronID" "', argument " "3"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFlav_getHadronID" "', argument " "3"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::FlavContainer * >(argp3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StringFlav_getHadronID" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (int)(arg1)->getHadronID(*arg2,*arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFlav_getHadronID__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFlav *arg1 = (Pythia8::StringFlav *) 0 ;
  Pythia8::FlavContainer *arg2 = 0 ;
  Pythia8::FlavContainer *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:StringFlav_getHadronID",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFlav_getHadronID" "', argument " "1"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFlav * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__FlavContainer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringFlav_getHadronID" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFlav_getHadronID" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::FlavContainer * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__FlavContainer,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringFlav_getHadronID" "', argument " "3"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFlav_getHadronID" "', argument " "3"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::FlavContainer * >(argp3);
  result = (int)(arg1)->getHadronID(*arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFlav_getHadronID(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringFlav, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__FlavContainer, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__FlavContainer, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StringFlav_getHadronID__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringFlav, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__FlavContainer, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__FlavContainer, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_StringFlav_getHadronID__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringFlav, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__FlavContainer, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__FlavContainer, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_StringFlav_getHadronID__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringFlav, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__FlavContainer, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__FlavContainer, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_StringFlav_getHadronID__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'StringFlav_getHadronID'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::StringFlav::getHadronID(Pythia8::FlavContainer &,Pythia8::FlavContainer &,double,double,bool)\n"
    "    Pythia8::StringFlav::getHadronID(Pythia8::FlavContainer &,Pythia8::FlavContainer &,double,double)\n"
    "    Pythia8::StringFlav::getHadronID(Pythia8::FlavContainer &,Pythia8::FlavContainer &,double)\n"
    "    Pythia8::StringFlav::getHadronID(Pythia8::FlavContainer &,Pythia8::FlavContainer &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringFlav_getHadronMassWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFlav *arg1 = (Pythia8::StringFlav *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringFlav_getHadronMassWin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFlav_getHadronMassWin" "', argument " "1"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFlav * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringFlav_getHadronMassWin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->getHadronMassWin(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFlav_assignPopQ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFlav *arg1 = (Pythia8::StringFlav *) 0 ;
  Pythia8::FlavContainer *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringFlav_assignPopQ",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFlav_assignPopQ" "', argument " "1"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFlav * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__FlavContainer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringFlav_assignPopQ" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFlav_assignPopQ" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::FlavContainer * >(argp2);
  (arg1)->assignPopQ(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFlav_makeDiquark__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFlav *arg1 = (Pythia8::StringFlav *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:StringFlav_makeDiquark",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFlav_makeDiquark" "', argument " "1"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFlav * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringFlav_makeDiquark" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringFlav_makeDiquark" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StringFlav_makeDiquark" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (int)(arg1)->makeDiquark(arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFlav_makeDiquark__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFlav *arg1 = (Pythia8::StringFlav *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:StringFlav_makeDiquark",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFlav_makeDiquark" "', argument " "1"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFlav * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringFlav_makeDiquark" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringFlav_makeDiquark" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)(arg1)->makeDiquark(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFlav_makeDiquark(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringFlav, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StringFlav_makeDiquark__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringFlav, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_StringFlav_makeDiquark__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'StringFlav_makeDiquark'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::StringFlav::makeDiquark(int,int,int)\n"
    "    Pythia8::StringFlav::makeDiquark(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringFlav_addQuarkDiquark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFlav *arg1 = (Pythia8::StringFlav *) 0 ;
  std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:StringFlav_addQuarkDiquark",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFlav_addQuarkDiquark" "', argument " "1"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFlav * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringFlav_addQuarkDiquark" "', argument " "2"" of type '" "std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFlav_addQuarkDiquark" "', argument " "2"" of type '" "std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringFlav_addQuarkDiquark" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StringFlav_addQuarkDiquark" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "StringFlav_addQuarkDiquark" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  (arg1)->addQuarkDiquark(*arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFlav_getMesonSpinCounter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFlav *arg1 = (Pythia8::StringFlav *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringFlav_getMesonSpinCounter",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFlav_getMesonSpinCounter" "', argument " "1"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFlav * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringFlav_getMesonSpinCounter" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->getMesonSpinCounter(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StringFlav_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__StringFlav, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LundFFRaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LundFFRaw *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LundFFRaw")) SWIG_fail;
  result = (Pythia8::LundFFRaw *)new Pythia8::LundFFRaw();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LundFFRaw, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LundFFRaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LundFFRaw *arg1 = (Pythia8::LundFFRaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LundFFRaw",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LundFFRaw, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LundFFRaw" "', argument " "1"" of type '" "Pythia8::LundFFRaw *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LundFFRaw * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LundFFRaw_f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LundFFRaw *arg1 = (Pythia8::LundFFRaw *) 0 ;
  std::vector< double,std::allocator< double > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LundFFRaw_f",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LundFFRaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LundFFRaw_f" "', argument " "1"" of type '" "Pythia8::LundFFRaw *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LundFFRaw * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LundFFRaw_f" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->f(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LundFFRaw_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__LundFFRaw, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LundFFAvg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LundFFAvg *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LundFFAvg")) SWIG_fail;
  result = (Pythia8::LundFFAvg *)new Pythia8::LundFFAvg();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LundFFAvg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LundFFAvg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LundFFAvg *arg1 = (Pythia8::LundFFAvg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LundFFAvg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LundFFAvg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LundFFAvg" "', argument " "1"" of type '" "Pythia8::LundFFAvg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LundFFAvg * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LundFFAvg_f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LundFFAvg *arg1 = (Pythia8::LundFFAvg *) 0 ;
  std::vector< double,std::allocator< double > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LundFFAvg_f",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LundFFAvg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LundFFAvg_f" "', argument " "1"" of type '" "Pythia8::LundFFAvg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LundFFAvg * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LundFFAvg_f" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->f(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LundFFAvg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__LundFFAvg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_StringZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringZ *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StringZ")) SWIG_fail;
  result = (Pythia8::StringZ *)new Pythia8::StringZ();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__StringZ, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StringZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringZ *arg1 = (Pythia8::StringZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StringZ",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringZ, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StringZ" "', argument " "1"" of type '" "Pythia8::StringZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringZ * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringZ_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringZ *arg1 = (Pythia8::StringZ *) 0 ;
  Pythia8::Settings *arg2 = 0 ;
  Pythia8::ParticleData *arg3 = 0 ;
  Pythia8::Rndm *arg4 = (Pythia8::Rndm *) 0 ;
  Pythia8::Info *arg5 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:StringZ_init",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringZ_init" "', argument " "1"" of type '" "Pythia8::StringZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringZ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringZ_init" "', argument " "2"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringZ_init" "', argument " "2"" of type '" "Pythia8::Settings &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__ParticleData,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringZ_init" "', argument " "3"" of type '" "Pythia8::ParticleData &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringZ_init" "', argument " "3"" of type '" "Pythia8::ParticleData &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ParticleData * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StringZ_init" "', argument " "4"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Rndm * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "StringZ_init" "', argument " "5"" of type '" "Pythia8::Info *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Info * >(argp5);
  (arg1)->init(*arg2,*arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringZ_zFrag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringZ *arg1 = (Pythia8::StringZ *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:StringZ_zFrag",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringZ_zFrag" "', argument " "1"" of type '" "Pythia8::StringZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringZ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringZ_zFrag" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringZ_zFrag" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StringZ_zFrag" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->zFrag(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringZ_zFrag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringZ *arg1 = (Pythia8::StringZ *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:StringZ_zFrag",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringZ_zFrag" "', argument " "1"" of type '" "Pythia8::StringZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringZ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringZ_zFrag" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringZ_zFrag" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)(arg1)->zFrag(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringZ_zFrag__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringZ *arg1 = (Pythia8::StringZ *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringZ_zFrag",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringZ_zFrag" "', argument " "1"" of type '" "Pythia8::StringZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringZ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringZ_zFrag" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->zFrag(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringZ_zFrag(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringZ, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringZ_zFrag__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringZ, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StringZ_zFrag__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringZ, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_StringZ_zFrag__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'StringZ_zFrag'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::StringZ::zFrag(int,int,double)\n"
    "    Pythia8::StringZ::zFrag(int,int)\n"
    "    Pythia8::StringZ::zFrag(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringZ_stopMass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringZ *arg1 = (Pythia8::StringZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringZ_stopMass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringZ_stopMass" "', argument " "1"" of type '" "Pythia8::StringZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringZ * >(argp1);
  result = (double)(arg1)->stopMass();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringZ_stopNewFlav(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringZ *arg1 = (Pythia8::StringZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringZ_stopNewFlav",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringZ_stopNewFlav" "', argument " "1"" of type '" "Pythia8::StringZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringZ * >(argp1);
  result = (double)(arg1)->stopNewFlav();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringZ_stopSmear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringZ *arg1 = (Pythia8::StringZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringZ_stopSmear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringZ_stopSmear" "', argument " "1"" of type '" "Pythia8::StringZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringZ * >(argp1);
  result = (double)(arg1)->stopSmear();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringZ_aAreaLund(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringZ *arg1 = (Pythia8::StringZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringZ_aAreaLund",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringZ_aAreaLund" "', argument " "1"" of type '" "Pythia8::StringZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringZ * >(argp1);
  result = (double)(arg1)->aAreaLund();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringZ_bAreaLund(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringZ *arg1 = (Pythia8::StringZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringZ_bAreaLund",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringZ_bAreaLund" "', argument " "1"" of type '" "Pythia8::StringZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringZ * >(argp1);
  result = (double)(arg1)->bAreaLund();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringZ_deriveBLund(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringZ *arg1 = (Pythia8::StringZ *) 0 ;
  Pythia8::Settings *arg2 = 0 ;
  Pythia8::ParticleData *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:StringZ_deriveBLund",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringZ_deriveBLund" "', argument " "1"" of type '" "Pythia8::StringZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringZ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringZ_deriveBLund" "', argument " "2"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringZ_deriveBLund" "', argument " "2"" of type '" "Pythia8::Settings &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__ParticleData,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringZ_deriveBLund" "', argument " "3"" of type '" "Pythia8::ParticleData &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringZ_deriveBLund" "', argument " "3"" of type '" "Pythia8::ParticleData &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ParticleData * >(argp3);
  result = (bool)(arg1)->deriveBLund(*arg2,*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StringZ_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__StringZ, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_StringPT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringPT *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StringPT")) SWIG_fail;
  result = (Pythia8::StringPT *)new Pythia8::StringPT();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__StringPT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StringPT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringPT *arg1 = (Pythia8::StringPT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StringPT",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringPT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StringPT" "', argument " "1"" of type '" "Pythia8::StringPT *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringPT * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringPT_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringPT *arg1 = (Pythia8::StringPT *) 0 ;
  Pythia8::Settings *arg2 = 0 ;
  Pythia8::ParticleData *arg3 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg4 = (Pythia8::Rndm *) 0 ;
  Pythia8::Info *arg5 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:StringPT_init",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringPT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringPT_init" "', argument " "1"" of type '" "Pythia8::StringPT *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringPT * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringPT_init" "', argument " "2"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringPT_init" "', argument " "2"" of type '" "Pythia8::Settings &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringPT_init" "', argument " "3"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ParticleData * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StringPT_init" "', argument " "4"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Rndm * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "StringPT_init" "', argument " "5"" of type '" "Pythia8::Info *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Info * >(argp5);
  (arg1)->init(*arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringPT_pxy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringPT *arg1 = (Pythia8::StringPT *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigValueWrapper< std::pair< double,double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:StringPT_pxy",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringPT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringPT_pxy" "', argument " "1"" of type '" "Pythia8::StringPT *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringPT * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringPT_pxy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringPT_pxy" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (arg1)->pxy(arg2,arg3);
  resultobj = SWIG_NewPointerObj((new std::pair< double,double >(static_cast< const std::pair< double,double >& >(result))), SWIGTYPE_p_std__pairT_double_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringPT_pxy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringPT *arg1 = (Pythia8::StringPT *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigValueWrapper< std::pair< double,double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringPT_pxy",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringPT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringPT_pxy" "', argument " "1"" of type '" "Pythia8::StringPT *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringPT * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringPT_pxy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (arg1)->pxy(arg2);
  resultobj = SWIG_NewPointerObj((new std::pair< double,double >(static_cast< const std::pair< double,double >& >(result))), SWIGTYPE_p_std__pairT_double_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringPT_pxy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringPT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringPT_pxy__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringPT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StringPT_pxy__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'StringPT_pxy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::StringPT::pxy(int,double)\n"
    "    Pythia8::StringPT::pxy(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringPT_pxyGauss__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringPT *arg1 = (Pythia8::StringPT *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigValueWrapper< std::pair< double,double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:StringPT_pxyGauss",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringPT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringPT_pxyGauss" "', argument " "1"" of type '" "Pythia8::StringPT *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringPT * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringPT_pxyGauss" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringPT_pxyGauss" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (arg1)->pxyGauss(arg2,arg3);
  resultobj = SWIG_NewPointerObj((new std::pair< double,double >(static_cast< const std::pair< double,double >& >(result))), SWIGTYPE_p_std__pairT_double_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringPT_pxyGauss__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringPT *arg1 = (Pythia8::StringPT *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigValueWrapper< std::pair< double,double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringPT_pxyGauss",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringPT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringPT_pxyGauss" "', argument " "1"" of type '" "Pythia8::StringPT *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringPT * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringPT_pxyGauss" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (arg1)->pxyGauss(arg2);
  resultobj = SWIG_NewPointerObj((new std::pair< double,double >(static_cast< const std::pair< double,double >& >(result))), SWIGTYPE_p_std__pairT_double_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringPT_pxyGauss__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringPT *arg1 = (Pythia8::StringPT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::pair< double,double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringPT_pxyGauss",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringPT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringPT_pxyGauss" "', argument " "1"" of type '" "Pythia8::StringPT *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringPT * >(argp1);
  result = (arg1)->pxyGauss();
  resultobj = SWIG_NewPointerObj((new std::pair< double,double >(static_cast< const std::pair< double,double >& >(result))), SWIGTYPE_p_std__pairT_double_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringPT_pxyGauss(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringPT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringPT_pxyGauss__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringPT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringPT_pxyGauss__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringPT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StringPT_pxyGauss__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'StringPT_pxyGauss'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::StringPT::pxyGauss(int,double)\n"
    "    Pythia8::StringPT::pxyGauss(int)\n"
    "    Pythia8::StringPT::pxyGauss()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringPT_pxyThermal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringPT *arg1 = (Pythia8::StringPT *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigValueWrapper< std::pair< double,double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:StringPT_pxyThermal",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringPT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringPT_pxyThermal" "', argument " "1"" of type '" "Pythia8::StringPT *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringPT * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringPT_pxyThermal" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringPT_pxyThermal" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (arg1)->pxyThermal(arg2,arg3);
  resultobj = SWIG_NewPointerObj((new std::pair< double,double >(static_cast< const std::pair< double,double >& >(result))), SWIGTYPE_p_std__pairT_double_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringPT_pxyThermal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringPT *arg1 = (Pythia8::StringPT *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigValueWrapper< std::pair< double,double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringPT_pxyThermal",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringPT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringPT_pxyThermal" "', argument " "1"" of type '" "Pythia8::StringPT *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringPT * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringPT_pxyThermal" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (arg1)->pxyThermal(arg2);
  resultobj = SWIG_NewPointerObj((new std::pair< double,double >(static_cast< const std::pair< double,double >& >(result))), SWIGTYPE_p_std__pairT_double_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringPT_pxyThermal(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringPT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringPT_pxyThermal__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringPT, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StringPT_pxyThermal__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'StringPT_pxyThermal'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::StringPT::pxyThermal(int,double)\n"
    "    Pythia8::StringPT::pxyThermal(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringPT_suppressPT2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringPT *arg1 = (Pythia8::StringPT *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringPT_suppressPT2",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringPT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringPT_suppressPT2" "', argument " "1"" of type '" "Pythia8::StringPT *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringPT * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringPT_suppressPT2" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->suppressPT2(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StringPT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__StringPT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ColSinglet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColSinglet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ColSinglet")) SWIG_fail;
  result = (Pythia8::ColSinglet *)new Pythia8::ColSinglet();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ColSinglet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ColSinglet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int,std::allocator< int > > *arg1 = 0 ;
  Pythia8::Vec4 arg2 ;
  double arg3 ;
  double arg4 ;
  bool arg5 ;
  bool arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Pythia8::ColSinglet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_ColSinglet",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ColSinglet" "', argument " "1"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ColSinglet" "', argument " "1"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ColSinglet" "', argument " "2"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ColSinglet" "', argument " "2"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ColSinglet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ColSinglet" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ColSinglet" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ColSinglet" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ColSinglet" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  result = (Pythia8::ColSinglet *)new Pythia8::ColSinglet(*arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ColSinglet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ColSinglet__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int,std::allocator< int > > *arg1 = 0 ;
  Pythia8::Vec4 arg2 ;
  double arg3 ;
  double arg4 ;
  bool arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::ColSinglet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_ColSinglet",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ColSinglet" "', argument " "1"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ColSinglet" "', argument " "1"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ColSinglet" "', argument " "2"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ColSinglet" "', argument " "2"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ColSinglet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ColSinglet" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ColSinglet" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ColSinglet" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  result = (Pythia8::ColSinglet *)new Pythia8::ColSinglet(*arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ColSinglet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ColSinglet__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int,std::allocator< int > > *arg1 = 0 ;
  Pythia8::Vec4 arg2 ;
  double arg3 ;
  double arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::ColSinglet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_ColSinglet",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ColSinglet" "', argument " "1"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ColSinglet" "', argument " "1"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ColSinglet" "', argument " "2"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ColSinglet" "', argument " "2"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ColSinglet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ColSinglet" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ColSinglet" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (Pythia8::ColSinglet *)new Pythia8::ColSinglet(*arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ColSinglet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ColSinglet__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int,std::allocator< int > > *arg1 = 0 ;
  Pythia8::Vec4 arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::ColSinglet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_ColSinglet",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ColSinglet" "', argument " "1"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ColSinglet" "', argument " "1"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ColSinglet" "', argument " "2"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ColSinglet" "', argument " "2"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ColSinglet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ColSinglet" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (Pythia8::ColSinglet *)new Pythia8::ColSinglet(*arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ColSinglet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ColSinglet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_ColSinglet__SWIG_0(self, args);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_ColSinglet__SWIG_4(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_ColSinglet__SWIG_3(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_ColSinglet__SWIG_2(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_ColSinglet__SWIG_1(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ColSinglet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ColSinglet::ColSinglet()\n"
    "    Pythia8::ColSinglet::ColSinglet(std::vector< int,std::allocator< int > > &,Pythia8::Vec4,double,double,bool,bool,bool)\n"
    "    Pythia8::ColSinglet::ColSinglet(std::vector< int,std::allocator< int > > &,Pythia8::Vec4,double,double,bool,bool)\n"
    "    Pythia8::ColSinglet::ColSinglet(std::vector< int,std::allocator< int > > &,Pythia8::Vec4,double,double,bool)\n"
    "    Pythia8::ColSinglet::ColSinglet(std::vector< int,std::allocator< int > > &,Pythia8::Vec4,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ColSinglet_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColSinglet *arg1 = (Pythia8::ColSinglet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColSinglet_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColSinglet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColSinglet_size" "', argument " "1"" of type '" "Pythia8::ColSinglet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColSinglet * >(argp1);
  result = (int)((Pythia8::ColSinglet const *)arg1)->size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColSinglet_iParton_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColSinglet *arg1 = (Pythia8::ColSinglet *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = (std::vector< int,std::allocator< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColSinglet_iParton_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColSinglet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColSinglet_iParton_set" "', argument " "1"" of type '" "Pythia8::ColSinglet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColSinglet * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColSinglet_iParton_set" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  if (arg1) (arg1)->iParton = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColSinglet_iParton_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColSinglet *arg1 = (Pythia8::ColSinglet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int,std::allocator< int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColSinglet_iParton_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColSinglet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColSinglet_iParton_get" "', argument " "1"" of type '" "Pythia8::ColSinglet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColSinglet * >(argp1);
  result = (std::vector< int,std::allocator< int > > *)& ((arg1)->iParton);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColSinglet_pSum_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColSinglet *arg1 = (Pythia8::ColSinglet *) 0 ;
  Pythia8::Vec4 *arg2 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColSinglet_pSum_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColSinglet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColSinglet_pSum_set" "', argument " "1"" of type '" "Pythia8::ColSinglet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColSinglet * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColSinglet_pSum_set" "', argument " "2"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  if (arg1) (arg1)->pSum = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColSinglet_pSum_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColSinglet *arg1 = (Pythia8::ColSinglet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColSinglet_pSum_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColSinglet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColSinglet_pSum_get" "', argument " "1"" of type '" "Pythia8::ColSinglet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColSinglet * >(argp1);
  result = (Pythia8::Vec4 *)& ((arg1)->pSum);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColSinglet_mass_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColSinglet *arg1 = (Pythia8::ColSinglet *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColSinglet_mass_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColSinglet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColSinglet_mass_set" "', argument " "1"" of type '" "Pythia8::ColSinglet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColSinglet * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColSinglet_mass_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->mass = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColSinglet_mass_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColSinglet *arg1 = (Pythia8::ColSinglet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColSinglet_mass_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColSinglet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColSinglet_mass_get" "', argument " "1"" of type '" "Pythia8::ColSinglet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColSinglet * >(argp1);
  result = (double) ((arg1)->mass);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColSinglet_massExcess_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColSinglet *arg1 = (Pythia8::ColSinglet *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColSinglet_massExcess_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColSinglet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColSinglet_massExcess_set" "', argument " "1"" of type '" "Pythia8::ColSinglet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColSinglet * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColSinglet_massExcess_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->massExcess = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColSinglet_massExcess_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColSinglet *arg1 = (Pythia8::ColSinglet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColSinglet_massExcess_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColSinglet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColSinglet_massExcess_get" "', argument " "1"" of type '" "Pythia8::ColSinglet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColSinglet * >(argp1);
  result = (double) ((arg1)->massExcess);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColSinglet_hasJunction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColSinglet *arg1 = (Pythia8::ColSinglet *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColSinglet_hasJunction_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColSinglet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColSinglet_hasJunction_set" "', argument " "1"" of type '" "Pythia8::ColSinglet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColSinglet * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColSinglet_hasJunction_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->hasJunction = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColSinglet_hasJunction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColSinglet *arg1 = (Pythia8::ColSinglet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColSinglet_hasJunction_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColSinglet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColSinglet_hasJunction_get" "', argument " "1"" of type '" "Pythia8::ColSinglet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColSinglet * >(argp1);
  result = (bool) ((arg1)->hasJunction);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColSinglet_isClosed_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColSinglet *arg1 = (Pythia8::ColSinglet *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColSinglet_isClosed_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColSinglet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColSinglet_isClosed_set" "', argument " "1"" of type '" "Pythia8::ColSinglet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColSinglet * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColSinglet_isClosed_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isClosed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColSinglet_isClosed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColSinglet *arg1 = (Pythia8::ColSinglet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColSinglet_isClosed_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColSinglet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColSinglet_isClosed_get" "', argument " "1"" of type '" "Pythia8::ColSinglet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColSinglet * >(argp1);
  result = (bool) ((arg1)->isClosed);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColSinglet_isCollected_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColSinglet *arg1 = (Pythia8::ColSinglet *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColSinglet_isCollected_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColSinglet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColSinglet_isCollected_set" "', argument " "1"" of type '" "Pythia8::ColSinglet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColSinglet * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColSinglet_isCollected_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isCollected = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColSinglet_isCollected_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColSinglet *arg1 = (Pythia8::ColSinglet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColSinglet_isCollected_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColSinglet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColSinglet_isCollected_get" "', argument " "1"" of type '" "Pythia8::ColSinglet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColSinglet * >(argp1);
  result = (bool) ((arg1)->isCollected);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ColSinglet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColSinglet *arg1 = (Pythia8::ColSinglet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ColSinglet",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColSinglet, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ColSinglet" "', argument " "1"" of type '" "Pythia8::ColSinglet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColSinglet * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ColSinglet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ColSinglet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ColConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColConfig *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ColConfig")) SWIG_fail;
  result = (Pythia8::ColConfig *)new Pythia8::ColConfig();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ColConfig, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColConfig_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColConfig *arg1 = (Pythia8::ColConfig *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::StringFlav *arg4 = (Pythia8::StringFlav *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ColConfig_init",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColConfig_init" "', argument " "1"" of type '" "Pythia8::ColConfig *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColConfig * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColConfig_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ColConfig_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ColConfig_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ColConfig_init" "', argument " "4"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::StringFlav * >(argp4);
  (arg1)->init(arg2,*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColConfig_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColConfig *arg1 = (Pythia8::ColConfig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColConfig_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColConfig_size" "', argument " "1"" of type '" "Pythia8::ColConfig const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColConfig * >(argp1);
  result = (int)((Pythia8::ColConfig const *)arg1)->size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColConfig_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColConfig *arg1 = (Pythia8::ColConfig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColConfig_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColConfig_clear" "', argument " "1"" of type '" "Pythia8::ColConfig *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColConfig * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColConfig_insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColConfig *arg1 = (Pythia8::ColConfig *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ColConfig_insert",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColConfig_insert" "', argument " "1"" of type '" "Pythia8::ColConfig *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColConfig * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColConfig_insert" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ColConfig_insert" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ColConfig_insert" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ColConfig_insert" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  result = (bool)(arg1)->insert(*arg2,*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColConfig_erase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColConfig *arg1 = (Pythia8::ColConfig *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColConfig_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColConfig_erase" "', argument " "1"" of type '" "Pythia8::ColConfig *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColConfig * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColConfig_erase" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->erase(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColConfig_collect__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColConfig *arg1 = (Pythia8::ColConfig *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ColConfig_collect",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColConfig_collect" "', argument " "1"" of type '" "Pythia8::ColConfig *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColConfig * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColConfig_collect" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ColConfig_collect" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ColConfig_collect" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ColConfig_collect" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->collect(arg2,*arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColConfig_collect__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColConfig *arg1 = (Pythia8::ColConfig *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ColConfig_collect",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColConfig_collect" "', argument " "1"" of type '" "Pythia8::ColConfig *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColConfig * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColConfig_collect" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ColConfig_collect" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ColConfig_collect" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  (arg1)->collect(arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColConfig_collect(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ColConfig, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ColConfig_collect__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ColConfig, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ColConfig_collect__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ColConfig_collect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ColConfig::collect(int,Pythia8::Event &,bool)\n"
    "    Pythia8::ColConfig::collect(int,Pythia8::Event &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ColConfig_findSinglet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColConfig *arg1 = (Pythia8::ColConfig *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColConfig_findSinglet",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColConfig_findSinglet" "', argument " "1"" of type '" "Pythia8::ColConfig *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColConfig * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColConfig_findSinglet" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->findSinglet(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColConfig_rapPairs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColConfig *arg1 = (Pythia8::ColConfig *) 0 ;
  std::vector< std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >,std::allocator< std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > > > *arg2 = (std::vector< std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >,std::allocator< std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColConfig_rapPairs_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColConfig_rapPairs_set" "', argument " "1"" of type '" "Pythia8::ColConfig *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColConfig * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t_std__allocatorT_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColConfig_rapPairs_set" "', argument " "2"" of type '" "std::vector< std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >,std::allocator< std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >,std::allocator< std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > > > * >(argp2);
  if (arg1) (arg1)->rapPairs = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColConfig_rapPairs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColConfig *arg1 = (Pythia8::ColConfig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >,std::allocator< std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColConfig_rapPairs_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColConfig_rapPairs_get" "', argument " "1"" of type '" "Pythia8::ColConfig *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColConfig * >(argp1);
  result = (std::vector< std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >,std::allocator< std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > > > *)& ((arg1)->rapPairs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t_std__allocatorT_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColConfig___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColConfig *arg1 = (Pythia8::ColConfig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColConfig___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColConfig___str__" "', argument " "1"" of type '" "Pythia8::ColConfig *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColConfig * >(argp1);
  result = Pythia8_ColConfig___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColConfig___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColConfig *arg1 = (Pythia8::ColConfig *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::ColSinglet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColConfig___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColConfig___getitem__" "', argument " "1"" of type '" "Pythia8::ColConfig *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColConfig * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColConfig___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    assert(!COLCONFIG_ERROR); result = (Pythia8::ColSinglet *)Pythia8_ColConfig___getitem__(arg1,arg2);
    if (COLCONFIG_ERROR) {
      COLCONFIG_ERROR = 0;
      SWIG_exception(SWIG_IndexError, "Index out of bounds");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ColSinglet, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ColConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColConfig *arg1 = (Pythia8::ColConfig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ColConfig",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColConfig, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ColConfig" "', argument " "1"" of type '" "Pythia8::ColConfig *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColConfig * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ColConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ColConfig, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_StringRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StringRegion")) SWIG_fail;
  result = (Pythia8::StringRegion *)new Pythia8::StringRegion();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__StringRegion, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int Swig_var_StringRegion_MJOIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StringRegion_MJOIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StringRegion_MJOIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(Pythia8::StringRegion::MJOIN));
  return pyobj;
}


SWIGINTERN int Swig_var_StringRegion_TINY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StringRegion_TINY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StringRegion_TINY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(Pythia8::StringRegion::TINY));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_StringRegion_isSetUp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringRegion_isSetUp_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_isSetUp_set" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringRegion_isSetUp_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isSetUp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_isSetUp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringRegion_isSetUp_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_isSetUp_get" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  result = (bool) ((arg1)->isSetUp);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_isEmpty_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringRegion_isEmpty_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_isEmpty_set" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringRegion_isEmpty_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isEmpty = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_isEmpty_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringRegion_isEmpty_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_isEmpty_get" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  result = (bool) ((arg1)->isEmpty);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_pPos_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  Pythia8::Vec4 *arg2 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringRegion_pPos_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_pPos_set" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringRegion_pPos_set" "', argument " "2"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  if (arg1) (arg1)->pPos = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_pPos_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringRegion_pPos_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_pPos_get" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  result = (Pythia8::Vec4 *)& ((arg1)->pPos);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_pNeg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  Pythia8::Vec4 *arg2 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringRegion_pNeg_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_pNeg_set" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringRegion_pNeg_set" "', argument " "2"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  if (arg1) (arg1)->pNeg = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_pNeg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringRegion_pNeg_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_pNeg_get" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  result = (Pythia8::Vec4 *)& ((arg1)->pNeg);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_eX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  Pythia8::Vec4 *arg2 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringRegion_eX_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_eX_set" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringRegion_eX_set" "', argument " "2"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  if (arg1) (arg1)->eX = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_eX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringRegion_eX_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_eX_get" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  result = (Pythia8::Vec4 *)& ((arg1)->eX);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_eY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  Pythia8::Vec4 *arg2 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringRegion_eY_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_eY_set" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringRegion_eY_set" "', argument " "2"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  if (arg1) (arg1)->eY = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_eY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringRegion_eY_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_eY_get" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  result = (Pythia8::Vec4 *)& ((arg1)->eY);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_pPosMass_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  Pythia8::Vec4 *arg2 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringRegion_pPosMass_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_pPosMass_set" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringRegion_pPosMass_set" "', argument " "2"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  if (arg1) (arg1)->pPosMass = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_pPosMass_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringRegion_pPosMass_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_pPosMass_get" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  result = (Pythia8::Vec4 *)& ((arg1)->pPosMass);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_pNegMass_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  Pythia8::Vec4 *arg2 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringRegion_pNegMass_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_pNegMass_set" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringRegion_pNegMass_set" "', argument " "2"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  if (arg1) (arg1)->pNegMass = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_pNegMass_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringRegion_pNegMass_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_pNegMass_get" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  result = (Pythia8::Vec4 *)& ((arg1)->pNegMass);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_massOffset_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  Pythia8::Vec4 *arg2 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringRegion_massOffset_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_massOffset_set" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringRegion_massOffset_set" "', argument " "2"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  if (arg1) (arg1)->massOffset = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_massOffset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringRegion_massOffset_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_massOffset_get" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  result = (Pythia8::Vec4 *)& ((arg1)->massOffset);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_w2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringRegion_w2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_w2_set" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringRegion_w2_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->w2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_w2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringRegion_w2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_w2_get" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  result = (double) ((arg1)->w2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_xPosProj_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringRegion_xPosProj_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_xPosProj_set" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringRegion_xPosProj_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->xPosProj = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_xPosProj_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringRegion_xPosProj_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_xPosProj_get" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  result = (double) ((arg1)->xPosProj);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_xNegProj_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringRegion_xNegProj_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_xNegProj_set" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringRegion_xNegProj_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->xNegProj = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_xNegProj_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringRegion_xNegProj_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_xNegProj_get" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  result = (double) ((arg1)->xNegProj);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_pxProj_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringRegion_pxProj_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_pxProj_set" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringRegion_pxProj_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pxProj = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_pxProj_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringRegion_pxProj_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_pxProj_get" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  result = (double) ((arg1)->pxProj);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_pyProj_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringRegion_pyProj_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_pyProj_set" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringRegion_pyProj_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pyProj = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_pyProj_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringRegion_pyProj_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_pyProj_get" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  result = (double) ((arg1)->pyProj);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_gluonOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ;
  Pythia8::Event *arg3 = 0 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:StringRegion_gluonOffset",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_gluonOffset" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringRegion_gluonOffset" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringRegion_gluonOffset" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringRegion_gluonOffset" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringRegion_gluonOffset" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StringRegion_gluonOffset" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "StringRegion_gluonOffset" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (arg1)->gluonOffset(*arg2,*arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_gluonOffsetJRF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ;
  Pythia8::Event *arg3 = 0 ;
  int arg4 ;
  int arg5 ;
  Pythia8::RotBstMatrix arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:StringRegion_gluonOffsetJRF",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_gluonOffsetJRF" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringRegion_gluonOffsetJRF" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringRegion_gluonOffsetJRF" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringRegion_gluonOffsetJRF" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringRegion_gluonOffsetJRF" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StringRegion_gluonOffsetJRF" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "StringRegion_gluonOffsetJRF" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Pythia8__RotBstMatrix,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "StringRegion_gluonOffsetJRF" "', argument " "6"" of type '" "Pythia8::RotBstMatrix""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringRegion_gluonOffsetJRF" "', argument " "6"" of type '" "Pythia8::RotBstMatrix""'");
    } else {
      Pythia8::RotBstMatrix * temp = reinterpret_cast< Pythia8::RotBstMatrix * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  result = (arg1)->gluonOffsetJRF(*arg2,*arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_massiveOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:StringRegion_massiveOffset",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_massiveOffset" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringRegion_massiveOffset" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringRegion_massiveOffset" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StringRegion_massiveOffset" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "StringRegion_massiveOffset" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "StringRegion_massiveOffset" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "StringRegion_massiveOffset" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "StringRegion_massiveOffset" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (bool)(arg1)->massiveOffset(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_setUp__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  Pythia8::Vec4 arg2 ;
  Pythia8::Vec4 arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:StringRegion_setUp",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_setUp" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringRegion_setUp" "', argument " "2"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringRegion_setUp" "', argument " "2"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringRegion_setUp" "', argument " "3"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringRegion_setUp" "', argument " "3"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StringRegion_setUp" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->setUp(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_setUp__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  Pythia8::Vec4 arg2 ;
  Pythia8::Vec4 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:StringRegion_setUp",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_setUp" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringRegion_setUp" "', argument " "2"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringRegion_setUp" "', argument " "2"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringRegion_setUp" "', argument " "3"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringRegion_setUp" "', argument " "3"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->setUp(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_setUp(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringRegion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StringRegion_setUp__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringRegion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_StringRegion_setUp__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'StringRegion_setUp'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::StringRegion::setUp(Pythia8::Vec4,Pythia8::Vec4,bool)\n"
    "    Pythia8::StringRegion::setUp(Pythia8::Vec4,Pythia8::Vec4)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringRegion_pHad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:StringRegion_pHad",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_pHad" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringRegion_pHad" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringRegion_pHad" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StringRegion_pHad" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "StringRegion_pHad" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (arg1)->pHad(arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_project__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  Pythia8::Vec4 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringRegion_project",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_project" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringRegion_project" "', argument " "2"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringRegion_project" "', argument " "2"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->project(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_project__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:StringRegion_project",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_project" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringRegion_project" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringRegion_project" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StringRegion_project" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "StringRegion_project" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  (arg1)->project(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_project(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringRegion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StringRegion_project__SWIG_0(self, args);
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringRegion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_StringRegion_project__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'StringRegion_project'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::StringRegion::project(Pythia8::Vec4)\n"
    "    Pythia8::StringRegion::project(double,double,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringRegion_xPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringRegion_xPos",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_xPos" "', argument " "1"" of type '" "Pythia8::StringRegion const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  result = (double)((Pythia8::StringRegion const *)arg1)->xPos();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_xNeg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringRegion_xNeg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_xNeg" "', argument " "1"" of type '" "Pythia8::StringRegion const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  result = (double)((Pythia8::StringRegion const *)arg1)->xNeg();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_px(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringRegion_px",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_px" "', argument " "1"" of type '" "Pythia8::StringRegion const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  result = (double)((Pythia8::StringRegion const *)arg1)->px();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringRegion_py(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringRegion_py",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringRegion_py" "', argument " "1"" of type '" "Pythia8::StringRegion const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  result = (double)((Pythia8::StringRegion const *)arg1)->py();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StringRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringRegion *arg1 = (Pythia8::StringRegion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StringRegion",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringRegion, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StringRegion" "', argument " "1"" of type '" "Pythia8::StringRegion *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringRegion * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StringRegion_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__StringRegion, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_StringSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringSystem *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StringSystem")) SWIG_fail;
  result = (Pythia8::StringSystem *)new Pythia8::StringSystem();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__StringSystem, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringSystem_setUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringSystem *arg1 = (Pythia8::StringSystem *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:StringSystem_setUp",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringSystem_setUp" "', argument " "1"" of type '" "Pythia8::StringSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringSystem * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringSystem_setUp" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringSystem_setUp" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringSystem_setUp" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringSystem_setUp" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  (arg1)->setUp(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringSystem_iReg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringSystem *arg1 = (Pythia8::StringSystem *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:StringSystem_iReg",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringSystem_iReg" "', argument " "1"" of type '" "Pythia8::StringSystem const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringSystem_iReg" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringSystem_iReg" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (int)((Pythia8::StringSystem const *)arg1)->iReg(arg2,arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringSystem_region(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringSystem *arg1 = (Pythia8::StringSystem *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::StringRegion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:StringSystem_region",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringSystem_region" "', argument " "1"" of type '" "Pythia8::StringSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringSystem_region" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringSystem_region" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::StringRegion *) &(arg1)->region(arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringSystem_regionLowPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringSystem *arg1 = (Pythia8::StringSystem *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::StringRegion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringSystem_regionLowPos",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringSystem_regionLowPos" "', argument " "1"" of type '" "Pythia8::StringSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringSystem_regionLowPos" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::StringRegion *) &(arg1)->regionLowPos(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringSystem_regionLowNeg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringSystem *arg1 = (Pythia8::StringSystem *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::StringRegion *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringSystem_regionLowNeg",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringSystem_regionLowNeg" "', argument " "1"" of type '" "Pythia8::StringSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringSystem_regionLowNeg" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::StringRegion *) &(arg1)->regionLowNeg(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__StringRegion, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringSystem_system_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringSystem *arg1 = (Pythia8::StringSystem *) 0 ;
  std::vector< Pythia8::StringRegion,std::allocator< Pythia8::StringRegion > > *arg2 = (std::vector< Pythia8::StringRegion,std::allocator< Pythia8::StringRegion > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringSystem_system_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringSystem_system_set" "', argument " "1"" of type '" "Pythia8::StringSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringSystem * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_Pythia8__StringRegion_std__allocatorT_Pythia8__StringRegion_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringSystem_system_set" "', argument " "2"" of type '" "std::vector< Pythia8::StringRegion,std::allocator< Pythia8::StringRegion > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::StringRegion,std::allocator< Pythia8::StringRegion > > * >(argp2);
  if (arg1) (arg1)->system = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringSystem_system_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringSystem *arg1 = (Pythia8::StringSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::StringRegion,std::allocator< Pythia8::StringRegion > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringSystem_system_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringSystem_system_get" "', argument " "1"" of type '" "Pythia8::StringSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringSystem * >(argp1);
  result = (std::vector< Pythia8::StringRegion,std::allocator< Pythia8::StringRegion > > *)& ((arg1)->system);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__StringRegion_std__allocatorT_Pythia8__StringRegion_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringSystem_sizePartons_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringSystem *arg1 = (Pythia8::StringSystem *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringSystem_sizePartons_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringSystem_sizePartons_set" "', argument " "1"" of type '" "Pythia8::StringSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringSystem_sizePartons_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->sizePartons = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringSystem_sizePartons_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringSystem *arg1 = (Pythia8::StringSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringSystem_sizePartons_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringSystem_sizePartons_get" "', argument " "1"" of type '" "Pythia8::StringSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringSystem * >(argp1);
  result = (int) ((arg1)->sizePartons);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringSystem_sizeStrings_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringSystem *arg1 = (Pythia8::StringSystem *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringSystem_sizeStrings_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringSystem_sizeStrings_set" "', argument " "1"" of type '" "Pythia8::StringSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringSystem_sizeStrings_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->sizeStrings = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringSystem_sizeStrings_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringSystem *arg1 = (Pythia8::StringSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringSystem_sizeStrings_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringSystem_sizeStrings_get" "', argument " "1"" of type '" "Pythia8::StringSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringSystem * >(argp1);
  result = (int) ((arg1)->sizeStrings);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringSystem_sizeRegions_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringSystem *arg1 = (Pythia8::StringSystem *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringSystem_sizeRegions_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringSystem_sizeRegions_set" "', argument " "1"" of type '" "Pythia8::StringSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringSystem_sizeRegions_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->sizeRegions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringSystem_sizeRegions_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringSystem *arg1 = (Pythia8::StringSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringSystem_sizeRegions_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringSystem_sizeRegions_get" "', argument " "1"" of type '" "Pythia8::StringSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringSystem * >(argp1);
  result = (int) ((arg1)->sizeRegions);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringSystem_indxReg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringSystem *arg1 = (Pythia8::StringSystem *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringSystem_indxReg_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringSystem_indxReg_set" "', argument " "1"" of type '" "Pythia8::StringSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringSystem_indxReg_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->indxReg = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringSystem_indxReg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringSystem *arg1 = (Pythia8::StringSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringSystem_indxReg_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringSystem_indxReg_get" "', argument " "1"" of type '" "Pythia8::StringSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringSystem * >(argp1);
  result = (int) ((arg1)->indxReg);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringSystem_iMax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringSystem *arg1 = (Pythia8::StringSystem *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringSystem_iMax_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringSystem_iMax_set" "', argument " "1"" of type '" "Pythia8::StringSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringSystem_iMax_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iMax = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringSystem_iMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringSystem *arg1 = (Pythia8::StringSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringSystem_iMax_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringSystem_iMax_get" "', argument " "1"" of type '" "Pythia8::StringSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringSystem * >(argp1);
  result = (int) ((arg1)->iMax);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringSystem_mJoin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringSystem *arg1 = (Pythia8::StringSystem *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringSystem_mJoin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringSystem_mJoin_set" "', argument " "1"" of type '" "Pythia8::StringSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringSystem * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringSystem_mJoin_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->mJoin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringSystem_mJoin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringSystem *arg1 = (Pythia8::StringSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringSystem_mJoin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringSystem_mJoin_get" "', argument " "1"" of type '" "Pythia8::StringSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringSystem * >(argp1);
  result = (double) ((arg1)->mJoin);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringSystem_m2Join_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringSystem *arg1 = (Pythia8::StringSystem *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringSystem_m2Join_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringSystem_m2Join_set" "', argument " "1"" of type '" "Pythia8::StringSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringSystem * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringSystem_m2Join_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->m2Join = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringSystem_m2Join_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringSystem *arg1 = (Pythia8::StringSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringSystem_m2Join_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringSystem_m2Join_get" "', argument " "1"" of type '" "Pythia8::StringSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringSystem * >(argp1);
  result = (double) ((arg1)->m2Join);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StringSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringSystem *arg1 = (Pythia8::StringSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StringSystem",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringSystem, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StringSystem" "', argument " "1"" of type '" "Pythia8::StringSystem *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringSystem * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StringSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__StringSystem, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_StringVertex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  bool val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::StringVertex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_StringVertex",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StringVertex" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StringVertex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_StringVertex" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_StringVertex" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_StringVertex" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (Pythia8::StringVertex *)new Pythia8::StringVertex(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__StringVertex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringVertex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  bool val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::StringVertex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_StringVertex",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StringVertex" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StringVertex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_StringVertex" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_StringVertex" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (Pythia8::StringVertex *)new Pythia8::StringVertex(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__StringVertex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringVertex__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  int arg2 ;
  int arg3 ;
  bool val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::StringVertex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_StringVertex",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StringVertex" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StringVertex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_StringVertex" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::StringVertex *)new Pythia8::StringVertex(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__StringVertex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringVertex__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  int arg2 ;
  bool val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::StringVertex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_StringVertex",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StringVertex" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StringVertex" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::StringVertex *)new Pythia8::StringVertex(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__StringVertex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringVertex__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::StringVertex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StringVertex",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StringVertex" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  result = (Pythia8::StringVertex *)new Pythia8::StringVertex(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__StringVertex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringVertex__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringVertex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StringVertex")) SWIG_fail;
  result = (Pythia8::StringVertex *)new Pythia8::StringVertex();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__StringVertex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringVertex__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringVertex *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::StringVertex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_StringVertex",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__StringVertex,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StringVertex" "', argument " "1"" of type '" "Pythia8::StringVertex const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StringVertex" "', argument " "1"" of type '" "Pythia8::StringVertex const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringVertex * >(argp1);
  result = (Pythia8::StringVertex *)new Pythia8::StringVertex((Pythia8::StringVertex const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__StringVertex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringVertex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_StringVertex__SWIG_5(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__StringVertex, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StringVertex__SWIG_6(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_StringVertex__SWIG_4(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_StringVertex__SWIG_3(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_StringVertex__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_StringVertex__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_StringVertex__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StringVertex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::StringVertex::StringVertex(bool,int,int,double,double)\n"
    "    Pythia8::StringVertex::StringVertex(bool,int,int,double)\n"
    "    Pythia8::StringVertex::StringVertex(bool,int,int)\n"
    "    Pythia8::StringVertex::StringVertex(bool,int)\n"
    "    Pythia8::StringVertex::StringVertex(bool)\n"
    "    Pythia8::StringVertex::StringVertex()\n"
    "    Pythia8::StringVertex::StringVertex(Pythia8::StringVertex const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringVertex_fromPos_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringVertex *arg1 = (Pythia8::StringVertex *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringVertex_fromPos_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVertex_fromPos_set" "', argument " "1"" of type '" "Pythia8::StringVertex *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringVertex * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVertex_fromPos_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->fromPos = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVertex_fromPos_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringVertex *arg1 = (Pythia8::StringVertex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringVertex_fromPos_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVertex_fromPos_get" "', argument " "1"" of type '" "Pythia8::StringVertex *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringVertex * >(argp1);
  result = (bool) ((arg1)->fromPos);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVertex_iRegPos_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringVertex *arg1 = (Pythia8::StringVertex *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringVertex_iRegPos_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVertex_iRegPos_set" "', argument " "1"" of type '" "Pythia8::StringVertex *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringVertex * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVertex_iRegPos_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iRegPos = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVertex_iRegPos_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringVertex *arg1 = (Pythia8::StringVertex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringVertex_iRegPos_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVertex_iRegPos_get" "', argument " "1"" of type '" "Pythia8::StringVertex *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringVertex * >(argp1);
  result = (int) ((arg1)->iRegPos);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVertex_iRegNeg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringVertex *arg1 = (Pythia8::StringVertex *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringVertex_iRegNeg_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVertex_iRegNeg_set" "', argument " "1"" of type '" "Pythia8::StringVertex *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringVertex * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVertex_iRegNeg_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iRegNeg = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVertex_iRegNeg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringVertex *arg1 = (Pythia8::StringVertex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringVertex_iRegNeg_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVertex_iRegNeg_get" "', argument " "1"" of type '" "Pythia8::StringVertex *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringVertex * >(argp1);
  result = (int) ((arg1)->iRegNeg);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVertex_xRegPos_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringVertex *arg1 = (Pythia8::StringVertex *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringVertex_xRegPos_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVertex_xRegPos_set" "', argument " "1"" of type '" "Pythia8::StringVertex *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringVertex * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVertex_xRegPos_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->xRegPos = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVertex_xRegPos_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringVertex *arg1 = (Pythia8::StringVertex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringVertex_xRegPos_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVertex_xRegPos_get" "', argument " "1"" of type '" "Pythia8::StringVertex *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringVertex * >(argp1);
  result = (double) ((arg1)->xRegPos);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVertex_xRegNeg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringVertex *arg1 = (Pythia8::StringVertex *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringVertex_xRegNeg_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVertex_xRegNeg_set" "', argument " "1"" of type '" "Pythia8::StringVertex *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringVertex * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVertex_xRegNeg_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->xRegNeg = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVertex_xRegNeg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringVertex *arg1 = (Pythia8::StringVertex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringVertex_xRegNeg_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVertex_xRegNeg_get" "', argument " "1"" of type '" "Pythia8::StringVertex *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringVertex * >(argp1);
  result = (double) ((arg1)->xRegNeg);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StringVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringVertex *arg1 = (Pythia8::StringVertex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StringVertex",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringVertex, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StringVertex" "', argument " "1"" of type '" "Pythia8::StringVertex *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringVertex * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StringVertex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__StringVertex, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_SigmaPartialWave_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaPartialWave *arg1 = (Pythia8::SigmaPartialWave *) 0 ;
  int arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  Pythia8::Info *arg5 = (Pythia8::Info *) 0 ;
  Pythia8::ParticleData *arg6 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg7 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:SigmaPartialWave_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaPartialWave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaPartialWave_init" "', argument " "1"" of type '" "Pythia8::SigmaPartialWave *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaPartialWave * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaPartialWave_init" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SigmaPartialWave_init" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SigmaPartialWave_init" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SigmaPartialWave_init" "', argument " "5"" of type '" "Pythia8::Info *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Info * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SigmaPartialWave_init" "', argument " "6"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::ParticleData * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SigmaPartialWave_init" "', argument " "7"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::Rndm * >(argp7);
  result = (bool)(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaPartialWave_readFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaPartialWave *arg1 = (Pythia8::SigmaPartialWave *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaPartialWave_readFile",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaPartialWave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaPartialWave_readFile" "', argument " "1"" of type '" "Pythia8::SigmaPartialWave *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaPartialWave * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SigmaPartialWave_readFile" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SigmaPartialWave_readFile" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->readFile(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaPartialWave_setSubprocess__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaPartialWave *arg1 = (Pythia8::SigmaPartialWave *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaPartialWave_setSubprocess",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaPartialWave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaPartialWave_setSubprocess" "', argument " "1"" of type '" "Pythia8::SigmaPartialWave *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaPartialWave * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaPartialWave_setSubprocess" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->setSubprocess(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaPartialWave_setSubprocess__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaPartialWave *arg1 = (Pythia8::SigmaPartialWave *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaPartialWave_setSubprocess",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaPartialWave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaPartialWave_setSubprocess" "', argument " "1"" of type '" "Pythia8::SigmaPartialWave *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaPartialWave * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaPartialWave_setSubprocess" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaPartialWave_setSubprocess" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (bool)(arg1)->setSubprocess(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaPartialWave_setSubprocess(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaPartialWave, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SigmaPartialWave_setSubprocess__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaPartialWave, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SigmaPartialWave_setSubprocess__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaPartialWave_setSubprocess'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaPartialWave::setSubprocess(int)\n"
    "    Pythia8::SigmaPartialWave::setSubprocess(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaPartialWave_sigmaEl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaPartialWave *arg1 = (Pythia8::SigmaPartialWave *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaPartialWave_sigmaEl",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaPartialWave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaPartialWave_sigmaEl" "', argument " "1"" of type '" "Pythia8::SigmaPartialWave *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaPartialWave * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaPartialWave_sigmaEl" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->sigmaEl(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaPartialWave_sigmaTot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaPartialWave *arg1 = (Pythia8::SigmaPartialWave *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaPartialWave_sigmaTot",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaPartialWave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaPartialWave_sigmaTot" "', argument " "1"" of type '" "Pythia8::SigmaPartialWave *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaPartialWave * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaPartialWave_sigmaTot" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->sigmaTot(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaPartialWave_dSigma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaPartialWave *arg1 = (Pythia8::SigmaPartialWave *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaPartialWave_dSigma",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaPartialWave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaPartialWave_dSigma" "', argument " "1"" of type '" "Pythia8::SigmaPartialWave *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaPartialWave * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaPartialWave_dSigma" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaPartialWave_dSigma" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)(arg1)->dSigma(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaPartialWave_pickCosTheta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaPartialWave *arg1 = (Pythia8::SigmaPartialWave *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaPartialWave_pickCosTheta",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaPartialWave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaPartialWave_pickCosTheta" "', argument " "1"" of type '" "Pythia8::SigmaPartialWave *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaPartialWave * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaPartialWave_pickCosTheta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->pickCosTheta(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaPartialWave_getSigmaElMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaPartialWave *arg1 = (Pythia8::SigmaPartialWave *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaPartialWave_getSigmaElMax",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaPartialWave, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaPartialWave_getSigmaElMax" "', argument " "1"" of type '" "Pythia8::SigmaPartialWave *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaPartialWave * >(argp1);
  result = (double)(arg1)->getSigmaElMax();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SigmaPartialWave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaPartialWave *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SigmaPartialWave")) SWIG_fail;
  result = (Pythia8::SigmaPartialWave *)new Pythia8::SigmaPartialWave();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SigmaPartialWave, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SigmaPartialWave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaPartialWave *arg1 = (Pythia8::SigmaPartialWave *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SigmaPartialWave",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaPartialWave, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SigmaPartialWave" "', argument " "1"" of type '" "Pythia8::SigmaPartialWave *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaPartialWave * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SigmaPartialWave_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SigmaPartialWave, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_HadronScatterPair__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronScatterPair *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HadronScatterPair")) SWIG_fail;
  result = (Pythia8::HadronScatterPair *)new Pythia8::HadronScatterPair();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HadronScatterPair, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HadronScatterPair__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HSIndex *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  Pythia8::HSIndex *arg4 = 0 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  int res1 = SWIG_OLDOBJ ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Pythia8::HadronScatterPair *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_HadronScatterPair",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  {
    std::pair< int,int > *ptr = (std::pair< int,int > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HadronScatterPair" "', argument " "1"" of type '" "Pythia8::HSIndex const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HadronScatterPair" "', argument " "1"" of type '" "Pythia8::HSIndex const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HadronScatterPair" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HadronScatterPair" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::pair< int,int > *ptr = (std::pair< int,int > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_HadronScatterPair" "', argument " "4"" of type '" "Pythia8::HSIndex const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HadronScatterPair" "', argument " "4"" of type '" "Pythia8::HSIndex const &""'"); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HadronScatterPair" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HadronScatterPair" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_HadronScatterPair" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (Pythia8::HadronScatterPair *)new Pythia8::HadronScatterPair((Pythia8::HSIndex const &)*arg1,arg2,arg3,(Pythia8::HSIndex const &)*arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HadronScatterPair, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HadronScatterPair(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_HadronScatterPair__SWIG_0(self, args);
  }
  if (argc == 7) {
    int _v;
    int res = swig::asptr(argv[0], (std::pair< int,int >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::pair< int,int >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_HadronScatterPair__SWIG_1(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_HadronScatterPair'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::HadronScatterPair::HadronScatterPair()\n"
    "    Pythia8::HadronScatterPair::HadronScatterPair(Pythia8::HSIndex const &,int,int,Pythia8::HSIndex const &,int,int,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HadronScatterPair___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronScatterPair *arg1 = (Pythia8::HadronScatterPair *) 0 ;
  Pythia8::HadronScatterPair *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HadronScatterPair___lt__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HadronScatterPair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HadronScatterPair___lt__" "', argument " "1"" of type '" "Pythia8::HadronScatterPair const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HadronScatterPair * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__HadronScatterPair,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HadronScatterPair___lt__" "', argument " "2"" of type '" "Pythia8::HadronScatterPair const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HadronScatterPair___lt__" "', argument " "2"" of type '" "Pythia8::HadronScatterPair const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::HadronScatterPair * >(argp2);
  result = (bool)((Pythia8::HadronScatterPair const *)arg1)->operator <((Pythia8::HadronScatterPair const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HadronScatterPair_i1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronScatterPair *arg1 = (Pythia8::HadronScatterPair *) 0 ;
  Pythia8::HSIndex *arg2 = (Pythia8::HSIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HadronScatterPair_i1_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HadronScatterPair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HadronScatterPair_i1_set" "', argument " "1"" of type '" "Pythia8::HadronScatterPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HadronScatterPair * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__pairT_int_int_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HadronScatterPair_i1_set" "', argument " "2"" of type '" "Pythia8::HSIndex *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::HSIndex * >(argp2);
  if (arg1) (arg1)->i1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HadronScatterPair_i1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronScatterPair *arg1 = (Pythia8::HadronScatterPair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::HSIndex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HadronScatterPair_i1_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HadronScatterPair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HadronScatterPair_i1_get" "', argument " "1"" of type '" "Pythia8::HadronScatterPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HadronScatterPair * >(argp1);
  result = (Pythia8::HSIndex *)& ((arg1)->i1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_int_int_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HadronScatterPair_yt1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronScatterPair *arg1 = (Pythia8::HadronScatterPair *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HadronScatterPair_yt1_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HadronScatterPair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HadronScatterPair_yt1_set" "', argument " "1"" of type '" "Pythia8::HadronScatterPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HadronScatterPair * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HadronScatterPair_yt1_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->yt1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HadronScatterPair_yt1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronScatterPair *arg1 = (Pythia8::HadronScatterPair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HadronScatterPair_yt1_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HadronScatterPair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HadronScatterPair_yt1_get" "', argument " "1"" of type '" "Pythia8::HadronScatterPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HadronScatterPair * >(argp1);
  result = (int) ((arg1)->yt1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HadronScatterPair_pt1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronScatterPair *arg1 = (Pythia8::HadronScatterPair *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HadronScatterPair_pt1_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HadronScatterPair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HadronScatterPair_pt1_set" "', argument " "1"" of type '" "Pythia8::HadronScatterPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HadronScatterPair * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HadronScatterPair_pt1_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->pt1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HadronScatterPair_pt1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronScatterPair *arg1 = (Pythia8::HadronScatterPair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HadronScatterPair_pt1_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HadronScatterPair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HadronScatterPair_pt1_get" "', argument " "1"" of type '" "Pythia8::HadronScatterPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HadronScatterPair * >(argp1);
  result = (int) ((arg1)->pt1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HadronScatterPair_i2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronScatterPair *arg1 = (Pythia8::HadronScatterPair *) 0 ;
  Pythia8::HSIndex *arg2 = (Pythia8::HSIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HadronScatterPair_i2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HadronScatterPair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HadronScatterPair_i2_set" "', argument " "1"" of type '" "Pythia8::HadronScatterPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HadronScatterPair * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__pairT_int_int_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HadronScatterPair_i2_set" "', argument " "2"" of type '" "Pythia8::HSIndex *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::HSIndex * >(argp2);
  if (arg1) (arg1)->i2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HadronScatterPair_i2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronScatterPair *arg1 = (Pythia8::HadronScatterPair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::HSIndex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HadronScatterPair_i2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HadronScatterPair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HadronScatterPair_i2_get" "', argument " "1"" of type '" "Pythia8::HadronScatterPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HadronScatterPair * >(argp1);
  result = (Pythia8::HSIndex *)& ((arg1)->i2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_int_int_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HadronScatterPair_yt2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronScatterPair *arg1 = (Pythia8::HadronScatterPair *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HadronScatterPair_yt2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HadronScatterPair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HadronScatterPair_yt2_set" "', argument " "1"" of type '" "Pythia8::HadronScatterPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HadronScatterPair * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HadronScatterPair_yt2_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->yt2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HadronScatterPair_yt2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronScatterPair *arg1 = (Pythia8::HadronScatterPair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HadronScatterPair_yt2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HadronScatterPair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HadronScatterPair_yt2_get" "', argument " "1"" of type '" "Pythia8::HadronScatterPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HadronScatterPair * >(argp1);
  result = (int) ((arg1)->yt2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HadronScatterPair_pt2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronScatterPair *arg1 = (Pythia8::HadronScatterPair *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HadronScatterPair_pt2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HadronScatterPair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HadronScatterPair_pt2_set" "', argument " "1"" of type '" "Pythia8::HadronScatterPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HadronScatterPair * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HadronScatterPair_pt2_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->pt2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HadronScatterPair_pt2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronScatterPair *arg1 = (Pythia8::HadronScatterPair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HadronScatterPair_pt2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HadronScatterPair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HadronScatterPair_pt2_get" "', argument " "1"" of type '" "Pythia8::HadronScatterPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HadronScatterPair * >(argp1);
  result = (int) ((arg1)->pt2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HadronScatterPair_measure_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronScatterPair *arg1 = (Pythia8::HadronScatterPair *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HadronScatterPair_measure_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HadronScatterPair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HadronScatterPair_measure_set" "', argument " "1"" of type '" "Pythia8::HadronScatterPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HadronScatterPair * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HadronScatterPair_measure_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->measure = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HadronScatterPair_measure_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronScatterPair *arg1 = (Pythia8::HadronScatterPair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HadronScatterPair_measure_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HadronScatterPair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HadronScatterPair_measure_get" "', argument " "1"" of type '" "Pythia8::HadronScatterPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HadronScatterPair * >(argp1);
  result = (double) ((arg1)->measure);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HadronScatterPair(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronScatterPair *arg1 = (Pythia8::HadronScatterPair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HadronScatterPair",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HadronScatterPair, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HadronScatterPair" "', argument " "1"" of type '" "Pythia8::HadronScatterPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HadronScatterPair * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HadronScatterPair_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HadronScatterPair, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_HadronScatter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronScatter *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HadronScatter")) SWIG_fail;
  result = (Pythia8::HadronScatter *)new Pythia8::HadronScatter();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HadronScatter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HadronScatter_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronScatter *arg1 = (Pythia8::HadronScatter *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::Rndm *arg4 = (Pythia8::Rndm *) 0 ;
  Pythia8::ParticleData *arg5 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:HadronScatter_init",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HadronScatter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HadronScatter_init" "', argument " "1"" of type '" "Pythia8::HadronScatter *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HadronScatter * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HadronScatter_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HadronScatter_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HadronScatter_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "HadronScatter_init" "', argument " "4"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Rndm * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "HadronScatter_init" "', argument " "5"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::ParticleData * >(argp5);
  result = (bool)(arg1)->init(arg2,*arg3,arg4,arg5);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HadronScatter_scatter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronScatter *arg1 = (Pythia8::HadronScatter *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HadronScatter_scatter",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HadronScatter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HadronScatter_scatter" "', argument " "1"" of type '" "Pythia8::HadronScatter *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HadronScatter * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HadronScatter_scatter" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HadronScatter_scatter" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  (arg1)->scatter(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HadronScatter_scatterOld(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronScatter *arg1 = (Pythia8::HadronScatter *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HadronScatter_scatterOld",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HadronScatter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HadronScatter_scatterOld" "', argument " "1"" of type '" "Pythia8::HadronScatter *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HadronScatter * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HadronScatter_scatterOld" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HadronScatter_scatterOld" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  (arg1)->scatterOld(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HadronScatter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronScatter *arg1 = (Pythia8::HadronScatter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HadronScatter",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HadronScatter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HadronScatter" "', argument " "1"" of type '" "Pythia8::HadronScatter *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HadronScatter * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HadronScatter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HadronScatter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Wave4__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Wave4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Wave4")) SWIG_fail;
  result = (Pythia8::Wave4 *)new Pythia8::Wave4();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Wave4, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Wave4__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::complex arg1 ;
  Pythia8::complex arg2 ;
  Pythia8::complex arg3 ;
  Pythia8::complex arg4 ;
  std::complex< double > val1 ;
  int ecode1 = 0 ;
  std::complex< double > val2 ;
  int ecode2 = 0 ;
  std::complex< double > val3 ;
  int ecode3 = 0 ;
  std::complex< double > val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::Wave4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Wave4",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Wave4" "', argument " "1"" of type '" "Pythia8::complex""'");
  } 
  arg1 = static_cast< Pythia8::complex >(val1);
  ecode2 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Wave4" "', argument " "2"" of type '" "Pythia8::complex""'");
  } 
  arg2 = static_cast< Pythia8::complex >(val2);
  ecode3 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Wave4" "', argument " "3"" of type '" "Pythia8::complex""'");
  } 
  arg3 = static_cast< Pythia8::complex >(val3);
  ecode4 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Wave4" "', argument " "4"" of type '" "Pythia8::complex""'");
  } 
  arg4 = static_cast< Pythia8::complex >(val4);
  result = (Pythia8::Wave4 *)new Pythia8::Wave4(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Wave4, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Wave4__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Wave4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Wave4",&obj0)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Wave4" "', argument " "1"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Wave4" "', argument " "1"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = (Pythia8::Wave4 *)new Pythia8::Wave4(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Wave4, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Wave4(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Wave4__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Wave4__SWIG_2(self, args);
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_std_complex_Sl_double_Sg_(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_std_complex_Sl_double_Sg_(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_std_complex_Sl_double_Sg_(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_std_complex_Sl_double_Sg_(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Wave4__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Wave4'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Wave4::Wave4()\n"
    "    Pythia8::Wave4::Wave4(Pythia8::complex,Pythia8::complex,Pythia8::complex,Pythia8::complex)\n"
    "    Pythia8::Wave4::Wave4(Pythia8::Vec4)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Wave4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Wave4 *arg1 = (Pythia8::Wave4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Wave4",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Wave4, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Wave4" "', argument " "1"" of type '" "Pythia8::Wave4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Wave4 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Wave4___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Wave4 *arg1 = (Pythia8::Wave4 *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::complex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Wave4___call__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Wave4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wave4___call__" "', argument " "1"" of type '" "Pythia8::Wave4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Wave4 * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Wave4___call__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::complex *) &(arg1)->operator ()(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Wave4___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Wave4 *arg1 = (Pythia8::Wave4 *) 0 ;
  Pythia8::Wave4 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Wave4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Wave4___add__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Wave4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wave4___add__" "', argument " "1"" of type '" "Pythia8::Wave4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Wave4 * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Wave4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Wave4___add__" "', argument " "2"" of type '" "Pythia8::Wave4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Wave4___add__" "', argument " "2"" of type '" "Pythia8::Wave4""'");
    } else {
      Pythia8::Wave4 * temp = reinterpret_cast< Pythia8::Wave4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (arg1)->operator +(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Wave4(static_cast< const Pythia8::Wave4& >(result))), SWIGTYPE_p_Pythia8__Wave4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Wave4___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Wave4 *arg1 = (Pythia8::Wave4 *) 0 ;
  Pythia8::Wave4 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Wave4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Wave4___sub__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Wave4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wave4___sub__" "', argument " "1"" of type '" "Pythia8::Wave4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Wave4 * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Wave4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Wave4___sub__" "', argument " "2"" of type '" "Pythia8::Wave4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Wave4___sub__" "', argument " "2"" of type '" "Pythia8::Wave4""'");
    } else {
      Pythia8::Wave4 * temp = reinterpret_cast< Pythia8::Wave4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (arg1)->operator -(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Wave4(static_cast< const Pythia8::Wave4& >(result))), SWIGTYPE_p_Pythia8__Wave4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Wave4___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Wave4 *arg1 = (Pythia8::Wave4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Wave4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Wave4___neg__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Wave4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wave4___neg__" "', argument " "1"" of type '" "Pythia8::Wave4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Wave4 * >(argp1);
  result = (arg1)->operator -();
  resultobj = SWIG_NewPointerObj((new Pythia8::Wave4(static_cast< const Pythia8::Wave4& >(result))), SWIGTYPE_p_Pythia8__Wave4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Wave4___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Wave4 *arg1 = (Pythia8::Wave4 *) 0 ;
  Pythia8::Wave4 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::complex result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Wave4___mul__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Wave4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wave4___mul__" "', argument " "1"" of type '" "Pythia8::Wave4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Wave4 * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Wave4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Wave4___mul__" "', argument " "2"" of type '" "Pythia8::Wave4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Wave4___mul__" "', argument " "2"" of type '" "Pythia8::Wave4""'");
    } else {
      Pythia8::Wave4 * temp = reinterpret_cast< Pythia8::Wave4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (arg1)->operator *(arg2);
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Wave4___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Wave4 *arg1 = (Pythia8::Wave4 *) 0 ;
  Pythia8::complex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::complex< double > val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Wave4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Wave4___mul__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Wave4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wave4___mul__" "', argument " "1"" of type '" "Pythia8::Wave4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Wave4 * >(argp1);
  ecode2 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Wave4___mul__" "', argument " "2"" of type '" "Pythia8::complex""'");
  } 
  arg2 = static_cast< Pythia8::complex >(val2);
  result = (arg1)->operator *(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Wave4(static_cast< const Pythia8::Wave4& >(result))), SWIGTYPE_p_Pythia8__Wave4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Wave4___mul____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Wave4 *arg1 = (Pythia8::Wave4 *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Wave4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Wave4___mul__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Wave4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wave4___mul__" "', argument " "1"" of type '" "Pythia8::Wave4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Wave4 * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Wave4___mul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (arg1)->operator *(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Wave4(static_cast< const Pythia8::Wave4& >(result))), SWIGTYPE_p_Pythia8__Wave4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Wave4___div____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Wave4 *arg1 = (Pythia8::Wave4 *) 0 ;
  Pythia8::complex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::complex< double > val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Wave4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Wave4___div__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Wave4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wave4___div__" "', argument " "1"" of type '" "Pythia8::Wave4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Wave4 * >(argp1);
  ecode2 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Wave4___div__" "', argument " "2"" of type '" "Pythia8::complex""'");
  } 
  arg2 = static_cast< Pythia8::complex >(val2);
  result = (arg1)->operator /(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Wave4(static_cast< const Pythia8::Wave4& >(result))), SWIGTYPE_p_Pythia8__Wave4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Wave4___div____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Wave4 *arg1 = (Pythia8::Wave4 *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Wave4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Wave4___div__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Wave4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wave4___div__" "', argument " "1"" of type '" "Pythia8::Wave4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Wave4 * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Wave4___div__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (arg1)->operator /(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Wave4(static_cast< const Pythia8::Wave4& >(result))), SWIGTYPE_p_Pythia8__Wave4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Wave4___div__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Wave4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Wave4___div____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Wave4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_std_complex_Sl_double_Sg_(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Wave4___div____SWIG_0(self, args);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Wave4___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Wave4 *arg1 = (Pythia8::Wave4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Wave4___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Wave4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wave4___str__" "', argument " "1"" of type '" "Pythia8::Wave4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Wave4 * >(argp1);
  result = Pythia8_Wave4___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Wave4___rmul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Wave4 *arg1 = (Pythia8::Wave4 *) 0 ;
  std::complex< double > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::complex< double > val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Wave4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Wave4___rmul__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Wave4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wave4___rmul__" "', argument " "1"" of type '" "Pythia8::Wave4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Wave4 * >(argp1);
  ecode2 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Wave4___rmul__" "', argument " "2"" of type '" "std::complex< double >""'");
  } 
  arg2 = static_cast< std::complex< double > >(val2);
  result = Pythia8_Wave4___rmul____SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Wave4(static_cast< const Pythia8::Wave4& >(result))), SWIGTYPE_p_Pythia8__Wave4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Wave4___rmul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Wave4 *arg1 = (Pythia8::Wave4 *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Wave4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Wave4___rmul__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Wave4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wave4___rmul__" "', argument " "1"" of type '" "Pythia8::Wave4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Wave4 * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Wave4___rmul__" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = Pythia8_Wave4___rmul____SWIG_1(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Wave4(static_cast< const Pythia8::Wave4& >(result))), SWIGTYPE_p_Pythia8__Wave4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Wave4___rmul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Wave4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Wave4___rmul____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Wave4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_std_complex_Sl_double_Sg_(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Wave4___rmul____SWIG_0(self, args);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_Wave4___mul____SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Wave4 *arg1 = (Pythia8::Wave4 *) 0 ;
  Pythia8::GammaMatrix arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Wave4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Wave4___mul__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Wave4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wave4___mul__" "', argument " "1"" of type '" "Pythia8::Wave4 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Wave4 * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__GammaMatrix,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Wave4___mul__" "', argument " "2"" of type '" "Pythia8::GammaMatrix""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Wave4___mul__" "', argument " "2"" of type '" "Pythia8::GammaMatrix""'");
    } else {
      Pythia8::GammaMatrix * temp = reinterpret_cast< Pythia8::GammaMatrix * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = Pythia8_Wave4___mul____SWIG_3(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Wave4(static_cast< const Pythia8::Wave4& >(result))), SWIGTYPE_p_Pythia8__Wave4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Wave4___mul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Wave4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Wave4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Wave4___mul____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Wave4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__GammaMatrix, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Wave4___mul____SWIG_3(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Wave4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Wave4___mul____SWIG_2(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Wave4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_std_complex_Sl_double_Sg_(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Wave4___mul____SWIG_1(self, args);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *Wave4_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Wave4, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap___mul____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::complex arg1 ;
  Pythia8::Wave4 *arg2 = 0 ;
  std::complex< double > val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Wave4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__mul__",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "__mul__" "', argument " "1"" of type '" "Pythia8::complex""'");
  } 
  arg1 = static_cast< Pythia8::complex >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Wave4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__mul__" "', argument " "2"" of type '" "Pythia8::Wave4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__mul__" "', argument " "2"" of type '" "Pythia8::Wave4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Wave4 * >(argp2);
  result = Pythia8::operator *(arg1,(Pythia8::Wave4 const &)*arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Wave4(static_cast< const Pythia8::Wave4& >(result))), SWIGTYPE_p_Pythia8__Wave4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap___mul____SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  Pythia8::Wave4 *arg2 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Wave4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__mul__",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "__mul__" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Wave4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__mul__" "', argument " "2"" of type '" "Pythia8::Wave4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__mul__" "', argument " "2"" of type '" "Pythia8::Wave4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Wave4 * >(argp2);
  result = Pythia8::operator *(arg1,(Pythia8::Wave4 const &)*arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Wave4(static_cast< const Pythia8::Wave4& >(result))), SWIGTYPE_p_Pythia8__Wave4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_conj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Wave4 arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Wave4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:conj",&obj0)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Wave4,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "conj" "', argument " "1"" of type '" "Pythia8::Wave4""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "conj" "', argument " "1"" of type '" "Pythia8::Wave4""'");
    } else {
      Pythia8::Wave4 * temp = reinterpret_cast< Pythia8::Wave4 * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = Pythia8::conj(arg1);
  resultobj = SWIG_NewPointerObj((new Pythia8::Wave4(static_cast< const Pythia8::Wave4& >(result))), SWIGTYPE_p_Pythia8__Wave4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_epsilon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Wave4 arg1 ;
  Pythia8::Wave4 arg2 ;
  Pythia8::Wave4 arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Wave4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:epsilon",&obj0,&obj1,&obj2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Wave4,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "epsilon" "', argument " "1"" of type '" "Pythia8::Wave4""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "epsilon" "', argument " "1"" of type '" "Pythia8::Wave4""'");
    } else {
      Pythia8::Wave4 * temp = reinterpret_cast< Pythia8::Wave4 * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Wave4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "epsilon" "', argument " "2"" of type '" "Pythia8::Wave4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "epsilon" "', argument " "2"" of type '" "Pythia8::Wave4""'");
    } else {
      Pythia8::Wave4 * temp = reinterpret_cast< Pythia8::Wave4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Wave4,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "epsilon" "', argument " "3"" of type '" "Pythia8::Wave4""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "epsilon" "', argument " "3"" of type '" "Pythia8::Wave4""'");
    } else {
      Pythia8::Wave4 * temp = reinterpret_cast< Pythia8::Wave4 * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = Pythia8::epsilon(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj((new Pythia8::Wave4(static_cast< const Pythia8::Wave4& >(result))), SWIGTYPE_p_Pythia8__Wave4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_m2__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Wave4 arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:m2",&obj0)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Wave4,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "m2" "', argument " "1"" of type '" "Pythia8::Wave4""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "m2" "', argument " "1"" of type '" "Pythia8::Wave4""'");
    } else {
      Pythia8::Wave4 * temp = reinterpret_cast< Pythia8::Wave4 * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = (double)Pythia8::m2(arg1);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_m2__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Wave4 arg1 ;
  Pythia8::Wave4 arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:m2",&obj0,&obj1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Wave4,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "m2" "', argument " "1"" of type '" "Pythia8::Wave4""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "m2" "', argument " "1"" of type '" "Pythia8::Wave4""'");
    } else {
      Pythia8::Wave4 * temp = reinterpret_cast< Pythia8::Wave4 * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Wave4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "m2" "', argument " "2"" of type '" "Pythia8::Wave4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "m2" "', argument " "2"" of type '" "Pythia8::Wave4""'");
    } else {
      Pythia8::Wave4 * temp = reinterpret_cast< Pythia8::Wave4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (double)Pythia8::m2(arg1,arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_m2(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Wave4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_m2__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Particle, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_m2__SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_m2__SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Wave4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Wave4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_m2__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'm2'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::m2(Pythia8::Vec4 const &,Pythia8::Vec4 const &)\n"
    "    Pythia8::m2(Pythia8::Particle const &,Pythia8::Particle const &)\n"
    "    Pythia8::m2(Pythia8::Wave4)\n"
    "    Pythia8::m2(Pythia8::Wave4,Pythia8::Wave4)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap___lshift____SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  Pythia8::Wave4 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::ostream *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__lshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__lshift__" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Wave4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lshift__" "', argument " "2"" of type '" "Pythia8::Wave4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "2"" of type '" "Pythia8::Wave4""'");
    } else {
      Pythia8::Wave4 * temp = reinterpret_cast< Pythia8::Wave4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (std::ostream *) &Pythia8::operator <<(*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GammaMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaMatrix *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_GammaMatrix")) SWIG_fail;
  result = (Pythia8::GammaMatrix *)new Pythia8::GammaMatrix();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__GammaMatrix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GammaMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::GammaMatrix *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_GammaMatrix",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GammaMatrix" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::GammaMatrix *)new Pythia8::GammaMatrix(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__GammaMatrix, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_GammaMatrix(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_GammaMatrix__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_GammaMatrix__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GammaMatrix'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::GammaMatrix::GammaMatrix()\n"
    "    Pythia8::GammaMatrix::GammaMatrix(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_GammaMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaMatrix *arg1 = (Pythia8::GammaMatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_GammaMatrix",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaMatrix, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GammaMatrix" "', argument " "1"" of type '" "Pythia8::GammaMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaMatrix * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GammaMatrix___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaMatrix *arg1 = (Pythia8::GammaMatrix *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::complex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:GammaMatrix___call__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GammaMatrix___call__" "', argument " "1"" of type '" "Pythia8::GammaMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaMatrix * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GammaMatrix___call__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GammaMatrix___call__" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::complex *) &(arg1)->operator ()(arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__complexT_double_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GammaMatrix___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaMatrix *arg1 = (Pythia8::GammaMatrix *) 0 ;
  Pythia8::complex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::complex< double > val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::GammaMatrix result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GammaMatrix___mul__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GammaMatrix___mul__" "', argument " "1"" of type '" "Pythia8::GammaMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaMatrix * >(argp1);
  ecode2 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GammaMatrix___mul__" "', argument " "2"" of type '" "Pythia8::complex""'");
  } 
  arg2 = static_cast< Pythia8::complex >(val2);
  result = (arg1)->operator *(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::GammaMatrix(static_cast< const Pythia8::GammaMatrix& >(result))), SWIGTYPE_p_Pythia8__GammaMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GammaMatrix___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaMatrix *arg1 = (Pythia8::GammaMatrix *) 0 ;
  Pythia8::complex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::complex< double > val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::GammaMatrix result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GammaMatrix___sub__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GammaMatrix___sub__" "', argument " "1"" of type '" "Pythia8::GammaMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaMatrix * >(argp1);
  ecode2 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GammaMatrix___sub__" "', argument " "2"" of type '" "Pythia8::complex""'");
  } 
  arg2 = static_cast< Pythia8::complex >(val2);
  result = (arg1)->operator -(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::GammaMatrix(static_cast< const Pythia8::GammaMatrix& >(result))), SWIGTYPE_p_Pythia8__GammaMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GammaMatrix___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaMatrix *arg1 = (Pythia8::GammaMatrix *) 0 ;
  Pythia8::complex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::complex< double > val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::GammaMatrix result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GammaMatrix___add__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GammaMatrix___add__" "', argument " "1"" of type '" "Pythia8::GammaMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaMatrix * >(argp1);
  ecode2 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GammaMatrix___add__" "', argument " "2"" of type '" "Pythia8::complex""'");
  } 
  arg2 = static_cast< Pythia8::complex >(val2);
  result = (arg1)->operator +(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::GammaMatrix(static_cast< const Pythia8::GammaMatrix& >(result))), SWIGTYPE_p_Pythia8__GammaMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GammaMatrix___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaMatrix *arg1 = (Pythia8::GammaMatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GammaMatrix___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GammaMatrix___str__" "', argument " "1"" of type '" "Pythia8::GammaMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaMatrix * >(argp1);
  result = Pythia8_GammaMatrix___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GammaMatrix___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaMatrix *arg1 = (Pythia8::GammaMatrix *) 0 ;
  std::complex< double > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::complex< double > val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::GammaMatrix result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GammaMatrix___rmul__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GammaMatrix___rmul__" "', argument " "1"" of type '" "Pythia8::GammaMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaMatrix * >(argp1);
  ecode2 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GammaMatrix___rmul__" "', argument " "2"" of type '" "std::complex< double >""'");
  } 
  arg2 = static_cast< std::complex< double > >(val2);
  result = Pythia8_GammaMatrix___rmul__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::GammaMatrix(static_cast< const Pythia8::GammaMatrix& >(result))), SWIGTYPE_p_Pythia8__GammaMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GammaMatrix___rsub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaMatrix *arg1 = (Pythia8::GammaMatrix *) 0 ;
  std::complex< double > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::complex< double > val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::GammaMatrix result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GammaMatrix___rsub__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GammaMatrix___rsub__" "', argument " "1"" of type '" "Pythia8::GammaMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaMatrix * >(argp1);
  ecode2 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GammaMatrix___rsub__" "', argument " "2"" of type '" "std::complex< double >""'");
  } 
  arg2 = static_cast< std::complex< double > >(val2);
  result = Pythia8_GammaMatrix___rsub__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::GammaMatrix(static_cast< const Pythia8::GammaMatrix& >(result))), SWIGTYPE_p_Pythia8__GammaMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GammaMatrix___radd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaMatrix *arg1 = (Pythia8::GammaMatrix *) 0 ;
  std::complex< double > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::complex< double > val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::GammaMatrix result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GammaMatrix___radd__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GammaMatrix___radd__" "', argument " "1"" of type '" "Pythia8::GammaMatrix *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaMatrix * >(argp1);
  ecode2 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GammaMatrix___radd__" "', argument " "2"" of type '" "std::complex< double >""'");
  } 
  arg2 = static_cast< std::complex< double > >(val2);
  result = Pythia8_GammaMatrix___radd__(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::GammaMatrix(static_cast< const Pythia8::GammaMatrix& >(result))), SWIGTYPE_p_Pythia8__GammaMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GammaMatrix_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__GammaMatrix, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap___mul____SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Wave4 arg1 ;
  Pythia8::GammaMatrix arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Wave4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__mul__",&obj0,&obj1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Wave4,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__mul__" "', argument " "1"" of type '" "Pythia8::Wave4""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__mul__" "', argument " "1"" of type '" "Pythia8::Wave4""'");
    } else {
      Pythia8::Wave4 * temp = reinterpret_cast< Pythia8::Wave4 * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__GammaMatrix,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__mul__" "', argument " "2"" of type '" "Pythia8::GammaMatrix""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__mul__" "', argument " "2"" of type '" "Pythia8::GammaMatrix""'");
    } else {
      Pythia8::GammaMatrix * temp = reinterpret_cast< Pythia8::GammaMatrix * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = Pythia8::operator *(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Wave4(static_cast< const Pythia8::Wave4& >(result))), SWIGTYPE_p_Pythia8__Wave4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap___mul____SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::complex arg1 ;
  Pythia8::GammaMatrix arg2 ;
  std::complex< double > val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::GammaMatrix result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__mul__",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "__mul__" "', argument " "1"" of type '" "Pythia8::complex""'");
  } 
  arg1 = static_cast< Pythia8::complex >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__GammaMatrix,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__mul__" "', argument " "2"" of type '" "Pythia8::GammaMatrix""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__mul__" "', argument " "2"" of type '" "Pythia8::GammaMatrix""'");
    } else {
      Pythia8::GammaMatrix * temp = reinterpret_cast< Pythia8::GammaMatrix * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = Pythia8::operator *(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::GammaMatrix(static_cast< const Pythia8::GammaMatrix& >(result))), SWIGTYPE_p_Pythia8__GammaMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap___mul__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Wave4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__GammaMatrix, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___mul____SWIG_4(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Hist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___mul____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Wave4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___mul____SWIG_3(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___mul____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_std_complex_Sl_double_Sg_(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Wave4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___mul____SWIG_2(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_std_complex_Sl_double_Sg_(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__GammaMatrix, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___mul____SWIG_5(self, args);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::complex arg1 ;
  Pythia8::GammaMatrix arg2 ;
  std::complex< double > val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::GammaMatrix result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__sub__",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "__sub__" "', argument " "1"" of type '" "Pythia8::complex""'");
  } 
  arg1 = static_cast< Pythia8::complex >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__GammaMatrix,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__sub__" "', argument " "2"" of type '" "Pythia8::GammaMatrix""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__sub__" "', argument " "2"" of type '" "Pythia8::GammaMatrix""'");
    } else {
      Pythia8::GammaMatrix * temp = reinterpret_cast< Pythia8::GammaMatrix * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = Pythia8::operator -(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::GammaMatrix(static_cast< const Pythia8::GammaMatrix& >(result))), SWIGTYPE_p_Pythia8__GammaMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap___sub__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Hist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___sub____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_std_complex_Sl_double_Sg_(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__GammaMatrix, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___sub____SWIG_1(self, args);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::complex arg1 ;
  Pythia8::GammaMatrix arg2 ;
  std::complex< double > val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::GammaMatrix result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__add__",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "__add__" "', argument " "1"" of type '" "Pythia8::complex""'");
  } 
  arg1 = static_cast< Pythia8::complex >(val1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__GammaMatrix,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__add__" "', argument " "2"" of type '" "Pythia8::GammaMatrix""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__add__" "', argument " "2"" of type '" "Pythia8::GammaMatrix""'");
    } else {
      Pythia8::GammaMatrix * temp = reinterpret_cast< Pythia8::GammaMatrix * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = Pythia8::operator +(arg1,arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::GammaMatrix(static_cast< const Pythia8::GammaMatrix& >(result))), SWIGTYPE_p_Pythia8__GammaMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap___add__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Hist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___add____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_std_complex_Sl_double_Sg_(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__GammaMatrix, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___add____SWIG_1(self, args);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___lshift____SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  Pythia8::GammaMatrix arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::ostream *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:__lshift__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__lshift__" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__GammaMatrix,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lshift__" "', argument " "2"" of type '" "Pythia8::GammaMatrix""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "2"" of type '" "Pythia8::GammaMatrix""'");
    } else {
      Pythia8::GammaMatrix * temp = reinterpret_cast< Pythia8::GammaMatrix * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (std::ostream *) &Pythia8::operator <<(*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap___lshift__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lshift____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__RotBstMatrix, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lshift____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Hist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lshift____SWIG_2(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Wave4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lshift____SWIG_3(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__GammaMatrix, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lshift____SWIG_4(self, args);
      }
    }
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_new_HelicityParticle__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HelicityParticle")) SWIG_fail;
  result = (Pythia8::HelicityParticle *)new Pythia8::HelicityParticle();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelicityParticle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  Pythia8::ParticleData *arg15 = (Pythia8::ParticleData *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  Pythia8::HelicityParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:new_HelicityParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HelicityParticle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HelicityParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HelicityParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HelicityParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HelicityParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HelicityParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_HelicityParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_HelicityParticle" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_HelicityParticle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_HelicityParticle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_HelicityParticle" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_HelicityParticle" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_HelicityParticle" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_HelicityParticle" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  res15 = SWIG_ConvertPtr(obj14, &argp15,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "new_HelicityParticle" "', argument " "15"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg15 = reinterpret_cast< Pythia8::ParticleData * >(argp15);
  result = (Pythia8::HelicityParticle *)new Pythia8::HelicityParticle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelicityParticle__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  Pythia8::HelicityParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:new_HelicityParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HelicityParticle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HelicityParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HelicityParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HelicityParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HelicityParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HelicityParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_HelicityParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_HelicityParticle" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_HelicityParticle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_HelicityParticle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_HelicityParticle" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_HelicityParticle" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_HelicityParticle" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_HelicityParticle" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  result = (Pythia8::HelicityParticle *)new Pythia8::HelicityParticle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelicityParticle__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  Pythia8::HelicityParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:new_HelicityParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HelicityParticle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HelicityParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HelicityParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HelicityParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HelicityParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HelicityParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_HelicityParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_HelicityParticle" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_HelicityParticle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_HelicityParticle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_HelicityParticle" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_HelicityParticle" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_HelicityParticle" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  result = (Pythia8::HelicityParticle *)new Pythia8::HelicityParticle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelicityParticle__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  Pythia8::HelicityParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:new_HelicityParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HelicityParticle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HelicityParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HelicityParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HelicityParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HelicityParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HelicityParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_HelicityParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_HelicityParticle" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_HelicityParticle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_HelicityParticle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_HelicityParticle" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_HelicityParticle" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  result = (Pythia8::HelicityParticle *)new Pythia8::HelicityParticle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelicityParticle__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  Pythia8::HelicityParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:new_HelicityParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HelicityParticle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HelicityParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HelicityParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HelicityParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HelicityParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HelicityParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_HelicityParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_HelicityParticle" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_HelicityParticle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_HelicityParticle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_HelicityParticle" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  result = (Pythia8::HelicityParticle *)new Pythia8::HelicityParticle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelicityParticle__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  double arg9 ;
  double arg10 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  Pythia8::HelicityParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:new_HelicityParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HelicityParticle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HelicityParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HelicityParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HelicityParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HelicityParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HelicityParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_HelicityParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_HelicityParticle" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_HelicityParticle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_HelicityParticle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (Pythia8::HelicityParticle *)new Pythia8::HelicityParticle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelicityParticle__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  double arg9 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  Pythia8::HelicityParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_HelicityParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HelicityParticle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HelicityParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HelicityParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HelicityParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HelicityParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HelicityParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_HelicityParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_HelicityParticle" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_HelicityParticle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (Pythia8::HelicityParticle *)new Pythia8::HelicityParticle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelicityParticle__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  Pythia8::HelicityParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:new_HelicityParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HelicityParticle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HelicityParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HelicityParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HelicityParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HelicityParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HelicityParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_HelicityParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_HelicityParticle" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  result = (Pythia8::HelicityParticle *)new Pythia8::HelicityParticle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelicityParticle__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Pythia8::HelicityParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_HelicityParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HelicityParticle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HelicityParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HelicityParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HelicityParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HelicityParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HelicityParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_HelicityParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  result = (Pythia8::HelicityParticle *)new Pythia8::HelicityParticle(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelicityParticle__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::HelicityParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_HelicityParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HelicityParticle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HelicityParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HelicityParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HelicityParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HelicityParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HelicityParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (Pythia8::HelicityParticle *)new Pythia8::HelicityParticle(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelicityParticle__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::HelicityParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_HelicityParticle",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HelicityParticle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HelicityParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HelicityParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HelicityParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HelicityParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (Pythia8::HelicityParticle *)new Pythia8::HelicityParticle(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelicityParticle__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::HelicityParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_HelicityParticle",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HelicityParticle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HelicityParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HelicityParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HelicityParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (Pythia8::HelicityParticle *)new Pythia8::HelicityParticle(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelicityParticle__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::HelicityParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_HelicityParticle",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HelicityParticle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HelicityParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HelicityParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::HelicityParticle *)new Pythia8::HelicityParticle(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelicityParticle__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::HelicityParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_HelicityParticle",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HelicityParticle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HelicityParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::HelicityParticle *)new Pythia8::HelicityParticle(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelicityParticle__SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::HelicityParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_HelicityParticle",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HelicityParticle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::HelicityParticle *)new Pythia8::HelicityParticle(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelicityParticle__SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  Pythia8::Vec4 arg9 ;
  double arg10 ;
  double arg11 ;
  Pythia8::ParticleData *arg12 = (Pythia8::ParticleData *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  Pythia8::HelicityParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:new_HelicityParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HelicityParticle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HelicityParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HelicityParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HelicityParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HelicityParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HelicityParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_HelicityParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_HelicityParticle" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_HelicityParticle" "', argument " "9"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HelicityParticle" "', argument " "9"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_HelicityParticle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_HelicityParticle" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  res12 = SWIG_ConvertPtr(obj11, &argp12,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "new_HelicityParticle" "', argument " "12"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg12 = reinterpret_cast< Pythia8::ParticleData * >(argp12);
  result = (Pythia8::HelicityParticle *)new Pythia8::HelicityParticle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelicityParticle__SWIG_17(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  Pythia8::Vec4 arg9 ;
  double arg10 ;
  double arg11 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  Pythia8::HelicityParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:new_HelicityParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HelicityParticle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HelicityParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HelicityParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HelicityParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HelicityParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HelicityParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_HelicityParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_HelicityParticle" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_HelicityParticle" "', argument " "9"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HelicityParticle" "', argument " "9"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_HelicityParticle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_HelicityParticle" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  result = (Pythia8::HelicityParticle *)new Pythia8::HelicityParticle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelicityParticle__SWIG_18(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  Pythia8::Vec4 arg9 ;
  double arg10 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  Pythia8::HelicityParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:new_HelicityParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HelicityParticle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HelicityParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HelicityParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HelicityParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HelicityParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HelicityParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_HelicityParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_HelicityParticle" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_HelicityParticle" "', argument " "9"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HelicityParticle" "', argument " "9"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_HelicityParticle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (Pythia8::HelicityParticle *)new Pythia8::HelicityParticle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelicityParticle__SWIG_19(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  Pythia8::Vec4 arg9 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  Pythia8::HelicityParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_HelicityParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HelicityParticle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HelicityParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HelicityParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HelicityParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HelicityParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HelicityParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_HelicityParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_HelicityParticle" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  {
    res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_HelicityParticle" "', argument " "9"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HelicityParticle" "', argument " "9"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  result = (Pythia8::HelicityParticle *)new Pythia8::HelicityParticle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelicityParticle__SWIG_20(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = 0 ;
  Pythia8::ParticleData *arg2 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::HelicityParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_HelicityParticle",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Particle,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HelicityParticle" "', argument " "1"" of type '" "Pythia8::Particle const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HelicityParticle" "', argument " "1"" of type '" "Pythia8::Particle const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HelicityParticle" "', argument " "2"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ParticleData * >(argp2);
  result = (Pythia8::HelicityParticle *)new Pythia8::HelicityParticle((Pythia8::Particle const &)*arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelicityParticle__SWIG_21(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::HelicityParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_HelicityParticle",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Particle,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HelicityParticle" "', argument " "1"" of type '" "Pythia8::Particle const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HelicityParticle" "', argument " "1"" of type '" "Pythia8::Particle const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (Pythia8::HelicityParticle *)new Pythia8::HelicityParticle((Pythia8::Particle const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelicityParticle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[16] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 15) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_HelicityParticle__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HelicityParticle__SWIG_21(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_HelicityParticle__SWIG_15(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Particle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_HelicityParticle__SWIG_20(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_HelicityParticle__SWIG_14(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_HelicityParticle__SWIG_13(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_HelicityParticle__SWIG_12(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_HelicityParticle__SWIG_11(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_HelicityParticle__SWIG_10(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_HelicityParticle__SWIG_9(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_HelicityParticle__SWIG_8(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_HelicityParticle__SWIG_19(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_HelicityParticle__SWIG_7(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_HelicityParticle__SWIG_18(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_HelicityParticle__SWIG_6(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_HelicityParticle__SWIG_17(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_HelicityParticle__SWIG_5(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_ConvertPtr(argv[8], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_new_HelicityParticle__SWIG_16(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_HelicityParticle__SWIG_4(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_HelicityParticle__SWIG_3(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_HelicityParticle__SWIG_2(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[14], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  return _wrap_new_HelicityParticle__SWIG_1(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_HelicityParticle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::HelicityParticle::HelicityParticle()\n"
    "    Pythia8::HelicityParticle::HelicityParticle(int,int,int,int,int,int,int,int,double,double,double,double,double,double,Pythia8::ParticleData *)\n"
    "    Pythia8::HelicityParticle::HelicityParticle(int,int,int,int,int,int,int,int,double,double,double,double,double,double)\n"
    "    Pythia8::HelicityParticle::HelicityParticle(int,int,int,int,int,int,int,int,double,double,double,double,double)\n"
    "    Pythia8::HelicityParticle::HelicityParticle(int,int,int,int,int,int,int,int,double,double,double,double)\n"
    "    Pythia8::HelicityParticle::HelicityParticle(int,int,int,int,int,int,int,int,double,double,double)\n"
    "    Pythia8::HelicityParticle::HelicityParticle(int,int,int,int,int,int,int,int,double,double)\n"
    "    Pythia8::HelicityParticle::HelicityParticle(int,int,int,int,int,int,int,int,double)\n"
    "    Pythia8::HelicityParticle::HelicityParticle(int,int,int,int,int,int,int,int)\n"
    "    Pythia8::HelicityParticle::HelicityParticle(int,int,int,int,int,int,int)\n"
    "    Pythia8::HelicityParticle::HelicityParticle(int,int,int,int,int,int)\n"
    "    Pythia8::HelicityParticle::HelicityParticle(int,int,int,int,int)\n"
    "    Pythia8::HelicityParticle::HelicityParticle(int,int,int,int)\n"
    "    Pythia8::HelicityParticle::HelicityParticle(int,int,int)\n"
    "    Pythia8::HelicityParticle::HelicityParticle(int,int)\n"
    "    Pythia8::HelicityParticle::HelicityParticle(int)\n"
    "    Pythia8::HelicityParticle::HelicityParticle(int,int,int,int,int,int,int,int,Pythia8::Vec4,double,double,Pythia8::ParticleData *)\n"
    "    Pythia8::HelicityParticle::HelicityParticle(int,int,int,int,int,int,int,int,Pythia8::Vec4,double,double)\n"
    "    Pythia8::HelicityParticle::HelicityParticle(int,int,int,int,int,int,int,int,Pythia8::Vec4,double)\n"
    "    Pythia8::HelicityParticle::HelicityParticle(int,int,int,int,int,int,int,int,Pythia8::Vec4)\n"
    "    Pythia8::HelicityParticle::HelicityParticle(Pythia8::Particle const &,Pythia8::ParticleData *)\n"
    "    Pythia8::HelicityParticle::HelicityParticle(Pythia8::Particle const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HelicityParticle_wave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityParticle *arg1 = (Pythia8::HelicityParticle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Wave4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HelicityParticle_wave",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityParticle_wave" "', argument " "1"" of type '" "Pythia8::HelicityParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HelicityParticle_wave" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (arg1)->wave(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Wave4(static_cast< const Pythia8::Wave4& >(result))), SWIGTYPE_p_Pythia8__Wave4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityParticle_waveBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityParticle *arg1 = (Pythia8::HelicityParticle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Wave4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HelicityParticle_waveBar",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityParticle_waveBar" "', argument " "1"" of type '" "Pythia8::HelicityParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HelicityParticle_waveBar" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (arg1)->waveBar(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Wave4(static_cast< const Pythia8::Wave4& >(result))), SWIGTYPE_p_Pythia8__Wave4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityParticle_normalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityParticle *arg1 = (Pythia8::HelicityParticle *) 0 ;
  std::vector< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > >,std::allocator< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HelicityParticle_normalize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityParticle_normalize" "', argument " "1"" of type '" "Pythia8::HelicityParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityParticle * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HelicityParticle_normalize" "', argument " "2"" of type '" "std::vector< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > >,std::allocator< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HelicityParticle_normalize" "', argument " "2"" of type '" "std::vector< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > >,std::allocator< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > >,std::allocator< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > > > > * >(argp2);
  (arg1)->normalize(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityParticle_spinStates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityParticle *arg1 = (Pythia8::HelicityParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HelicityParticle_spinStates",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityParticle_spinStates" "', argument " "1"" of type '" "Pythia8::HelicityParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityParticle * >(argp1);
  result = (int)(arg1)->spinStates();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityParticle_m__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityParticle *arg1 = (Pythia8::HelicityParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HelicityParticle_m",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityParticle_m" "', argument " "1"" of type '" "Pythia8::HelicityParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityParticle * >(argp1);
  result = (double)(arg1)->m();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityParticle_m__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityParticle *arg1 = (Pythia8::HelicityParticle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HelicityParticle_m",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityParticle_m" "', argument " "1"" of type '" "Pythia8::HelicityParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityParticle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HelicityParticle_m" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->m(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityParticle_m(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HelicityParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_HelicityParticle_m__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HelicityParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_HelicityParticle_m__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'HelicityParticle_m'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::HelicityParticle::m()\n"
    "    Pythia8::HelicityParticle::m(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HelicityParticle_index__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityParticle *arg1 = (Pythia8::HelicityParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HelicityParticle_index",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityParticle_index" "', argument " "1"" of type '" "Pythia8::HelicityParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityParticle * >(argp1);
  result = (int)((Pythia8::HelicityParticle const *)arg1)->index();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityParticle_index__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityParticle *arg1 = (Pythia8::HelicityParticle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HelicityParticle_index",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityParticle_index" "', argument " "1"" of type '" "Pythia8::HelicityParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HelicityParticle_index" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->index(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityParticle_index(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HelicityParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_HelicityParticle_index__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HelicityParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_HelicityParticle_index__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'HelicityParticle_index'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::HelicityParticle::index() const\n"
    "    Pythia8::HelicityParticle::index(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HelicityParticle_direction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityParticle *arg1 = (Pythia8::HelicityParticle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HelicityParticle_direction_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityParticle_direction_set" "', argument " "1"" of type '" "Pythia8::HelicityParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HelicityParticle_direction_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->direction = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityParticle_direction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityParticle *arg1 = (Pythia8::HelicityParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HelicityParticle_direction_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityParticle_direction_get" "', argument " "1"" of type '" "Pythia8::HelicityParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityParticle * >(argp1);
  result = (int) ((arg1)->direction);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityParticle_rho_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityParticle *arg1 = (Pythia8::HelicityParticle *) 0 ;
  std::vector< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > >,std::allocator< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > > > > *arg2 = (std::vector< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > >,std::allocator< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HelicityParticle_rho_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityParticle_rho_set" "', argument " "1"" of type '" "Pythia8::HelicityParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityParticle * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HelicityParticle_rho_set" "', argument " "2"" of type '" "std::vector< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > >,std::allocator< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > >,std::allocator< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > > > > * >(argp2);
  if (arg1) (arg1)->rho = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityParticle_rho_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityParticle *arg1 = (Pythia8::HelicityParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > >,std::allocator< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HelicityParticle_rho_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityParticle_rho_get" "', argument " "1"" of type '" "Pythia8::HelicityParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityParticle * >(argp1);
  result = (std::vector< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > >,std::allocator< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > > > > *)& ((arg1)->rho);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityParticle_D_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityParticle *arg1 = (Pythia8::HelicityParticle *) 0 ;
  std::vector< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > >,std::allocator< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > > > > *arg2 = (std::vector< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > >,std::allocator< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HelicityParticle_D_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityParticle_D_set" "', argument " "1"" of type '" "Pythia8::HelicityParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityParticle * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HelicityParticle_D_set" "', argument " "2"" of type '" "std::vector< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > >,std::allocator< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > >,std::allocator< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > > > > * >(argp2);
  if (arg1) (arg1)->D = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityParticle_D_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityParticle *arg1 = (Pythia8::HelicityParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > >,std::allocator< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HelicityParticle_D_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityParticle_D_get" "', argument " "1"" of type '" "Pythia8::HelicityParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityParticle * >(argp1);
  result = (std::vector< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > >,std::allocator< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > > > > *)& ((arg1)->D);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HelicityParticle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityParticle *arg1 = (Pythia8::HelicityParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HelicityParticle",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityParticle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HelicityParticle" "', argument " "1"" of type '" "Pythia8::HelicityParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityParticle * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HelicityParticle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HelicityParticle, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_HelicityMatrixElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityMatrixElement *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HelicityMatrixElement")) SWIG_fail;
  result = (Pythia8::HelicityMatrixElement *)new Pythia8::HelicityMatrixElement();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityMatrixElement, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HelicityMatrixElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityMatrixElement *arg1 = (Pythia8::HelicityMatrixElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HelicityMatrixElement",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityMatrixElement, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HelicityMatrixElement" "', argument " "1"" of type '" "Pythia8::HelicityMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityMatrixElement * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityMatrixElement_initPointers__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityMatrixElement *arg1 = (Pythia8::HelicityMatrixElement *) 0 ;
  Pythia8::ParticleData *arg2 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Couplings *arg3 = (Pythia8::Couplings *) 0 ;
  Pythia8::Settings *arg4 = (Pythia8::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:HelicityMatrixElement_initPointers",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityMatrixElement_initPointers" "', argument " "1"" of type '" "Pythia8::HelicityMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HelicityMatrixElement_initPointers" "', argument " "2"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ParticleData * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HelicityMatrixElement_initPointers" "', argument " "3"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Couplings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "HelicityMatrixElement_initPointers" "', argument " "4"" of type '" "Pythia8::Settings *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Settings * >(argp4);
  (arg1)->initPointers(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityMatrixElement_initPointers__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityMatrixElement *arg1 = (Pythia8::HelicityMatrixElement *) 0 ;
  Pythia8::ParticleData *arg2 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Couplings *arg3 = (Pythia8::Couplings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:HelicityMatrixElement_initPointers",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityMatrixElement_initPointers" "', argument " "1"" of type '" "Pythia8::HelicityMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HelicityMatrixElement_initPointers" "', argument " "2"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ParticleData * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HelicityMatrixElement_initPointers" "', argument " "3"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Couplings * >(argp3);
  (arg1)->initPointers(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityMatrixElement_initPointers(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HelicityMatrixElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Couplings, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_HelicityMatrixElement_initPointers__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HelicityMatrixElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Couplings, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_HelicityMatrixElement_initPointers__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'HelicityMatrixElement_initPointers'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::HelicityMatrixElement::initPointers(Pythia8::ParticleData *,Pythia8::Couplings *,Pythia8::Settings *)\n"
    "    Pythia8::HelicityMatrixElement::initPointers(Pythia8::ParticleData *,Pythia8::Couplings *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HelicityMatrixElement_initChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityMatrixElement *arg1 = (Pythia8::HelicityMatrixElement *) 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::HelicityMatrixElement *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HelicityMatrixElement_initChannel",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityMatrixElement_initChannel" "', argument " "1"" of type '" "Pythia8::HelicityMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HelicityMatrixElement_initChannel" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HelicityMatrixElement_initChannel" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp2);
  result = (Pythia8::HelicityMatrixElement *)(arg1)->initChannel(*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityMatrixElement, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityMatrixElement_decayWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityMatrixElement *arg1 = (Pythia8::HelicityMatrixElement *) 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HelicityMatrixElement_decayWeight",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityMatrixElement_decayWeight" "', argument " "1"" of type '" "Pythia8::HelicityMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HelicityMatrixElement_decayWeight" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HelicityMatrixElement_decayWeight" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp2);
  result = (double)(arg1)->decayWeight(*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityMatrixElement_decayWeightMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityMatrixElement *arg1 = (Pythia8::HelicityMatrixElement *) 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HelicityMatrixElement_decayWeightMax",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityMatrixElement_decayWeightMax" "', argument " "1"" of type '" "Pythia8::HelicityMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HelicityMatrixElement_decayWeightMax" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HelicityMatrixElement_decayWeightMax" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp2);
  result = (double)(arg1)->decayWeightMax(*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityMatrixElement_calculateME(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityMatrixElement *arg1 = (Pythia8::HelicityMatrixElement *) 0 ;
  std::vector< int,std::allocator< int > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::complex result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HelicityMatrixElement_calculateME",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityMatrixElement_calculateME" "', argument " "1"" of type '" "Pythia8::HelicityMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityMatrixElement * >(argp1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HelicityMatrixElement_calculateME" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->calculateME(arg2);
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityMatrixElement_calculateD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityMatrixElement *arg1 = (Pythia8::HelicityMatrixElement *) 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HelicityMatrixElement_calculateD",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityMatrixElement_calculateD" "', argument " "1"" of type '" "Pythia8::HelicityMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityMatrixElement * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HelicityMatrixElement_calculateD" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HelicityMatrixElement_calculateD" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp2);
  (arg1)->calculateD(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityMatrixElement_calculateRho(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityMatrixElement *arg1 = (Pythia8::HelicityMatrixElement *) 0 ;
  unsigned int arg2 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:HelicityMatrixElement_calculateRho",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityMatrixElement_calculateRho" "', argument " "1"" of type '" "Pythia8::HelicityMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityMatrixElement * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HelicityMatrixElement_calculateRho" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HelicityMatrixElement_calculateRho" "', argument " "3"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HelicityMatrixElement_calculateRho" "', argument " "3"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp3);
  (arg1)->calculateRho(arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityMatrixElement_setFermionLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityMatrixElement *arg1 = (Pythia8::HelicityMatrixElement *) 0 ;
  int arg2 ;
  Pythia8::HelicityParticle *arg3 = 0 ;
  Pythia8::HelicityParticle *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:HelicityMatrixElement_setFermionLine",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityMatrixElement_setFermionLine" "', argument " "1"" of type '" "Pythia8::HelicityMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityMatrixElement * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HelicityMatrixElement_setFermionLine" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__HelicityParticle,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HelicityMatrixElement_setFermionLine" "', argument " "3"" of type '" "Pythia8::HelicityParticle &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HelicityMatrixElement_setFermionLine" "', argument " "3"" of type '" "Pythia8::HelicityParticle &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::HelicityParticle * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__HelicityParticle,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "HelicityMatrixElement_setFermionLine" "', argument " "4"" of type '" "Pythia8::HelicityParticle &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HelicityMatrixElement_setFermionLine" "', argument " "4"" of type '" "Pythia8::HelicityParticle &""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::HelicityParticle * >(argp4);
  (arg1)->setFermionLine(arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityMatrixElement_breitWigner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityMatrixElement *arg1 = (Pythia8::HelicityMatrixElement *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::complex result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:HelicityMatrixElement_breitWigner",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityMatrixElement_breitWigner" "', argument " "1"" of type '" "Pythia8::HelicityMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityMatrixElement * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HelicityMatrixElement_breitWigner" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HelicityMatrixElement_breitWigner" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HelicityMatrixElement_breitWigner" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (arg1)->breitWigner(arg2,arg3,arg4);
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityMatrixElement_sBreitWigner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityMatrixElement *arg1 = (Pythia8::HelicityMatrixElement *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::complex result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:HelicityMatrixElement_sBreitWigner",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityMatrixElement_sBreitWigner" "', argument " "1"" of type '" "Pythia8::HelicityMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityMatrixElement * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HelicityMatrixElement_sBreitWigner" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HelicityMatrixElement_sBreitWigner" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HelicityMatrixElement_sBreitWigner" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "HelicityMatrixElement_sBreitWigner" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "HelicityMatrixElement_sBreitWigner" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (arg1)->sBreitWigner(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityMatrixElement_pBreitWigner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityMatrixElement *arg1 = (Pythia8::HelicityMatrixElement *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::complex result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:HelicityMatrixElement_pBreitWigner",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityMatrixElement_pBreitWigner" "', argument " "1"" of type '" "Pythia8::HelicityMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityMatrixElement * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HelicityMatrixElement_pBreitWigner" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HelicityMatrixElement_pBreitWigner" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HelicityMatrixElement_pBreitWigner" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "HelicityMatrixElement_pBreitWigner" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "HelicityMatrixElement_pBreitWigner" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (arg1)->pBreitWigner(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelicityMatrixElement_dBreitWigner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HelicityMatrixElement *arg1 = (Pythia8::HelicityMatrixElement *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::complex result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:HelicityMatrixElement_dBreitWigner",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HelicityMatrixElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelicityMatrixElement_dBreitWigner" "', argument " "1"" of type '" "Pythia8::HelicityMatrixElement *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HelicityMatrixElement * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HelicityMatrixElement_dBreitWigner" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HelicityMatrixElement_dBreitWigner" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HelicityMatrixElement_dBreitWigner" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "HelicityMatrixElement_dBreitWigner" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "HelicityMatrixElement_dBreitWigner" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (arg1)->dBreitWigner(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HelicityMatrixElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HelicityMatrixElement, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_HMETwoFermions2W2TwoFermions_initConstants(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETwoFermions2W2TwoFermions *arg1 = (Pythia8::HMETwoFermions2W2TwoFermions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HMETwoFermions2W2TwoFermions_initConstants",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETwoFermions2W2TwoFermions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETwoFermions2W2TwoFermions_initConstants" "', argument " "1"" of type '" "Pythia8::HMETwoFermions2W2TwoFermions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETwoFermions2W2TwoFermions * >(argp1);
  (arg1)->initConstants();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HMETwoFermions2W2TwoFermions_initWaves(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETwoFermions2W2TwoFermions *arg1 = (Pythia8::HMETwoFermions2W2TwoFermions *) 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMETwoFermions2W2TwoFermions_initWaves",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETwoFermions2W2TwoFermions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETwoFermions2W2TwoFermions_initWaves" "', argument " "1"" of type '" "Pythia8::HMETwoFermions2W2TwoFermions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETwoFermions2W2TwoFermions * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HMETwoFermions2W2TwoFermions_initWaves" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HMETwoFermions2W2TwoFermions_initWaves" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp2);
  (arg1)->initWaves(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HMETwoFermions2W2TwoFermions_calculateME(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETwoFermions2W2TwoFermions *arg1 = (Pythia8::HMETwoFermions2W2TwoFermions *) 0 ;
  std::vector< int,std::allocator< int > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::complex result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMETwoFermions2W2TwoFermions_calculateME",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETwoFermions2W2TwoFermions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETwoFermions2W2TwoFermions_calculateME" "', argument " "1"" of type '" "Pythia8::HMETwoFermions2W2TwoFermions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETwoFermions2W2TwoFermions * >(argp1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HMETwoFermions2W2TwoFermions_calculateME" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->calculateME(arg2);
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HMETwoFermions2W2TwoFermions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETwoFermions2W2TwoFermions *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HMETwoFermions2W2TwoFermions")) SWIG_fail;
  result = (Pythia8::HMETwoFermions2W2TwoFermions *)new Pythia8::HMETwoFermions2W2TwoFermions();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HMETwoFermions2W2TwoFermions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HMETwoFermions2W2TwoFermions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETwoFermions2W2TwoFermions *arg1 = (Pythia8::HMETwoFermions2W2TwoFermions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HMETwoFermions2W2TwoFermions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETwoFermions2W2TwoFermions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HMETwoFermions2W2TwoFermions" "', argument " "1"" of type '" "Pythia8::HMETwoFermions2W2TwoFermions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETwoFermions2W2TwoFermions * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HMETwoFermions2W2TwoFermions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HMETwoFermions2W2TwoFermions, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_HMETwoFermions2GammaZ2TwoFermions_initConstants(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETwoFermions2GammaZ2TwoFermions *arg1 = (Pythia8::HMETwoFermions2GammaZ2TwoFermions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HMETwoFermions2GammaZ2TwoFermions_initConstants",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETwoFermions2GammaZ2TwoFermions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETwoFermions2GammaZ2TwoFermions_initConstants" "', argument " "1"" of type '" "Pythia8::HMETwoFermions2GammaZ2TwoFermions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETwoFermions2GammaZ2TwoFermions * >(argp1);
  (arg1)->initConstants();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HMETwoFermions2GammaZ2TwoFermions_initWaves(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETwoFermions2GammaZ2TwoFermions *arg1 = (Pythia8::HMETwoFermions2GammaZ2TwoFermions *) 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMETwoFermions2GammaZ2TwoFermions_initWaves",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETwoFermions2GammaZ2TwoFermions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETwoFermions2GammaZ2TwoFermions_initWaves" "', argument " "1"" of type '" "Pythia8::HMETwoFermions2GammaZ2TwoFermions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETwoFermions2GammaZ2TwoFermions * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HMETwoFermions2GammaZ2TwoFermions_initWaves" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HMETwoFermions2GammaZ2TwoFermions_initWaves" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp2);
  (arg1)->initWaves(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HMETwoFermions2GammaZ2TwoFermions_calculateME(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETwoFermions2GammaZ2TwoFermions *arg1 = (Pythia8::HMETwoFermions2GammaZ2TwoFermions *) 0 ;
  std::vector< int,std::allocator< int > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::complex result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMETwoFermions2GammaZ2TwoFermions_calculateME",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETwoFermions2GammaZ2TwoFermions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETwoFermions2GammaZ2TwoFermions_calculateME" "', argument " "1"" of type '" "Pythia8::HMETwoFermions2GammaZ2TwoFermions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETwoFermions2GammaZ2TwoFermions * >(argp1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HMETwoFermions2GammaZ2TwoFermions_calculateME" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->calculateME(arg2);
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HMETwoFermions2GammaZ2TwoFermions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETwoFermions2GammaZ2TwoFermions *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HMETwoFermions2GammaZ2TwoFermions")) SWIG_fail;
  result = (Pythia8::HMETwoFermions2GammaZ2TwoFermions *)new Pythia8::HMETwoFermions2GammaZ2TwoFermions();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HMETwoFermions2GammaZ2TwoFermions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HMETwoFermions2GammaZ2TwoFermions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETwoFermions2GammaZ2TwoFermions *arg1 = (Pythia8::HMETwoFermions2GammaZ2TwoFermions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HMETwoFermions2GammaZ2TwoFermions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETwoFermions2GammaZ2TwoFermions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HMETwoFermions2GammaZ2TwoFermions" "', argument " "1"" of type '" "Pythia8::HMETwoFermions2GammaZ2TwoFermions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETwoFermions2GammaZ2TwoFermions * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HMETwoFermions2GammaZ2TwoFermions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HMETwoFermions2GammaZ2TwoFermions, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_HMEX2TwoFermions_initWaves(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMEX2TwoFermions *arg1 = (Pythia8::HMEX2TwoFermions *) 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMEX2TwoFermions_initWaves",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMEX2TwoFermions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMEX2TwoFermions_initWaves" "', argument " "1"" of type '" "Pythia8::HMEX2TwoFermions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMEX2TwoFermions * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HMEX2TwoFermions_initWaves" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HMEX2TwoFermions_initWaves" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp2);
  (arg1)->initWaves(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HMEX2TwoFermions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMEX2TwoFermions *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HMEX2TwoFermions")) SWIG_fail;
  result = (Pythia8::HMEX2TwoFermions *)new Pythia8::HMEX2TwoFermions();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HMEX2TwoFermions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HMEX2TwoFermions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMEX2TwoFermions *arg1 = (Pythia8::HMEX2TwoFermions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HMEX2TwoFermions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMEX2TwoFermions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HMEX2TwoFermions" "', argument " "1"" of type '" "Pythia8::HMEX2TwoFermions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMEX2TwoFermions * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HMEX2TwoFermions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HMEX2TwoFermions, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_HMEW2TwoFermions_initConstants(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMEW2TwoFermions *arg1 = (Pythia8::HMEW2TwoFermions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HMEW2TwoFermions_initConstants",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMEW2TwoFermions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMEW2TwoFermions_initConstants" "', argument " "1"" of type '" "Pythia8::HMEW2TwoFermions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMEW2TwoFermions * >(argp1);
  (arg1)->initConstants();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HMEW2TwoFermions_calculateME(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMEW2TwoFermions *arg1 = (Pythia8::HMEW2TwoFermions *) 0 ;
  std::vector< int,std::allocator< int > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::complex result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMEW2TwoFermions_calculateME",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMEW2TwoFermions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMEW2TwoFermions_calculateME" "', argument " "1"" of type '" "Pythia8::HMEW2TwoFermions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMEW2TwoFermions * >(argp1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HMEW2TwoFermions_calculateME" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->calculateME(arg2);
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HMEW2TwoFermions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMEW2TwoFermions *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HMEW2TwoFermions")) SWIG_fail;
  result = (Pythia8::HMEW2TwoFermions *)new Pythia8::HMEW2TwoFermions();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HMEW2TwoFermions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HMEW2TwoFermions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMEW2TwoFermions *arg1 = (Pythia8::HMEW2TwoFermions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HMEW2TwoFermions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMEW2TwoFermions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HMEW2TwoFermions" "', argument " "1"" of type '" "Pythia8::HMEW2TwoFermions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMEW2TwoFermions * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HMEW2TwoFermions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HMEW2TwoFermions, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_HMEGamma2TwoFermions_calculateME(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMEGamma2TwoFermions *arg1 = (Pythia8::HMEGamma2TwoFermions *) 0 ;
  std::vector< int,std::allocator< int > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::complex result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMEGamma2TwoFermions_calculateME",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMEGamma2TwoFermions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMEGamma2TwoFermions_calculateME" "', argument " "1"" of type '" "Pythia8::HMEGamma2TwoFermions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMEGamma2TwoFermions * >(argp1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HMEGamma2TwoFermions_calculateME" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->calculateME(arg2);
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HMEGamma2TwoFermions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMEGamma2TwoFermions *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HMEGamma2TwoFermions")) SWIG_fail;
  result = (Pythia8::HMEGamma2TwoFermions *)new Pythia8::HMEGamma2TwoFermions();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HMEGamma2TwoFermions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HMEGamma2TwoFermions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMEGamma2TwoFermions *arg1 = (Pythia8::HMEGamma2TwoFermions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HMEGamma2TwoFermions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMEGamma2TwoFermions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HMEGamma2TwoFermions" "', argument " "1"" of type '" "Pythia8::HMEGamma2TwoFermions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMEGamma2TwoFermions * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HMEGamma2TwoFermions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HMEGamma2TwoFermions, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_HMEZ2TwoFermions_initConstants(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMEZ2TwoFermions *arg1 = (Pythia8::HMEZ2TwoFermions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HMEZ2TwoFermions_initConstants",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMEZ2TwoFermions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMEZ2TwoFermions_initConstants" "', argument " "1"" of type '" "Pythia8::HMEZ2TwoFermions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMEZ2TwoFermions * >(argp1);
  (arg1)->initConstants();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HMEZ2TwoFermions_calculateME(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMEZ2TwoFermions *arg1 = (Pythia8::HMEZ2TwoFermions *) 0 ;
  std::vector< int,std::allocator< int > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::complex result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMEZ2TwoFermions_calculateME",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMEZ2TwoFermions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMEZ2TwoFermions_calculateME" "', argument " "1"" of type '" "Pythia8::HMEZ2TwoFermions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMEZ2TwoFermions * >(argp1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HMEZ2TwoFermions_calculateME" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->calculateME(arg2);
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HMEZ2TwoFermions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMEZ2TwoFermions *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HMEZ2TwoFermions")) SWIG_fail;
  result = (Pythia8::HMEZ2TwoFermions *)new Pythia8::HMEZ2TwoFermions();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HMEZ2TwoFermions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HMEZ2TwoFermions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMEZ2TwoFermions *arg1 = (Pythia8::HMEZ2TwoFermions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HMEZ2TwoFermions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMEZ2TwoFermions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HMEZ2TwoFermions" "', argument " "1"" of type '" "Pythia8::HMEZ2TwoFermions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMEZ2TwoFermions * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HMEZ2TwoFermions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HMEZ2TwoFermions, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_HMEHiggs2TwoFermions_initConstants(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMEHiggs2TwoFermions *arg1 = (Pythia8::HMEHiggs2TwoFermions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HMEHiggs2TwoFermions_initConstants",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMEHiggs2TwoFermions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMEHiggs2TwoFermions_initConstants" "', argument " "1"" of type '" "Pythia8::HMEHiggs2TwoFermions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMEHiggs2TwoFermions * >(argp1);
  (arg1)->initConstants();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HMEHiggs2TwoFermions_initWaves(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMEHiggs2TwoFermions *arg1 = (Pythia8::HMEHiggs2TwoFermions *) 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMEHiggs2TwoFermions_initWaves",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMEHiggs2TwoFermions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMEHiggs2TwoFermions_initWaves" "', argument " "1"" of type '" "Pythia8::HMEHiggs2TwoFermions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMEHiggs2TwoFermions * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HMEHiggs2TwoFermions_initWaves" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HMEHiggs2TwoFermions_initWaves" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp2);
  (arg1)->initWaves(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HMEHiggs2TwoFermions_calculateME(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMEHiggs2TwoFermions *arg1 = (Pythia8::HMEHiggs2TwoFermions *) 0 ;
  std::vector< int,std::allocator< int > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::complex result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMEHiggs2TwoFermions_calculateME",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMEHiggs2TwoFermions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMEHiggs2TwoFermions_calculateME" "', argument " "1"" of type '" "Pythia8::HMEHiggs2TwoFermions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMEHiggs2TwoFermions * >(argp1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HMEHiggs2TwoFermions_calculateME" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->calculateME(arg2);
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HMEHiggs2TwoFermions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMEHiggs2TwoFermions *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HMEHiggs2TwoFermions")) SWIG_fail;
  result = (Pythia8::HMEHiggs2TwoFermions *)new Pythia8::HMEHiggs2TwoFermions();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HMEHiggs2TwoFermions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HMEHiggs2TwoFermions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMEHiggs2TwoFermions *arg1 = (Pythia8::HMEHiggs2TwoFermions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HMEHiggs2TwoFermions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMEHiggs2TwoFermions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HMEHiggs2TwoFermions" "', argument " "1"" of type '" "Pythia8::HMEHiggs2TwoFermions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMEHiggs2TwoFermions * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HMEHiggs2TwoFermions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HMEHiggs2TwoFermions, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_HMETauDecay_initWaves(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETauDecay *arg1 = (Pythia8::HMETauDecay *) 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMETauDecay_initWaves",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETauDecay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETauDecay_initWaves" "', argument " "1"" of type '" "Pythia8::HMETauDecay *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETauDecay * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HMETauDecay_initWaves" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HMETauDecay_initWaves" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp2);
  (arg1)->initWaves(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HMETauDecay_calculateME(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETauDecay *arg1 = (Pythia8::HMETauDecay *) 0 ;
  std::vector< int,std::allocator< int > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::complex result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMETauDecay_calculateME",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETauDecay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETauDecay_calculateME" "', argument " "1"" of type '" "Pythia8::HMETauDecay *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETauDecay * >(argp1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HMETauDecay_calculateME" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->calculateME(arg2);
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HMETauDecay_decayWeightMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETauDecay *arg1 = (Pythia8::HMETauDecay *) 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMETauDecay_decayWeightMax",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETauDecay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETauDecay_decayWeightMax" "', argument " "1"" of type '" "Pythia8::HMETauDecay *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETauDecay * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HMETauDecay_decayWeightMax" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HMETauDecay_decayWeightMax" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp2);
  result = (double)(arg1)->decayWeightMax(*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HMETauDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETauDecay *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HMETauDecay")) SWIG_fail;
  result = (Pythia8::HMETauDecay *)new Pythia8::HMETauDecay();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HMETauDecay, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HMETauDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETauDecay *arg1 = (Pythia8::HMETauDecay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HMETauDecay",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETauDecay, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HMETauDecay" "', argument " "1"" of type '" "Pythia8::HMETauDecay *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETauDecay * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HMETauDecay_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HMETauDecay, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_HMETau2Meson_initConstants(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2Meson *arg1 = (Pythia8::HMETau2Meson *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HMETau2Meson_initConstants",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2Meson, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETau2Meson_initConstants" "', argument " "1"" of type '" "Pythia8::HMETau2Meson *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2Meson * >(argp1);
  (arg1)->initConstants();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HMETau2Meson_initHadronicCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2Meson *arg1 = (Pythia8::HMETau2Meson *) 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMETau2Meson_initHadronicCurrent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2Meson, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETau2Meson_initHadronicCurrent" "', argument " "1"" of type '" "Pythia8::HMETau2Meson *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2Meson * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HMETau2Meson_initHadronicCurrent" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HMETau2Meson_initHadronicCurrent" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp2);
  (arg1)->initHadronicCurrent(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HMETau2Meson(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2Meson *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HMETau2Meson")) SWIG_fail;
  result = (Pythia8::HMETau2Meson *)new Pythia8::HMETau2Meson();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HMETau2Meson, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HMETau2Meson(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2Meson *arg1 = (Pythia8::HMETau2Meson *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HMETau2Meson",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2Meson, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HMETau2Meson" "', argument " "1"" of type '" "Pythia8::HMETau2Meson *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2Meson * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HMETau2Meson_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HMETau2Meson, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_HMETau2TwoLeptons_initConstants(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2TwoLeptons *arg1 = (Pythia8::HMETau2TwoLeptons *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HMETau2TwoLeptons_initConstants",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2TwoLeptons, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETau2TwoLeptons_initConstants" "', argument " "1"" of type '" "Pythia8::HMETau2TwoLeptons *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2TwoLeptons * >(argp1);
  (arg1)->initConstants();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HMETau2TwoLeptons_initWaves(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2TwoLeptons *arg1 = (Pythia8::HMETau2TwoLeptons *) 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMETau2TwoLeptons_initWaves",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2TwoLeptons, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETau2TwoLeptons_initWaves" "', argument " "1"" of type '" "Pythia8::HMETau2TwoLeptons *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2TwoLeptons * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HMETau2TwoLeptons_initWaves" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HMETau2TwoLeptons_initWaves" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp2);
  (arg1)->initWaves(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HMETau2TwoLeptons_calculateME(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2TwoLeptons *arg1 = (Pythia8::HMETau2TwoLeptons *) 0 ;
  std::vector< int,std::allocator< int > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::complex result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMETau2TwoLeptons_calculateME",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2TwoLeptons, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETau2TwoLeptons_calculateME" "', argument " "1"" of type '" "Pythia8::HMETau2TwoLeptons *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2TwoLeptons * >(argp1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HMETau2TwoLeptons_calculateME" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->calculateME(arg2);
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HMETau2TwoLeptons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2TwoLeptons *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HMETau2TwoLeptons")) SWIG_fail;
  result = (Pythia8::HMETau2TwoLeptons *)new Pythia8::HMETau2TwoLeptons();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HMETau2TwoLeptons, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HMETau2TwoLeptons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2TwoLeptons *arg1 = (Pythia8::HMETau2TwoLeptons *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HMETau2TwoLeptons",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2TwoLeptons, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HMETau2TwoLeptons" "', argument " "1"" of type '" "Pythia8::HMETau2TwoLeptons *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2TwoLeptons * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HMETau2TwoLeptons_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HMETau2TwoLeptons, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_HMETau2TwoMesonsViaVector_initConstants(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2TwoMesonsViaVector *arg1 = (Pythia8::HMETau2TwoMesonsViaVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HMETau2TwoMesonsViaVector_initConstants",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2TwoMesonsViaVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETau2TwoMesonsViaVector_initConstants" "', argument " "1"" of type '" "Pythia8::HMETau2TwoMesonsViaVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2TwoMesonsViaVector * >(argp1);
  (arg1)->initConstants();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HMETau2TwoMesonsViaVector_initHadronicCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2TwoMesonsViaVector *arg1 = (Pythia8::HMETau2TwoMesonsViaVector *) 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMETau2TwoMesonsViaVector_initHadronicCurrent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2TwoMesonsViaVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETau2TwoMesonsViaVector_initHadronicCurrent" "', argument " "1"" of type '" "Pythia8::HMETau2TwoMesonsViaVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2TwoMesonsViaVector * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HMETau2TwoMesonsViaVector_initHadronicCurrent" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HMETau2TwoMesonsViaVector_initHadronicCurrent" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp2);
  (arg1)->initHadronicCurrent(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HMETau2TwoMesonsViaVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2TwoMesonsViaVector *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HMETau2TwoMesonsViaVector")) SWIG_fail;
  result = (Pythia8::HMETau2TwoMesonsViaVector *)new Pythia8::HMETau2TwoMesonsViaVector();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HMETau2TwoMesonsViaVector, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HMETau2TwoMesonsViaVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2TwoMesonsViaVector *arg1 = (Pythia8::HMETau2TwoMesonsViaVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HMETau2TwoMesonsViaVector",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2TwoMesonsViaVector, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HMETau2TwoMesonsViaVector" "', argument " "1"" of type '" "Pythia8::HMETau2TwoMesonsViaVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2TwoMesonsViaVector * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HMETau2TwoMesonsViaVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HMETau2TwoMesonsViaVector, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_HMETau2TwoMesonsViaVectorScalar_initConstants(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2TwoMesonsViaVectorScalar *arg1 = (Pythia8::HMETau2TwoMesonsViaVectorScalar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HMETau2TwoMesonsViaVectorScalar_initConstants",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2TwoMesonsViaVectorScalar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETau2TwoMesonsViaVectorScalar_initConstants" "', argument " "1"" of type '" "Pythia8::HMETau2TwoMesonsViaVectorScalar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2TwoMesonsViaVectorScalar * >(argp1);
  (arg1)->initConstants();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HMETau2TwoMesonsViaVectorScalar_initHadronicCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2TwoMesonsViaVectorScalar *arg1 = (Pythia8::HMETau2TwoMesonsViaVectorScalar *) 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMETau2TwoMesonsViaVectorScalar_initHadronicCurrent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2TwoMesonsViaVectorScalar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETau2TwoMesonsViaVectorScalar_initHadronicCurrent" "', argument " "1"" of type '" "Pythia8::HMETau2TwoMesonsViaVectorScalar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2TwoMesonsViaVectorScalar * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HMETau2TwoMesonsViaVectorScalar_initHadronicCurrent" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HMETau2TwoMesonsViaVectorScalar_initHadronicCurrent" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp2);
  (arg1)->initHadronicCurrent(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HMETau2TwoMesonsViaVectorScalar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2TwoMesonsViaVectorScalar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HMETau2TwoMesonsViaVectorScalar")) SWIG_fail;
  result = (Pythia8::HMETau2TwoMesonsViaVectorScalar *)new Pythia8::HMETau2TwoMesonsViaVectorScalar();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HMETau2TwoMesonsViaVectorScalar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HMETau2TwoMesonsViaVectorScalar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2TwoMesonsViaVectorScalar *arg1 = (Pythia8::HMETau2TwoMesonsViaVectorScalar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HMETau2TwoMesonsViaVectorScalar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2TwoMesonsViaVectorScalar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HMETau2TwoMesonsViaVectorScalar" "', argument " "1"" of type '" "Pythia8::HMETau2TwoMesonsViaVectorScalar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2TwoMesonsViaVectorScalar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HMETau2TwoMesonsViaVectorScalar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HMETau2TwoMesonsViaVectorScalar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_HMETau2ThreeMesons_initConstants(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2ThreeMesons *arg1 = (Pythia8::HMETau2ThreeMesons *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HMETau2ThreeMesons_initConstants",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2ThreeMesons, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETau2ThreeMesons_initConstants" "', argument " "1"" of type '" "Pythia8::HMETau2ThreeMesons *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2ThreeMesons * >(argp1);
  (arg1)->initConstants();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HMETau2ThreeMesons_initHadronicCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2ThreeMesons *arg1 = (Pythia8::HMETau2ThreeMesons *) 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMETau2ThreeMesons_initHadronicCurrent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2ThreeMesons, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETau2ThreeMesons_initHadronicCurrent" "', argument " "1"" of type '" "Pythia8::HMETau2ThreeMesons *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2ThreeMesons * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HMETau2ThreeMesons_initHadronicCurrent" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HMETau2ThreeMesons_initHadronicCurrent" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp2);
  (arg1)->initHadronicCurrent(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HMETau2ThreeMesons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2ThreeMesons *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HMETau2ThreeMesons")) SWIG_fail;
  result = (Pythia8::HMETau2ThreeMesons *)new Pythia8::HMETau2ThreeMesons();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HMETau2ThreeMesons, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HMETau2ThreeMesons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2ThreeMesons *arg1 = (Pythia8::HMETau2ThreeMesons *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HMETau2ThreeMesons",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2ThreeMesons, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HMETau2ThreeMesons" "', argument " "1"" of type '" "Pythia8::HMETau2ThreeMesons *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2ThreeMesons * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HMETau2ThreeMesons_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HMETau2ThreeMesons, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_HMETau2ThreePions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2ThreePions *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HMETau2ThreePions")) SWIG_fail;
  result = (Pythia8::HMETau2ThreePions *)new Pythia8::HMETau2ThreePions();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HMETau2ThreePions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HMETau2ThreePions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2ThreePions *arg1 = (Pythia8::HMETau2ThreePions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HMETau2ThreePions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2ThreePions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HMETau2ThreePions" "', argument " "1"" of type '" "Pythia8::HMETau2ThreePions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2ThreePions * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HMETau2ThreePions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HMETau2ThreePions, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_HMETau2ThreeMesonsWithKaons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2ThreeMesonsWithKaons *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HMETau2ThreeMesonsWithKaons")) SWIG_fail;
  result = (Pythia8::HMETau2ThreeMesonsWithKaons *)new Pythia8::HMETau2ThreeMesonsWithKaons();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HMETau2ThreeMesonsWithKaons, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HMETau2ThreeMesonsWithKaons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2ThreeMesonsWithKaons *arg1 = (Pythia8::HMETau2ThreeMesonsWithKaons *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HMETau2ThreeMesonsWithKaons",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2ThreeMesonsWithKaons, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HMETau2ThreeMesonsWithKaons" "', argument " "1"" of type '" "Pythia8::HMETau2ThreeMesonsWithKaons *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2ThreeMesonsWithKaons * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HMETau2ThreeMesonsWithKaons_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HMETau2ThreeMesonsWithKaons, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_HMETau2ThreeMesonsGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2ThreeMesonsGeneric *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HMETau2ThreeMesonsGeneric")) SWIG_fail;
  result = (Pythia8::HMETau2ThreeMesonsGeneric *)new Pythia8::HMETau2ThreeMesonsGeneric();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HMETau2ThreeMesonsGeneric, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HMETau2ThreeMesonsGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2ThreeMesonsGeneric *arg1 = (Pythia8::HMETau2ThreeMesonsGeneric *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HMETau2ThreeMesonsGeneric",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2ThreeMesonsGeneric, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HMETau2ThreeMesonsGeneric" "', argument " "1"" of type '" "Pythia8::HMETau2ThreeMesonsGeneric *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2ThreeMesonsGeneric * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HMETau2ThreeMesonsGeneric_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HMETau2ThreeMesonsGeneric, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_HMETau2TwoPionsGamma_initConstants(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2TwoPionsGamma *arg1 = (Pythia8::HMETau2TwoPionsGamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HMETau2TwoPionsGamma_initConstants",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2TwoPionsGamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETau2TwoPionsGamma_initConstants" "', argument " "1"" of type '" "Pythia8::HMETau2TwoPionsGamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2TwoPionsGamma * >(argp1);
  (arg1)->initConstants();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HMETau2TwoPionsGamma_initWaves(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2TwoPionsGamma *arg1 = (Pythia8::HMETau2TwoPionsGamma *) 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMETau2TwoPionsGamma_initWaves",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2TwoPionsGamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETau2TwoPionsGamma_initWaves" "', argument " "1"" of type '" "Pythia8::HMETau2TwoPionsGamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2TwoPionsGamma * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HMETau2TwoPionsGamma_initWaves" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HMETau2TwoPionsGamma_initWaves" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp2);
  (arg1)->initWaves(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HMETau2TwoPionsGamma_calculateME(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2TwoPionsGamma *arg1 = (Pythia8::HMETau2TwoPionsGamma *) 0 ;
  std::vector< int,std::allocator< int > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::complex result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMETau2TwoPionsGamma_calculateME",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2TwoPionsGamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETau2TwoPionsGamma_calculateME" "', argument " "1"" of type '" "Pythia8::HMETau2TwoPionsGamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2TwoPionsGamma * >(argp1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HMETau2TwoPionsGamma_calculateME" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->calculateME(arg2);
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HMETau2TwoPionsGamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2TwoPionsGamma *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HMETau2TwoPionsGamma")) SWIG_fail;
  result = (Pythia8::HMETau2TwoPionsGamma *)new Pythia8::HMETau2TwoPionsGamma();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HMETau2TwoPionsGamma, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HMETau2TwoPionsGamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2TwoPionsGamma *arg1 = (Pythia8::HMETau2TwoPionsGamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HMETau2TwoPionsGamma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2TwoPionsGamma, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HMETau2TwoPionsGamma" "', argument " "1"" of type '" "Pythia8::HMETau2TwoPionsGamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2TwoPionsGamma * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HMETau2TwoPionsGamma_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HMETau2TwoPionsGamma, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_HMETau2FourPions_initConstants(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2FourPions *arg1 = (Pythia8::HMETau2FourPions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HMETau2FourPions_initConstants",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2FourPions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETau2FourPions_initConstants" "', argument " "1"" of type '" "Pythia8::HMETau2FourPions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2FourPions * >(argp1);
  (arg1)->initConstants();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HMETau2FourPions_initHadronicCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2FourPions *arg1 = (Pythia8::HMETau2FourPions *) 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMETau2FourPions_initHadronicCurrent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2FourPions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETau2FourPions_initHadronicCurrent" "', argument " "1"" of type '" "Pythia8::HMETau2FourPions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2FourPions * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HMETau2FourPions_initHadronicCurrent" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HMETau2FourPions_initHadronicCurrent" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp2);
  (arg1)->initHadronicCurrent(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HMETau2FourPions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2FourPions *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HMETau2FourPions")) SWIG_fail;
  result = (Pythia8::HMETau2FourPions *)new Pythia8::HMETau2FourPions();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HMETau2FourPions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HMETau2FourPions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2FourPions *arg1 = (Pythia8::HMETau2FourPions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HMETau2FourPions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2FourPions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HMETau2FourPions" "', argument " "1"" of type '" "Pythia8::HMETau2FourPions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2FourPions * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HMETau2FourPions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HMETau2FourPions, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_HMETau2FivePions_initConstants(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2FivePions *arg1 = (Pythia8::HMETau2FivePions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HMETau2FivePions_initConstants",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2FivePions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETau2FivePions_initConstants" "', argument " "1"" of type '" "Pythia8::HMETau2FivePions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2FivePions * >(argp1);
  (arg1)->initConstants();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HMETau2FivePions_initHadronicCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2FivePions *arg1 = (Pythia8::HMETau2FivePions *) 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMETau2FivePions_initHadronicCurrent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2FivePions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETau2FivePions_initHadronicCurrent" "', argument " "1"" of type '" "Pythia8::HMETau2FivePions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2FivePions * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HMETau2FivePions_initHadronicCurrent" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HMETau2FivePions_initHadronicCurrent" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp2);
  (arg1)->initHadronicCurrent(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HMETau2FivePions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2FivePions *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HMETau2FivePions")) SWIG_fail;
  result = (Pythia8::HMETau2FivePions *)new Pythia8::HMETau2FivePions();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HMETau2FivePions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HMETau2FivePions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2FivePions *arg1 = (Pythia8::HMETau2FivePions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HMETau2FivePions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2FivePions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HMETau2FivePions" "', argument " "1"" of type '" "Pythia8::HMETau2FivePions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2FivePions * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HMETau2FivePions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HMETau2FivePions, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_HMETau2PhaseSpace_initWaves(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2PhaseSpace *arg1 = (Pythia8::HMETau2PhaseSpace *) 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMETau2PhaseSpace_initWaves",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETau2PhaseSpace_initWaves" "', argument " "1"" of type '" "Pythia8::HMETau2PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HMETau2PhaseSpace_initWaves" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HMETau2PhaseSpace_initWaves" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp2);
  (arg1)->initWaves(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HMETau2PhaseSpace_calculateME(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2PhaseSpace *arg1 = (Pythia8::HMETau2PhaseSpace *) 0 ;
  std::vector< int,std::allocator< int > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::complex result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMETau2PhaseSpace_calculateME",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETau2PhaseSpace_calculateME" "', argument " "1"" of type '" "Pythia8::HMETau2PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2PhaseSpace * >(argp1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HMETau2PhaseSpace_calculateME" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->calculateME(arg2);
  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HMETau2PhaseSpace_calculateD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2PhaseSpace *arg1 = (Pythia8::HMETau2PhaseSpace *) 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMETau2PhaseSpace_calculateD",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETau2PhaseSpace_calculateD" "', argument " "1"" of type '" "Pythia8::HMETau2PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HMETau2PhaseSpace_calculateD" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HMETau2PhaseSpace_calculateD" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp2);
  (arg1)->calculateD(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HMETau2PhaseSpace_calculateRho(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2PhaseSpace *arg1 = (Pythia8::HMETau2PhaseSpace *) 0 ;
  unsigned int arg2 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:HMETau2PhaseSpace_calculateRho",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETau2PhaseSpace_calculateRho" "', argument " "1"" of type '" "Pythia8::HMETau2PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HMETau2PhaseSpace_calculateRho" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HMETau2PhaseSpace_calculateRho" "', argument " "3"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HMETau2PhaseSpace_calculateRho" "', argument " "3"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp3);
  (arg1)->calculateRho(arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HMETau2PhaseSpace_decayWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2PhaseSpace *arg1 = (Pythia8::HMETau2PhaseSpace *) 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMETau2PhaseSpace_decayWeight",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETau2PhaseSpace_decayWeight" "', argument " "1"" of type '" "Pythia8::HMETau2PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HMETau2PhaseSpace_decayWeight" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HMETau2PhaseSpace_decayWeight" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp2);
  result = (double)(arg1)->decayWeight(*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HMETau2PhaseSpace_decayWeightMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2PhaseSpace *arg1 = (Pythia8::HMETau2PhaseSpace *) 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HMETau2PhaseSpace_decayWeightMax",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HMETau2PhaseSpace_decayWeightMax" "', argument " "1"" of type '" "Pythia8::HMETau2PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HMETau2PhaseSpace_decayWeightMax" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HMETau2PhaseSpace_decayWeightMax" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp2);
  result = (double)(arg1)->decayWeightMax(*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HMETau2PhaseSpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2PhaseSpace *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HMETau2PhaseSpace")) SWIG_fail;
  result = (Pythia8::HMETau2PhaseSpace *)new Pythia8::HMETau2PhaseSpace();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HMETau2PhaseSpace, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HMETau2PhaseSpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HMETau2PhaseSpace *arg1 = (Pythia8::HMETau2PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HMETau2PhaseSpace",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HMETau2PhaseSpace, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HMETau2PhaseSpace" "', argument " "1"" of type '" "Pythia8::HMETau2PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HMETau2PhaseSpace * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HMETau2PhaseSpace_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HMETau2PhaseSpace, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LHAProcess__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAProcess *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LHAProcess")) SWIG_fail;
  result = (Pythia8::LHAProcess *)new Pythia8::LHAProcess();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAProcess, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAProcess__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::LHAProcess *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_LHAProcess",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LHAProcess" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LHAProcess" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LHAProcess" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LHAProcess" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (Pythia8::LHAProcess *)new Pythia8::LHAProcess(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAProcess, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAProcess(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_LHAProcess__SWIG_0(self, args);
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_LHAProcess__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LHAProcess'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAProcess::LHAProcess()\n"
    "    Pythia8::LHAProcess::LHAProcess(int,double,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAProcess_idProc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAProcess *arg1 = (Pythia8::LHAProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAProcess_idProc_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAProcess_idProc_set" "', argument " "1"" of type '" "Pythia8::LHAProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAProcess_idProc_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->idProc = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAProcess_idProc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAProcess *arg1 = (Pythia8::LHAProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAProcess_idProc_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAProcess_idProc_get" "', argument " "1"" of type '" "Pythia8::LHAProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAProcess * >(argp1);
  result = (int) ((arg1)->idProc);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAProcess_xSecProc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAProcess *arg1 = (Pythia8::LHAProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAProcess_xSecProc_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAProcess_xSecProc_set" "', argument " "1"" of type '" "Pythia8::LHAProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAProcess_xSecProc_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->xSecProc = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAProcess_xSecProc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAProcess *arg1 = (Pythia8::LHAProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAProcess_xSecProc_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAProcess_xSecProc_get" "', argument " "1"" of type '" "Pythia8::LHAProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAProcess * >(argp1);
  result = (double) ((arg1)->xSecProc);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAProcess_xErrProc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAProcess *arg1 = (Pythia8::LHAProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAProcess_xErrProc_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAProcess_xErrProc_set" "', argument " "1"" of type '" "Pythia8::LHAProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAProcess_xErrProc_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->xErrProc = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAProcess_xErrProc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAProcess *arg1 = (Pythia8::LHAProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAProcess_xErrProc_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAProcess_xErrProc_get" "', argument " "1"" of type '" "Pythia8::LHAProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAProcess * >(argp1);
  result = (double) ((arg1)->xErrProc);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAProcess_xMaxProc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAProcess *arg1 = (Pythia8::LHAProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAProcess_xMaxProc_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAProcess_xMaxProc_set" "', argument " "1"" of type '" "Pythia8::LHAProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAProcess_xMaxProc_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->xMaxProc = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAProcess_xMaxProc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAProcess *arg1 = (Pythia8::LHAProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAProcess_xMaxProc_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAProcess_xMaxProc_get" "', argument " "1"" of type '" "Pythia8::LHAProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAProcess * >(argp1);
  result = (double) ((arg1)->xMaxProc);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LHAProcess(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAProcess *arg1 = (Pythia8::LHAProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LHAProcess",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAProcess, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LHAProcess" "', argument " "1"" of type '" "Pythia8::LHAProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAProcess * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LHAProcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__LHAProcess, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LHAParticle__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_LHAParticle")) SWIG_fail;
  result = (Pythia8::LHAParticle *)new Pythia8::LHAParticle();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAParticle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  Pythia8::LHAParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:new_LHAParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LHAParticle" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LHAParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LHAParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LHAParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_LHAParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_LHAParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_LHAParticle" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_LHAParticle" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_LHAParticle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_LHAParticle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_LHAParticle" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_LHAParticle" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_LHAParticle" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_LHAParticle" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  result = (Pythia8::LHAParticle *)new Pythia8::LHAParticle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAParticle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[15] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 14) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_LHAParticle__SWIG_0(self, args);
  }
  if (argc == 14) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_LHAParticle__SWIG_1(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LHAParticle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAParticle::LHAParticle()\n"
    "    Pythia8::LHAParticle::LHAParticle(int,int,int,int,int,int,double,double,double,double,double,double,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAParticle_idPart_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAParticle_idPart_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_idPart_set" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAParticle_idPart_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->idPart = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_idPart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAParticle_idPart_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_idPart_get" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  result = (int) ((arg1)->idPart);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_statusPart_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAParticle_statusPart_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_statusPart_set" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAParticle_statusPart_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->statusPart = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_statusPart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAParticle_statusPart_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_statusPart_get" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  result = (int) ((arg1)->statusPart);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_mother1Part_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAParticle_mother1Part_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_mother1Part_set" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAParticle_mother1Part_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->mother1Part = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_mother1Part_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAParticle_mother1Part_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_mother1Part_get" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  result = (int) ((arg1)->mother1Part);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_mother2Part_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAParticle_mother2Part_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_mother2Part_set" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAParticle_mother2Part_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->mother2Part = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_mother2Part_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAParticle_mother2Part_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_mother2Part_get" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  result = (int) ((arg1)->mother2Part);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_col1Part_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAParticle_col1Part_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_col1Part_set" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAParticle_col1Part_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->col1Part = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_col1Part_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAParticle_col1Part_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_col1Part_get" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  result = (int) ((arg1)->col1Part);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_col2Part_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAParticle_col2Part_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_col2Part_set" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAParticle_col2Part_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->col2Part = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_col2Part_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAParticle_col2Part_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_col2Part_get" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  result = (int) ((arg1)->col2Part);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_pxPart_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAParticle_pxPart_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_pxPart_set" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAParticle_pxPart_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pxPart = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_pxPart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAParticle_pxPart_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_pxPart_get" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  result = (double) ((arg1)->pxPart);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_pyPart_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAParticle_pyPart_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_pyPart_set" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAParticle_pyPart_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pyPart = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_pyPart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAParticle_pyPart_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_pyPart_get" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  result = (double) ((arg1)->pyPart);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_pzPart_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAParticle_pzPart_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_pzPart_set" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAParticle_pzPart_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pzPart = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_pzPart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAParticle_pzPart_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_pzPart_get" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  result = (double) ((arg1)->pzPart);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_ePart_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAParticle_ePart_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_ePart_set" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAParticle_ePart_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->ePart = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_ePart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAParticle_ePart_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_ePart_get" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  result = (double) ((arg1)->ePart);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_mPart_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAParticle_mPart_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_mPart_set" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAParticle_mPart_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->mPart = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_mPart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAParticle_mPart_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_mPart_get" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  result = (double) ((arg1)->mPart);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_tauPart_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAParticle_tauPart_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_tauPart_set" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAParticle_tauPart_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->tauPart = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_tauPart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAParticle_tauPart_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_tauPart_get" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  result = (double) ((arg1)->tauPart);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_spinPart_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAParticle_spinPart_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_spinPart_set" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAParticle_spinPart_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->spinPart = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_spinPart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAParticle_spinPart_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_spinPart_get" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  result = (double) ((arg1)->spinPart);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_scalePart_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAParticle_scalePart_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_scalePart_set" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAParticle_scalePart_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->scalePart = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAParticle_scalePart_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAParticle_scalePart_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAParticle_scalePart_get" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  result = (double) ((arg1)->scalePart);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LHAParticle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAParticle *arg1 = (Pythia8::LHAParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LHAParticle",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAParticle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LHAParticle" "', argument " "1"" of type '" "Pythia8::LHAParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAParticle * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LHAParticle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__LHAParticle, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_LHAup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LHAup",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LHAup" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_setPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setPtr" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAup_setPtr" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  (arg1)->setPtr(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_newEventFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_newEventFile",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_newEventFile" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAup_newEventFile" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::LHAup::newEventFile((char const *)arg2);
    } else {
      (arg1)->newEventFile((char const *)arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_fileFound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_fileFound",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_fileFound" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::LHAup::fileFound();
    } else {
      result = (bool)(arg1)->fileFound();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_useExternal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_useExternal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_useExternal" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::LHAup::useExternal();
    } else {
      result = (bool)(arg1)->useExternal();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setInit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_setInit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setInit" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("Pythia8::LHAup::setInit");
    } else {
      result = (bool)(arg1)->setInit();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_idBeamA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_idBeamA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_idBeamA" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (int)((Pythia8::LHAup const *)arg1)->idBeamA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_idBeamB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_idBeamB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_idBeamB" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (int)((Pythia8::LHAup const *)arg1)->idBeamB();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_eBeamA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_eBeamA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_eBeamA" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (double)((Pythia8::LHAup const *)arg1)->eBeamA();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_eBeamB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_eBeamB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_eBeamB" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (double)((Pythia8::LHAup const *)arg1)->eBeamB();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_pdfGroupBeamA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_pdfGroupBeamA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_pdfGroupBeamA" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (int)((Pythia8::LHAup const *)arg1)->pdfGroupBeamA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_pdfGroupBeamB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_pdfGroupBeamB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_pdfGroupBeamB" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (int)((Pythia8::LHAup const *)arg1)->pdfGroupBeamB();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_pdfSetBeamA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_pdfSetBeamA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_pdfSetBeamA" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (int)((Pythia8::LHAup const *)arg1)->pdfSetBeamA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_pdfSetBeamB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_pdfSetBeamB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_pdfSetBeamB" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (int)((Pythia8::LHAup const *)arg1)->pdfSetBeamB();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_strategy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_strategy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_strategy" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (int)((Pythia8::LHAup const *)arg1)->strategy();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_sizeProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_sizeProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_sizeProc" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (int)((Pythia8::LHAup const *)arg1)->sizeProc();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_idProcess__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_idProcess",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_idProcess" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_idProcess" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::LHAup const *)arg1)->idProcess(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_xSec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_xSec",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_xSec" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_xSec" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::LHAup const *)arg1)->xSec(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_xErr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_xErr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_xErr" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_xErr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::LHAup const *)arg1)->xErr(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_xMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_xMax",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_xMax" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_xMax" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::LHAup const *)arg1)->xMax(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_xSecSum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_xSecSum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_xSecSum" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (double)((Pythia8::LHAup const *)arg1)->xSecSum();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_xErrSum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_xErrSum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_xErrSum" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (double)((Pythia8::LHAup const *)arg1)->xErrSum();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_listInit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_listInit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_listInit" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  (arg1)->listInit();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setEvent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_setEvent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setEvent" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_setEvent" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("Pythia8::LHAup::setEvent");
    } else {
      result = (bool)(arg1)->setEvent(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setEvent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_setEvent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setEvent" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("Pythia8::LHAup::setEvent");
    } else {
      result = (bool)(arg1)->setEvent();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setEvent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LHAup_setEvent__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LHAup_setEvent__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LHAup_setEvent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAup::setEvent(int)\n"
    "    Pythia8::LHAup::setEvent()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAup_idProcess__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_idProcess",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_idProcess" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (int)((Pythia8::LHAup const *)arg1)->idProcess();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_idProcess(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LHAup_idProcess__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LHAup_idProcess__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LHAup_idProcess'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAup::idProcess(int) const\n"
    "    Pythia8::LHAup::idProcess() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAup_weight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_weight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_weight" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (double)((Pythia8::LHAup const *)arg1)->weight();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_scale",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_scale" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (double)((Pythia8::LHAup const *)arg1)->scale();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_alphaQED(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_alphaQED",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_alphaQED" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (double)((Pythia8::LHAup const *)arg1)->alphaQED();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_alphaQCD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_alphaQCD",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_alphaQCD" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (double)((Pythia8::LHAup const *)arg1)->alphaQCD();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_sizePart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_sizePart",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_sizePart" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (int)((Pythia8::LHAup const *)arg1)->sizePart();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_id",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_id" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_id" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::LHAup const *)arg1)->id(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_status(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_status",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_status" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_status" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::LHAup const *)arg1)->status(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_mother1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_mother1",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_mother1" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_mother1" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::LHAup const *)arg1)->mother1(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_mother2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_mother2",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_mother2" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_mother2" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::LHAup const *)arg1)->mother2(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_col1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_col1",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_col1" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_col1" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::LHAup const *)arg1)->col1(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_col2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_col2",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_col2" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_col2" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::LHAup const *)arg1)->col2(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_px(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_px",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_px" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_px" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::LHAup const *)arg1)->px(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_py(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_py",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_py" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_py" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::LHAup const *)arg1)->py(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_pz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_pz",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_pz" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_pz" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::LHAup const *)arg1)->pz(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_e(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_e",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_e" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_e" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::LHAup const *)arg1)->e(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_m(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_m",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_m" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_m" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::LHAup const *)arg1)->m(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_tau(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_tau",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_tau" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_tau" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::LHAup const *)arg1)->tau(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_spin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_spin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_spin" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_spin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::LHAup const *)arg1)->spin(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_scale",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_scale" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_scale" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::LHAup const *)arg1)->scale(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_scale(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LHAup_scale__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LHAup_scale__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LHAup_scale'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAup::scale() const\n"
    "    Pythia8::LHAup::scale(int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAup_id1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_id1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_id1" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (int)((Pythia8::LHAup const *)arg1)->id1();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_id2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_id2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_id2" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (int)((Pythia8::LHAup const *)arg1)->id2();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_x1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_x1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_x1" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (double)((Pythia8::LHAup const *)arg1)->x1();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_x2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_x2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_x2" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (double)((Pythia8::LHAup const *)arg1)->x2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_pdfIsSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_pdfIsSet",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_pdfIsSet" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (bool)((Pythia8::LHAup const *)arg1)->pdfIsSet();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_id1pdf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_id1pdf",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_id1pdf" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (int)((Pythia8::LHAup const *)arg1)->id1pdf();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_id2pdf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_id2pdf",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_id2pdf" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (int)((Pythia8::LHAup const *)arg1)->id2pdf();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_x1pdf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_x1pdf",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_x1pdf" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (double)((Pythia8::LHAup const *)arg1)->x1pdf();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_x2pdf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_x2pdf",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_x2pdf" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (double)((Pythia8::LHAup const *)arg1)->x2pdf();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_scalePDF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_scalePDF",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_scalePDF" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (double)((Pythia8::LHAup const *)arg1)->scalePDF();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_pdf1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_pdf1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_pdf1" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (double)((Pythia8::LHAup const *)arg1)->pdf1();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_pdf2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_pdf2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_pdf2" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (double)((Pythia8::LHAup const *)arg1)->pdf2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_listEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_listEvent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_listEvent" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  (arg1)->listEvent();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_skipEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_skipEvent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_skipEvent" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_skipEvent" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::LHAup::skipEvent(arg2);
    } else {
      result = (bool)(arg1)->skipEvent(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_openLHEF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_openLHEF",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_openLHEF" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LHAup_openLHEF" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::LHAup::openLHEF(arg2);
    } else {
      result = (bool)(arg1)->openLHEF(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_closeLHEF__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_closeLHEF",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_closeLHEF" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_closeLHEF" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::LHAup::closeLHEF(arg2);
    } else {
      result = (bool)(arg1)->closeLHEF(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_closeLHEF__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_closeLHEF",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_closeLHEF" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::LHAup::closeLHEF();
    } else {
      result = (bool)(arg1)->closeLHEF();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_closeLHEF(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LHAup_closeLHEF__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LHAup_closeLHEF__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LHAup_closeLHEF'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAup::closeLHEF(bool)\n"
    "    Pythia8::LHAup::closeLHEF()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAup_initLHEF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_initLHEF",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_initLHEF" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (bool)(arg1)->initLHEF();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_eventLHEF__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_eventLHEF",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_eventLHEF" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_eventLHEF" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)(arg1)->eventLHEF(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_eventLHEF__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_eventLHEF",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_eventLHEF" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = (bool)(arg1)->eventLHEF();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_eventLHEF(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LHAup_eventLHEF__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LHAup_eventLHEF__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LHAup_eventLHEF'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAup::eventLHEF(bool)\n"
    "    Pythia8::LHAup::eventLHEF()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAup_getFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_getFileName",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_getFileName" "', argument " "1"" of type '" "Pythia8::LHAup const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  result = ((Pythia8::LHAup const *)arg1)->getFileName();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAup__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  int arg2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::LHAup *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_LHAup",&obj0,&obj1)) SWIG_fail;
  arg1 = obj0;
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LHAup" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (Pythia8::LHAup *)new SwigDirector_LHAup(arg1,arg2); 
  } else {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
    SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAup, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAup__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHAup *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LHAup",&obj0)) SWIG_fail;
  arg1 = obj0;
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (Pythia8::LHAup *)new SwigDirector_LHAup(arg1); 
  } else {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
    SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAup, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAup(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    _v = (argv[0] != 0);
    if (_v) {
      return _wrap_new_LHAup__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    _v = (argv[0] != 0);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_LHAup__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LHAup'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAup::LHAup(int)\n"
    "    Pythia8::LHAup::LHAup(PyObject *)\n");
  return 0;
}


SWIGINTERN int Swig_var_LHAup_CONVERTMB2PB_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable LHAup_CONVERTMB2PB is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_LHAup_CONVERTMB2PB_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(SwigDirector_LHAup::CONVERTMB2PB));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_LHAup_infoPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_infoPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_infoPtr_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAup_infoPtr_set" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg1) darg->infoPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_infoPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  Pythia8::Info *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_infoPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_infoPtr_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (Pythia8::Info *) (darg->infoPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setBeamA__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:LHAup_setBeamA",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setBeamA" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_setBeamA" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_setBeamA" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAup_setBeamA" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "LHAup_setBeamA" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->setBeamA(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setBeamA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:LHAup_setBeamA",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setBeamA" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_setBeamA" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_setBeamA" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAup_setBeamA" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->setBeamA(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setBeamA__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:LHAup_setBeamA",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setBeamA" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_setBeamA" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_setBeamA" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->setBeamA(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setBeamA(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LHAup_setBeamA__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_LHAup_setBeamA__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_LHAup_setBeamA__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LHAup_setBeamA'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAup::setBeamA(int,double,int,int)\n"
    "    Pythia8::LHAup::setBeamA(int,double,int)\n"
    "    Pythia8::LHAup::setBeamA(int,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAup_setBeamB__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:LHAup_setBeamB",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setBeamB" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_setBeamB" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_setBeamB" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAup_setBeamB" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "LHAup_setBeamB" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->setBeamB(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setBeamB__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:LHAup_setBeamB",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setBeamB" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_setBeamB" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_setBeamB" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAup_setBeamB" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->setBeamB(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setBeamB__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:LHAup_setBeamB",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setBeamB" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_setBeamB" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_setBeamB" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->setBeamB(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setBeamB(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LHAup_setBeamB__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_LHAup_setBeamB__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_LHAup_setBeamB__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LHAup_setBeamB'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAup::setBeamB(int,double,int,int)\n"
    "    Pythia8::LHAup::setBeamB(int,double,int)\n"
    "    Pythia8::LHAup::setBeamB(int,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAup_setStrategy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_setStrategy",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setStrategy" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_setStrategy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->setStrategy(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_addProcess__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:LHAup_addProcess",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_addProcess" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_addProcess" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_addProcess" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAup_addProcess" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "LHAup_addProcess" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->addProcess(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_addProcess__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:LHAup_addProcess",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_addProcess" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_addProcess" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_addProcess" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAup_addProcess" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->addProcess(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_addProcess__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:LHAup_addProcess",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_addProcess" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_addProcess" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_addProcess" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->addProcess(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_addProcess__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_addProcess",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_addProcess" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_addProcess" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->addProcess(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_addProcess(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LHAup_addProcess__SWIG_3(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LHAup_addProcess__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_LHAup_addProcess__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_LHAup_addProcess__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LHAup_addProcess'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAup::addProcess(int,double,double,double)\n"
    "    Pythia8::LHAup::addProcess(int,double,double)\n"
    "    Pythia8::LHAup::addProcess(int,double)\n"
    "    Pythia8::LHAup::addProcess(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAup_setXSec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:LHAup_setXSec",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setXSec" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_setXSec" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_setXSec" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->setXSec(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setXErr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:LHAup_setXErr",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setXErr" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_setXErr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_setXErr" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->setXErr(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:LHAup_setXMax",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setXMax" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_setXMax" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_setXMax" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->setXMax(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setProcess__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:LHAup_setProcess",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setProcess" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_setProcess" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_setProcess" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAup_setProcess" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "LHAup_setProcess" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "LHAup_setProcess" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->setProcess(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setProcess__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:LHAup_setProcess",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setProcess" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_setProcess" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_setProcess" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAup_setProcess" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "LHAup_setProcess" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->setProcess(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setProcess__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:LHAup_setProcess",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setProcess" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_setProcess" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_setProcess" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAup_setProcess" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->setProcess(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setProcess__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:LHAup_setProcess",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setProcess" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_setProcess" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_setProcess" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->setProcess(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setProcess__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_setProcess",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setProcess" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_setProcess" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->setProcess(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setProcess__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_setProcess",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setProcess" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->setProcess();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setProcess(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LHAup_setProcess__SWIG_5(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LHAup_setProcess__SWIG_4(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LHAup_setProcess__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_LHAup_setProcess__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_LHAup_setProcess__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_LHAup_setProcess__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LHAup_setProcess'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAup::setProcess(int,double,double,double,double)\n"
    "    Pythia8::LHAup::setProcess(int,double,double,double)\n"
    "    Pythia8::LHAup::setProcess(int,double,double)\n"
    "    Pythia8::LHAup::setProcess(int,double)\n"
    "    Pythia8::LHAup::setProcess(int)\n"
    "    Pythia8::LHAup::setProcess()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAup_addParticle__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  Pythia8::LHAParticle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_addParticle",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_addParticle" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__LHAParticle,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAup_addParticle" "', argument " "2"" of type '" "Pythia8::LHAParticle""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LHAup_addParticle" "', argument " "2"" of type '" "Pythia8::LHAParticle""'");
    } else {
      Pythia8::LHAParticle * temp = reinterpret_cast< Pythia8::LHAParticle * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->addParticle(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_addParticle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:LHAup_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_addParticle" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_addParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAup_addParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "LHAup_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "LHAup_addParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "LHAup_addParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "LHAup_addParticle" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "LHAup_addParticle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "LHAup_addParticle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "LHAup_addParticle" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "LHAup_addParticle" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "LHAup_addParticle" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "LHAup_addParticle" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_double(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "LHAup_addParticle" "', argument " "15"" of type '" "double""'");
  } 
  arg15 = static_cast< double >(val15);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->addParticle(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_addParticle__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:LHAup_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_addParticle" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_addParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAup_addParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "LHAup_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "LHAup_addParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "LHAup_addParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "LHAup_addParticle" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "LHAup_addParticle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "LHAup_addParticle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "LHAup_addParticle" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "LHAup_addParticle" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "LHAup_addParticle" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "LHAup_addParticle" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->addParticle(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_addParticle__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:LHAup_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_addParticle" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_addParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAup_addParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "LHAup_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "LHAup_addParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "LHAup_addParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "LHAup_addParticle" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "LHAup_addParticle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "LHAup_addParticle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "LHAup_addParticle" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "LHAup_addParticle" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "LHAup_addParticle" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->addParticle(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_addParticle__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:LHAup_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_addParticle" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_addParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAup_addParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "LHAup_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "LHAup_addParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "LHAup_addParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "LHAup_addParticle" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "LHAup_addParticle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "LHAup_addParticle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "LHAup_addParticle" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "LHAup_addParticle" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->addParticle(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_addParticle__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:LHAup_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_addParticle" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_addParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAup_addParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "LHAup_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "LHAup_addParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "LHAup_addParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "LHAup_addParticle" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "LHAup_addParticle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "LHAup_addParticle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "LHAup_addParticle" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->addParticle(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_addParticle__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:LHAup_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_addParticle" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_addParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAup_addParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "LHAup_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "LHAup_addParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "LHAup_addParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "LHAup_addParticle" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "LHAup_addParticle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "LHAup_addParticle" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->addParticle(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_addParticle__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  double arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:LHAup_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_addParticle" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_addParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAup_addParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "LHAup_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "LHAup_addParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "LHAup_addParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "LHAup_addParticle" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "LHAup_addParticle" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->addParticle(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_addParticle__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  double arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:LHAup_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_addParticle" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_addParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAup_addParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "LHAup_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "LHAup_addParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "LHAup_addParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "LHAup_addParticle" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->addParticle(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_addParticle__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:LHAup_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_addParticle" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_addParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAup_addParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "LHAup_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "LHAup_addParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "LHAup_addParticle" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->addParticle(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_addParticle__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:LHAup_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_addParticle" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_addParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAup_addParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "LHAup_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "LHAup_addParticle" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->addParticle(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_addParticle__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:LHAup_addParticle",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_addParticle" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_addParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAup_addParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "LHAup_addParticle" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->addParticle(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_addParticle__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:LHAup_addParticle",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_addParticle" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_addParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAup_addParticle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->addParticle(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_addParticle__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:LHAup_addParticle",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_addParticle" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_addParticle" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->addParticle(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_addParticle__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_addParticle",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_addParticle" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_addParticle" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->addParticle(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_addParticle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[16] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 15) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__LHAParticle, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_LHAup_addParticle__SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LHAup_addParticle__SWIG_14(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LHAup_addParticle__SWIG_13(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_LHAup_addParticle__SWIG_12(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_LHAup_addParticle__SWIG_11(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_LHAup_addParticle__SWIG_10(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_LHAup_addParticle__SWIG_9(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_LHAup_addParticle__SWIG_8(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_LHAup_addParticle__SWIG_7(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_LHAup_addParticle__SWIG_6(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_LHAup_addParticle__SWIG_5(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_LHAup_addParticle__SWIG_4(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_LHAup_addParticle__SWIG_3(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_LHAup_addParticle__SWIG_2(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_double(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_double(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_double(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_double(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_double(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_LHAup_addParticle__SWIG_1(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LHAup_addParticle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAup::addParticle(Pythia8::LHAParticle)\n"
    "    Pythia8::LHAup::addParticle(int,int,int,int,int,int,double,double,double,double,double,double,double,double)\n"
    "    Pythia8::LHAup::addParticle(int,int,int,int,int,int,double,double,double,double,double,double,double)\n"
    "    Pythia8::LHAup::addParticle(int,int,int,int,int,int,double,double,double,double,double,double)\n"
    "    Pythia8::LHAup::addParticle(int,int,int,int,int,int,double,double,double,double,double)\n"
    "    Pythia8::LHAup::addParticle(int,int,int,int,int,int,double,double,double,double)\n"
    "    Pythia8::LHAup::addParticle(int,int,int,int,int,int,double,double,double)\n"
    "    Pythia8::LHAup::addParticle(int,int,int,int,int,int,double,double)\n"
    "    Pythia8::LHAup::addParticle(int,int,int,int,int,int,double)\n"
    "    Pythia8::LHAup::addParticle(int,int,int,int,int,int)\n"
    "    Pythia8::LHAup::addParticle(int,int,int,int,int)\n"
    "    Pythia8::LHAup::addParticle(int,int,int,int)\n"
    "    Pythia8::LHAup::addParticle(int,int,int)\n"
    "    Pythia8::LHAup::addParticle(int,int)\n"
    "    Pythia8::LHAup::addParticle(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAup_setIdX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:LHAup_setIdX",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setIdX" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_setIdX" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_setIdX" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAup_setIdX" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "LHAup_setIdX" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->setIdX(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setPdf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  bool arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:LHAup_setPdf",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setPdf" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_setPdf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_setPdf" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LHAup_setPdf" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "LHAup_setPdf" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "LHAup_setPdf" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "LHAup_setPdf" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "LHAup_setPdf" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "LHAup_setPdf" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->setPdf(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setInitLHEF__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  std::istream *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigDirector_LHAup *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:LHAup_setInitLHEF",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setInitLHEF" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAup_setInitLHEF" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LHAup_setInitLHEF" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAup_setInitLHEF" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (bool)(darg)->setInitLHEF(*arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setInitLHEF__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  std::istream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_setInitLHEF",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setInitLHEF" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAup_setInitLHEF" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LHAup_setInitLHEF" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (bool)(darg)->setInitLHEF(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setInitLHEF(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_LHAup_setInitLHEF__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LHAup_setInitLHEF__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LHAup_setInitLHEF'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAup::setInitLHEF(std::istream &,bool)\n"
    "    Pythia8::LHAup::setInitLHEF(std::istream &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAup_setNewEventLHEF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  std::istream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_setNewEventLHEF",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setNewEventLHEF" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAup_setNewEventLHEF" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LHAup_setNewEventLHEF" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (bool)(darg)->setNewEventLHEF(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setOldEventLHEF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_setOldEventLHEF",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setOldEventLHEF" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (bool)(darg)->setOldEventLHEF();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_openFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  char *arg2 = (char *) 0 ;
  ifstream *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigDirector_LHAup *darg = 0;
  std::istream *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:LHAup_openFile",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_openFile" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAup_openFile" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_ifstream,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LHAup_openFile" "', argument " "3"" of type '" "ifstream &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LHAup_openFile" "', argument " "3"" of type '" "ifstream &""'"); 
  }
  arg3 = reinterpret_cast< ifstream * >(argp3);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (std::istream *)(darg)->openFile((char const *)arg2,*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_closeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  std::istream **arg2 = 0 ;
  ifstream *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:LHAup_closeFile",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_closeFile" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAup_closeFile" "', argument " "2"" of type '" "std::istream *&""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LHAup_closeFile" "', argument " "2"" of type '" "std::istream *&""'"); 
  }
  arg2 = reinterpret_cast< std::istream ** >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_ifstream,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LHAup_closeFile" "', argument " "3"" of type '" "ifstream &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LHAup_closeFile" "', argument " "3"" of type '" "ifstream &""'"); 
  }
  arg3 = reinterpret_cast< ifstream * >(argp3);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->closeFile(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_setInfoHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:LHAup_setInfoHeader",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_setInfoHeader" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAup_setInfoHeader" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LHAup_setInfoHeader" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LHAup_setInfoHeader" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LHAup_setInfoHeader" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  (darg)->setInfoHeader((std::string const &)*arg2,(std::string const &)*arg3);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_nupSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_nupSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_nupSave_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_nupSave_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg1) darg->nupSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_nupSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_nupSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_nupSave_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (int) (darg->nupSave);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_idprupSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_idprupSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_idprupSave_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_idprupSave_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg1) darg->idprupSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_idprupSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_idprupSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_idprupSave_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (int) (darg->idprupSave);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_xwgtupSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_xwgtupSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_xwgtupSave_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_xwgtupSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg1) darg->xwgtupSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_xwgtupSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_xwgtupSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_xwgtupSave_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (double) (darg->xwgtupSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_scalupSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_scalupSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_scalupSave_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_scalupSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg1) darg->scalupSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_scalupSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_scalupSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_scalupSave_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (double) (darg->scalupSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_aqedupSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_aqedupSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_aqedupSave_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_aqedupSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg1) darg->aqedupSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_aqedupSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_aqedupSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_aqedupSave_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (double) (darg->aqedupSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_aqcdupSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_aqcdupSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_aqcdupSave_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_aqcdupSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg1) darg->aqcdupSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_aqcdupSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_aqcdupSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_aqcdupSave_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (double) (darg->aqcdupSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_xSecSumSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_xSecSumSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_xSecSumSave_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_xSecSumSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg1) darg->xSecSumSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_xSecSumSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_xSecSumSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_xSecSumSave_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (double) (darg->xSecSumSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_xErrSumSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_xErrSumSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_xErrSumSave_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_xErrSumSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg1) darg->xErrSumSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_xErrSumSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_xErrSumSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_xErrSumSave_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (double) (darg->xErrSumSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_particlesSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  std::vector< Pythia8::LHAParticle,std::allocator< Pythia8::LHAParticle > > *arg2 = (std::vector< Pythia8::LHAParticle,std::allocator< Pythia8::LHAParticle > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_particlesSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_particlesSave_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_Pythia8__LHAParticle_std__allocatorT_Pythia8__LHAParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAup_particlesSave_set" "', argument " "2"" of type '" "std::vector< Pythia8::LHAParticle,std::allocator< Pythia8::LHAParticle > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::LHAParticle,std::allocator< Pythia8::LHAParticle > > * >(argp2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg1) darg->particlesSave = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_particlesSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  std::vector< Pythia8::LHAParticle,std::allocator< Pythia8::LHAParticle > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_particlesSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_particlesSave_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (std::vector< Pythia8::LHAParticle,std::allocator< Pythia8::LHAParticle > > *)& (darg->particlesSave);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__LHAParticle_std__allocatorT_Pythia8__LHAParticle_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_getPDFSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_getPDFSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_getPDFSave_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_getPDFSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg1) darg->getPDFSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_getPDFSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_getPDFSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_getPDFSave_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (bool) (darg->getPDFSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_getScale_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_getScale_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_getScale_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_getScale_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg1) darg->getScale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_getScale_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_getScale_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_getScale_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (bool) (darg->getScale);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_id1InSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_id1InSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_id1InSave_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_id1InSave_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg1) darg->id1InSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_id1InSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_id1InSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_id1InSave_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (int) (darg->id1InSave);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_id2InSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_id2InSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_id2InSave_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_id2InSave_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg1) darg->id2InSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_id2InSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_id2InSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_id2InSave_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (int) (darg->id2InSave);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_id1pdfInSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_id1pdfInSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_id1pdfInSave_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_id1pdfInSave_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg1) darg->id1pdfInSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_id1pdfInSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_id1pdfInSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_id1pdfInSave_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (int) (darg->id1pdfInSave);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_id2pdfInSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_id2pdfInSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_id2pdfInSave_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_id2pdfInSave_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg1) darg->id2pdfInSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_id2pdfInSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_id2pdfInSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_id2pdfInSave_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (int) (darg->id2pdfInSave);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_x1InSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_x1InSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_x1InSave_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_x1InSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg1) darg->x1InSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_x1InSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_x1InSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_x1InSave_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (double) (darg->x1InSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_x2InSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_x2InSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_x2InSave_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_x2InSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg1) darg->x2InSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_x2InSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_x2InSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_x2InSave_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (double) (darg->x2InSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_x1pdfInSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_x1pdfInSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_x1pdfInSave_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_x1pdfInSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg1) darg->x1pdfInSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_x1pdfInSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_x1pdfInSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_x1pdfInSave_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (double) (darg->x1pdfInSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_x2pdfInSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_x2pdfInSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_x2pdfInSave_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_x2pdfInSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg1) darg->x2pdfInSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_x2pdfInSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_x2pdfInSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_x2pdfInSave_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (double) (darg->x2pdfInSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_scalePDFInSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_scalePDFInSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_scalePDFInSave_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_scalePDFInSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg1) darg->scalePDFInSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_scalePDFInSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_scalePDFInSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_scalePDFInSave_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (double) (darg->scalePDFInSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_pdf1InSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_pdf1InSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_pdf1InSave_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_pdf1InSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg1) darg->pdf1InSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_pdf1InSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_pdf1InSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_pdf1InSave_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (double) (darg->pdf1InSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_pdf2InSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_pdf2InSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_pdf2InSave_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAup_pdf2InSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg1) darg->pdf2InSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_pdf2InSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_pdf2InSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_pdf2InSave_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (double) (darg->pdf2InSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_fileName_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_fileName_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_fileName_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAup_fileName_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LHAup_fileName_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg1) darg->fileName = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_fileName_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_fileName_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_fileName_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (std::string *) & (darg->fileName);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_dateNow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[12] ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_dateNow_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_dateNow_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  res2 = SWIG_AsCharArray(obj1, temp2, 12);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAup_dateNow_set" "', argument " "2"" of type '" "char [12]""'");
  }
  arg2 = reinterpret_cast< char * >(temp2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg2) memcpy(darg->dateNow,arg2,12*sizeof(char));
  else memset(darg->dateNow,0,12*sizeof(char));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_dateNow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_dateNow_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_dateNow_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (char *)(char *) (darg->dateNow);
  {
    size_t size = SWIG_strnlen(result, 12);
    
    
    
    resultobj = SWIG_FromCharPtrAndSize(result, size);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_timeNow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  char *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[9] ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_LHAup *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAup_timeNow_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_timeNow_set" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  res2 = SWIG_AsCharArray(obj1, temp2, 9);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAup_timeNow_set" "', argument " "2"" of type '" "char [9]""'");
  }
  arg2 = reinterpret_cast< char * >(temp2);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  if (arg2) memcpy(darg->timeNow,arg2,9*sizeof(char));
  else memset(darg->timeNow,0,9*sizeof(char));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAup_timeNow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_LHAup *darg = 0;
  char *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAup_timeNow_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAup_timeNow_get" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  darg = dynamic_cast<SwigDirector_LHAup *>(arg1);
  result = (char *)(char *) (darg->timeNow);
  {
    size_t size = SWIG_strnlen(result, 9);
    
    
    
    resultobj = SWIG_FromCharPtrAndSize(result, size);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_LHAup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAup *arg1 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:disown_LHAup",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_LHAup" "', argument " "1"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAup * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LHAup_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__LHAup, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LHAupLHEF__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::istream *arg2 = (std::istream *) 0 ;
  std::istream *arg3 = (std::istream *) 0 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::LHAupLHEF *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_LHAupLHEF",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAupLHEF" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LHAupLHEF" "', argument " "2"" of type '" "std::istream *""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LHAupLHEF" "', argument " "3"" of type '" "std::istream *""'"); 
  }
  arg3 = reinterpret_cast< std::istream * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LHAupLHEF" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_LHAupLHEF" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (Pythia8::LHAupLHEF *)new Pythia8::LHAupLHEF(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAupLHEF, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAupLHEF__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::istream *arg2 = (std::istream *) 0 ;
  std::istream *arg3 = (std::istream *) 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::LHAupLHEF *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_LHAupLHEF",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAupLHEF" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LHAupLHEF" "', argument " "2"" of type '" "std::istream *""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LHAupLHEF" "', argument " "3"" of type '" "std::istream *""'"); 
  }
  arg3 = reinterpret_cast< std::istream * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LHAupLHEF" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (Pythia8::LHAupLHEF *)new Pythia8::LHAupLHEF(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAupLHEF, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAupLHEF__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  std::istream *arg2 = (std::istream *) 0 ;
  std::istream *arg3 = (std::istream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::LHAupLHEF *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_LHAupLHEF",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAupLHEF" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LHAupLHEF" "', argument " "2"" of type '" "std::istream *""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LHAupLHEF" "', argument " "3"" of type '" "std::istream *""'"); 
  }
  arg3 = reinterpret_cast< std::istream * >(argp3);
  result = (Pythia8::LHAupLHEF *)new Pythia8::LHAupLHEF(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAupLHEF, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAupLHEF__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::LHAupLHEF *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_LHAupLHEF",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAupLHEF" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LHAupLHEF" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LHAupLHEF" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LHAupLHEF" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_LHAupLHEF" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (Pythia8::LHAupLHEF *)new Pythia8::LHAupLHEF(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAupLHEF, SWIG_POINTER_NEW |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAupLHEF__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::LHAupLHEF *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_LHAupLHEF",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAupLHEF" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LHAupLHEF" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LHAupLHEF" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LHAupLHEF" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (Pythia8::LHAupLHEF *)new Pythia8::LHAupLHEF(arg1,(char const *)arg2,(char const *)arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAupLHEF, SWIG_POINTER_NEW |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAupLHEF__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::LHAupLHEF *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_LHAupLHEF",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAupLHEF" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LHAupLHEF" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LHAupLHEF" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  result = (Pythia8::LHAupLHEF *)new Pythia8::LHAupLHEF(arg1,(char const *)arg2,(char const *)arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAupLHEF, SWIG_POINTER_NEW |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAupLHEF__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::LHAupLHEF *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_LHAupLHEF",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAupLHEF" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LHAupLHEF" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (Pythia8::LHAupLHEF *)new Pythia8::LHAupLHEF(arg1,(char const *)arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAupLHEF, SWIG_POINTER_NEW |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAupLHEF(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_LHAupLHEF__SWIG_6(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_LHAupLHEF__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_LHAupLHEF__SWIG_5(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_LHAupLHEF__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_LHAupLHEF__SWIG_4(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_LHAupLHEF__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_LHAupLHEF__SWIG_3(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LHAupLHEF'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAupLHEF::LHAupLHEF(Pythia8::Info *,std::istream *,std::istream *,bool,bool)\n"
    "    Pythia8::LHAupLHEF::LHAupLHEF(Pythia8::Info *,std::istream *,std::istream *,bool)\n"
    "    Pythia8::LHAupLHEF::LHAupLHEF(Pythia8::Info *,std::istream *,std::istream *)\n"
    "    Pythia8::LHAupLHEF::LHAupLHEF(Pythia8::Info *,char const *,char const *,bool,bool)\n"
    "    Pythia8::LHAupLHEF::LHAupLHEF(Pythia8::Info *,char const *,char const *,bool)\n"
    "    Pythia8::LHAupLHEF::LHAupLHEF(Pythia8::Info *,char const *,char const *)\n"
    "    Pythia8::LHAupLHEF::LHAupLHEF(Pythia8::Info *,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LHAupLHEF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupLHEF *arg1 = (Pythia8::LHAupLHEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LHAupLHEF",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupLHEF, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LHAupLHEF" "', argument " "1"" of type '" "Pythia8::LHAupLHEF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupLHEF * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupLHEF_closeAllFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupLHEF *arg1 = (Pythia8::LHAupLHEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAupLHEF_closeAllFiles",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupLHEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupLHEF_closeAllFiles" "', argument " "1"" of type '" "Pythia8::LHAupLHEF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupLHEF * >(argp1);
  (arg1)->closeAllFiles();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupLHEF_newEventFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupLHEF *arg1 = (Pythia8::LHAupLHEF *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAupLHEF_newEventFile",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupLHEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupLHEF_newEventFile" "', argument " "1"" of type '" "Pythia8::LHAupLHEF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupLHEF * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAupLHEF_newEventFile" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  (arg1)->newEventFile((char const *)arg2);
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupLHEF_fileFound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupLHEF *arg1 = (Pythia8::LHAupLHEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAupLHEF_fileFound",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupLHEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupLHEF_fileFound" "', argument " "1"" of type '" "Pythia8::LHAupLHEF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupLHEF * >(argp1);
  result = (bool)(arg1)->fileFound();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupLHEF_useExternal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupLHEF *arg1 = (Pythia8::LHAupLHEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAupLHEF_useExternal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupLHEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupLHEF_useExternal" "', argument " "1"" of type '" "Pythia8::LHAupLHEF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupLHEF * >(argp1);
  result = (bool)(arg1)->useExternal();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupLHEF_setInit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupLHEF *arg1 = (Pythia8::LHAupLHEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAupLHEF_setInit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupLHEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupLHEF_setInit" "', argument " "1"" of type '" "Pythia8::LHAupLHEF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupLHEF * >(argp1);
  result = (bool)(arg1)->setInit();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupLHEF_setInitLHEF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupLHEF *arg1 = (Pythia8::LHAupLHEF *) 0 ;
  std::istream *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:LHAupLHEF_setInitLHEF",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupLHEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupLHEF_setInitLHEF" "', argument " "1"" of type '" "Pythia8::LHAupLHEF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupLHEF * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHAupLHEF_setInitLHEF" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LHAupLHEF_setInitLHEF" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAupLHEF_setInitLHEF" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->setInitLHEF(*arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupLHEF_setEvent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupLHEF *arg1 = (Pythia8::LHAupLHEF *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAupLHEF_setEvent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupLHEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupLHEF_setEvent" "', argument " "1"" of type '" "Pythia8::LHAupLHEF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupLHEF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAupLHEF_setEvent" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->setEvent(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupLHEF_setEvent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupLHEF *arg1 = (Pythia8::LHAupLHEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAupLHEF_setEvent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupLHEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupLHEF_setEvent" "', argument " "1"" of type '" "Pythia8::LHAupLHEF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupLHEF * >(argp1);
  result = (bool)(arg1)->setEvent();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupLHEF_setEvent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAupLHEF, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LHAupLHEF_setEvent__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAupLHEF, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LHAupLHEF_setEvent__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LHAupLHEF_setEvent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAupLHEF::setEvent(int)\n"
    "    Pythia8::LHAupLHEF::setEvent()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAupLHEF_skipEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupLHEF *arg1 = (Pythia8::LHAupLHEF *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAupLHEF_skipEvent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupLHEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupLHEF_skipEvent" "', argument " "1"" of type '" "Pythia8::LHAupLHEF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupLHEF * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAupLHEF_skipEvent" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->skipEvent(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupLHEF_setNewEventLHEF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupLHEF *arg1 = (Pythia8::LHAupLHEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAupLHEF_setNewEventLHEF",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupLHEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupLHEF_setNewEventLHEF" "', argument " "1"" of type '" "Pythia8::LHAupLHEF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupLHEF * >(argp1);
  result = (bool)(arg1)->setNewEventLHEF();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupLHEF_updateSigma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupLHEF *arg1 = (Pythia8::LHAupLHEF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAupLHEF_updateSigma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupLHEF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupLHEF_updateSigma" "', argument " "1"" of type '" "Pythia8::LHAupLHEF *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupLHEF * >(argp1);
  result = (bool)(arg1)->updateSigma();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LHAupLHEF_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__LHAupLHEF, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LHAupFromPYTHIA8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::LHAupFromPYTHIA8 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_LHAupFromPYTHIA8",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAupFromPYTHIA8" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LHAupFromPYTHIA8" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  result = (Pythia8::LHAupFromPYTHIA8 *)new Pythia8::LHAupFromPYTHIA8(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAupFromPYTHIA8, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_LHAupFromPYTHIA8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupFromPYTHIA8 *arg1 = (Pythia8::LHAupFromPYTHIA8 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LHAupFromPYTHIA8",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupFromPYTHIA8, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LHAupFromPYTHIA8" "', argument " "1"" of type '" "Pythia8::LHAupFromPYTHIA8 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupFromPYTHIA8 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupFromPYTHIA8_setInit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupFromPYTHIA8 *arg1 = (Pythia8::LHAupFromPYTHIA8 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAupFromPYTHIA8_setInit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupFromPYTHIA8, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupFromPYTHIA8_setInit" "', argument " "1"" of type '" "Pythia8::LHAupFromPYTHIA8 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupFromPYTHIA8 * >(argp1);
  result = (bool)(arg1)->setInit();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupFromPYTHIA8_setEvent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupFromPYTHIA8 *arg1 = (Pythia8::LHAupFromPYTHIA8 *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAupFromPYTHIA8_setEvent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupFromPYTHIA8, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupFromPYTHIA8_setEvent" "', argument " "1"" of type '" "Pythia8::LHAupFromPYTHIA8 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupFromPYTHIA8 * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAupFromPYTHIA8_setEvent" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->setEvent(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupFromPYTHIA8_setEvent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupFromPYTHIA8 *arg1 = (Pythia8::LHAupFromPYTHIA8 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAupFromPYTHIA8_setEvent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupFromPYTHIA8, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupFromPYTHIA8_setEvent" "', argument " "1"" of type '" "Pythia8::LHAupFromPYTHIA8 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupFromPYTHIA8 * >(argp1);
  result = (bool)(arg1)->setEvent();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupFromPYTHIA8_setEvent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAupFromPYTHIA8, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LHAupFromPYTHIA8_setEvent__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAupFromPYTHIA8, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LHAupFromPYTHIA8_setEvent__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LHAupFromPYTHIA8_setEvent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAupFromPYTHIA8::setEvent(int)\n"
    "    Pythia8::LHAupFromPYTHIA8::setEvent()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAupFromPYTHIA8_updateSigma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupFromPYTHIA8 *arg1 = (Pythia8::LHAupFromPYTHIA8 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAupFromPYTHIA8_updateSigma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupFromPYTHIA8, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupFromPYTHIA8_updateSigma" "', argument " "1"" of type '" "Pythia8::LHAupFromPYTHIA8 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupFromPYTHIA8 * >(argp1);
  result = (bool)(arg1)->updateSigma();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LHAupFromPYTHIA8_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__LHAupFromPYTHIA8, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LHEF3FromPythia8__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  Pythia8::Settings *arg2 = (Pythia8::Settings *) 0 ;
  Pythia8::Info *arg3 = (Pythia8::Info *) 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  int arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::LHEF3FromPythia8 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_LHEF3FromPythia8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHEF3FromPythia8" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LHEF3FromPythia8" "', argument " "2"" of type '" "Pythia8::Settings *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LHEF3FromPythia8" "', argument " "3"" of type '" "Pythia8::Info *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Info * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LHEF3FromPythia8" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_LHEF3FromPythia8" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_LHEF3FromPythia8" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  result = (Pythia8::LHEF3FromPythia8 *)new Pythia8::LHEF3FromPythia8(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHEF3FromPythia8, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHEF3FromPythia8__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  Pythia8::Settings *arg2 = (Pythia8::Settings *) 0 ;
  Pythia8::Info *arg3 = (Pythia8::Info *) 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::LHEF3FromPythia8 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_LHEF3FromPythia8",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHEF3FromPythia8" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LHEF3FromPythia8" "', argument " "2"" of type '" "Pythia8::Settings *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LHEF3FromPythia8" "', argument " "3"" of type '" "Pythia8::Info *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Info * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LHEF3FromPythia8" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_LHEF3FromPythia8" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (Pythia8::LHEF3FromPythia8 *)new Pythia8::LHEF3FromPythia8(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHEF3FromPythia8, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHEF3FromPythia8__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  Pythia8::Settings *arg2 = (Pythia8::Settings *) 0 ;
  Pythia8::Info *arg3 = (Pythia8::Info *) 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::LHEF3FromPythia8 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_LHEF3FromPythia8",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHEF3FromPythia8" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LHEF3FromPythia8" "', argument " "2"" of type '" "Pythia8::Settings *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LHEF3FromPythia8" "', argument " "3"" of type '" "Pythia8::Info *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Info * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_LHEF3FromPythia8" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  result = (Pythia8::LHEF3FromPythia8 *)new Pythia8::LHEF3FromPythia8(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHEF3FromPythia8, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHEF3FromPythia8(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_LHEF3FromPythia8__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_LHEF3FromPythia8__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_LHEF3FromPythia8__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LHEF3FromPythia8'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHEF3FromPythia8::LHEF3FromPythia8(Pythia8::Event *,Pythia8::Settings *,Pythia8::Info *,Pythia8::ParticleData *,int,bool)\n"
    "    Pythia8::LHEF3FromPythia8::LHEF3FromPythia8(Pythia8::Event *,Pythia8::Settings *,Pythia8::Info *,Pythia8::ParticleData *,int)\n"
    "    Pythia8::LHEF3FromPythia8::LHEF3FromPythia8(Pythia8::Event *,Pythia8::Settings *,Pythia8::Info *,Pythia8::ParticleData *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHEF3FromPythia8_setInit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHEF3FromPythia8 *arg1 = (Pythia8::LHEF3FromPythia8 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHEF3FromPythia8_setInit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHEF3FromPythia8, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHEF3FromPythia8_setInit" "', argument " "1"" of type '" "Pythia8::LHEF3FromPythia8 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHEF3FromPythia8 * >(argp1);
  result = (bool)(arg1)->setInit();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHEF3FromPythia8_setEventPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHEF3FromPythia8 *arg1 = (Pythia8::LHEF3FromPythia8 *) 0 ;
  Pythia8::Event *arg2 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHEF3FromPythia8_setEventPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHEF3FromPythia8, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHEF3FromPythia8_setEventPtr" "', argument " "1"" of type '" "Pythia8::LHEF3FromPythia8 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHEF3FromPythia8 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LHEF3FromPythia8_setEventPtr" "', argument " "2"" of type '" "Pythia8::Event *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  (arg1)->setEventPtr(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHEF3FromPythia8_setEvent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHEF3FromPythia8 *arg1 = (Pythia8::LHEF3FromPythia8 *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHEF3FromPythia8_setEvent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHEF3FromPythia8, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHEF3FromPythia8_setEvent" "', argument " "1"" of type '" "Pythia8::LHEF3FromPythia8 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHEF3FromPythia8 * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHEF3FromPythia8_setEvent" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->setEvent(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHEF3FromPythia8_setEvent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHEF3FromPythia8 *arg1 = (Pythia8::LHEF3FromPythia8 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHEF3FromPythia8_setEvent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHEF3FromPythia8, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHEF3FromPythia8_setEvent" "', argument " "1"" of type '" "Pythia8::LHEF3FromPythia8 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHEF3FromPythia8 * >(argp1);
  result = (bool)(arg1)->setEvent();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHEF3FromPythia8_setEvent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHEF3FromPythia8, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LHEF3FromPythia8_setEvent__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHEF3FromPythia8, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LHEF3FromPythia8_setEvent__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LHEF3FromPythia8_setEvent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHEF3FromPythia8::setEvent(int)\n"
    "    Pythia8::LHEF3FromPythia8::setEvent()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHEF3FromPythia8_getEventString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHEF3FromPythia8 *arg1 = (Pythia8::LHEF3FromPythia8 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHEF3FromPythia8_getEventString",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHEF3FromPythia8, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHEF3FromPythia8_getEventString" "', argument " "1"" of type '" "Pythia8::LHEF3FromPythia8 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHEF3FromPythia8 * >(argp1);
  result = (arg1)->getEventString();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHEF3FromPythia8_openLHEF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHEF3FromPythia8 *arg1 = (Pythia8::LHEF3FromPythia8 *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHEF3FromPythia8_openLHEF",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHEF3FromPythia8, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHEF3FromPythia8_openLHEF" "', argument " "1"" of type '" "Pythia8::LHEF3FromPythia8 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHEF3FromPythia8 * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LHEF3FromPythia8_openLHEF" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->openLHEF(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHEF3FromPythia8_closeLHEF__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHEF3FromPythia8 *arg1 = (Pythia8::LHEF3FromPythia8 *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHEF3FromPythia8_closeLHEF",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHEF3FromPythia8, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHEF3FromPythia8_closeLHEF" "', argument " "1"" of type '" "Pythia8::LHEF3FromPythia8 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHEF3FromPythia8 * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHEF3FromPythia8_closeLHEF" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)(arg1)->closeLHEF(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHEF3FromPythia8_closeLHEF__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHEF3FromPythia8 *arg1 = (Pythia8::LHEF3FromPythia8 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHEF3FromPythia8_closeLHEF",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHEF3FromPythia8, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHEF3FromPythia8_closeLHEF" "', argument " "1"" of type '" "Pythia8::LHEF3FromPythia8 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHEF3FromPythia8 * >(argp1);
  result = (bool)(arg1)->closeLHEF();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHEF3FromPythia8_closeLHEF(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHEF3FromPythia8, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LHEF3FromPythia8_closeLHEF__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHEF3FromPythia8, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LHEF3FromPythia8_closeLHEF__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LHEF3FromPythia8_closeLHEF'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHEF3FromPythia8::closeLHEF(bool)\n"
    "    Pythia8::LHEF3FromPythia8::closeLHEF()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LHEF3FromPythia8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHEF3FromPythia8 *arg1 = (Pythia8::LHEF3FromPythia8 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LHEF3FromPythia8",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHEF3FromPythia8, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LHEF3FromPythia8" "', argument " "1"" of type '" "Pythia8::LHEF3FromPythia8 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHEF3FromPythia8 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LHEF3FromPythia8_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__LHEF3FromPythia8, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MiniStringFragmentation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MiniStringFragmentation *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MiniStringFragmentation")) SWIG_fail;
  result = (Pythia8::MiniStringFragmentation *)new Pythia8::MiniStringFragmentation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MiniStringFragmentation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MiniStringFragmentation_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MiniStringFragmentation *arg1 = (Pythia8::MiniStringFragmentation *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  Pythia8::StringFlav *arg6 = (Pythia8::StringFlav *) 0 ;
  Pythia8::StringPT *arg7 = (Pythia8::StringPT *) 0 ;
  Pythia8::StringZ *arg8 = (Pythia8::StringZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:MiniStringFragmentation_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MiniStringFragmentation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MiniStringFragmentation_init" "', argument " "1"" of type '" "Pythia8::MiniStringFragmentation *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MiniStringFragmentation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MiniStringFragmentation_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MiniStringFragmentation_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MiniStringFragmentation_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MiniStringFragmentation_init" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MiniStringFragmentation_init" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "MiniStringFragmentation_init" "', argument " "6"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::StringFlav * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__StringPT, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "MiniStringFragmentation_init" "', argument " "7"" of type '" "Pythia8::StringPT *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::StringPT * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__StringZ, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "MiniStringFragmentation_init" "', argument " "8"" of type '" "Pythia8::StringZ *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::StringZ * >(argp8);
  (arg1)->init(arg2,*arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MiniStringFragmentation_fragment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MiniStringFragmentation *arg1 = (Pythia8::MiniStringFragmentation *) 0 ;
  int arg2 ;
  Pythia8::ColConfig *arg3 = 0 ;
  Pythia8::Event *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:MiniStringFragmentation_fragment",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MiniStringFragmentation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MiniStringFragmentation_fragment" "', argument " "1"" of type '" "Pythia8::MiniStringFragmentation *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MiniStringFragmentation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MiniStringFragmentation_fragment" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__ColConfig,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MiniStringFragmentation_fragment" "', argument " "3"" of type '" "Pythia8::ColConfig &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MiniStringFragmentation_fragment" "', argument " "3"" of type '" "Pythia8::ColConfig &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ColConfig * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MiniStringFragmentation_fragment" "', argument " "4"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MiniStringFragmentation_fragment" "', argument " "4"" of type '" "Pythia8::Event &""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Event * >(argp4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MiniStringFragmentation_fragment" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (bool)(arg1)->fragment(arg2,*arg3,*arg4,arg5);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MiniStringFragmentation_fragment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MiniStringFragmentation *arg1 = (Pythia8::MiniStringFragmentation *) 0 ;
  int arg2 ;
  Pythia8::ColConfig *arg3 = 0 ;
  Pythia8::Event *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:MiniStringFragmentation_fragment",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MiniStringFragmentation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MiniStringFragmentation_fragment" "', argument " "1"" of type '" "Pythia8::MiniStringFragmentation *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MiniStringFragmentation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MiniStringFragmentation_fragment" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__ColConfig,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MiniStringFragmentation_fragment" "', argument " "3"" of type '" "Pythia8::ColConfig &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MiniStringFragmentation_fragment" "', argument " "3"" of type '" "Pythia8::ColConfig &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ColConfig * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MiniStringFragmentation_fragment" "', argument " "4"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MiniStringFragmentation_fragment" "', argument " "4"" of type '" "Pythia8::Event &""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Event * >(argp4);
  result = (bool)(arg1)->fragment(arg2,*arg3,*arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MiniStringFragmentation_fragment(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MiniStringFragmentation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__ColConfig, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_MiniStringFragmentation_fragment__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MiniStringFragmentation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__ColConfig, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_MiniStringFragmentation_fragment__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MiniStringFragmentation_fragment'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::MiniStringFragmentation::fragment(int,Pythia8::ColConfig &,Pythia8::Event &,bool)\n"
    "    Pythia8::MiniStringFragmentation::fragment(int,Pythia8::ColConfig &,Pythia8::Event &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MiniStringFragmentation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MiniStringFragmentation *arg1 = (Pythia8::MiniStringFragmentation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MiniStringFragmentation",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MiniStringFragmentation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MiniStringFragmentation" "', argument " "1"" of type '" "Pythia8::MiniStringFragmentation *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MiniStringFragmentation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MiniStringFragmentation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__MiniStringFragmentation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PartonVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonVertex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PartonVertex")) SWIG_fail;
  result = (Pythia8::PartonVertex *)new Pythia8::PartonVertex();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PartonVertex, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PartonVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonVertex *arg1 = (Pythia8::PartonVertex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PartonVertex",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonVertex, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PartonVertex" "', argument " "1"" of type '" "Pythia8::PartonVertex *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonVertex * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonVertex_initPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonVertex *arg1 = (Pythia8::PartonVertex *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = (Pythia8::Settings *) 0 ;
  Pythia8::Rndm *arg4 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:PartonVertex_initPtr",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonVertex_initPtr" "', argument " "1"" of type '" "Pythia8::PartonVertex *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonVertex * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PartonVertex_initPtr" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PartonVertex_initPtr" "', argument " "3"" of type '" "Pythia8::Settings *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PartonVertex_initPtr" "', argument " "4"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Rndm * >(argp4);
  (arg1)->initPtr(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonVertex_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonVertex *arg1 = (Pythia8::PartonVertex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PartonVertex_init",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonVertex_init" "', argument " "1"" of type '" "Pythia8::PartonVertex *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonVertex * >(argp1);
  (arg1)->init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonVertex_vertexBeam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonVertex *arg1 = (Pythia8::PartonVertex *) 0 ;
  int arg2 ;
  int arg3 ;
  Pythia8::Event *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:PartonVertex_vertexBeam",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonVertex_vertexBeam" "', argument " "1"" of type '" "Pythia8::PartonVertex *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonVertex * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonVertex_vertexBeam" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PartonVertex_vertexBeam" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PartonVertex_vertexBeam" "', argument " "4"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PartonVertex_vertexBeam" "', argument " "4"" of type '" "Pythia8::Event &""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Event * >(argp4);
  (arg1)->vertexBeam(arg2,arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonVertex_vertexMPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonVertex *arg1 = (Pythia8::PartonVertex *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  Pythia8::Event *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:PartonVertex_vertexMPI",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonVertex_vertexMPI" "', argument " "1"" of type '" "Pythia8::PartonVertex *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonVertex * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonVertex_vertexMPI" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PartonVertex_vertexMPI" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PartonVertex_vertexMPI" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "PartonVertex_vertexMPI" "', argument " "5"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PartonVertex_vertexMPI" "', argument " "5"" of type '" "Pythia8::Event &""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Event * >(argp5);
  (arg1)->vertexMPI(arg2,arg3,arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonVertex_vertexFSR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonVertex *arg1 = (Pythia8::PartonVertex *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PartonVertex_vertexFSR",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonVertex_vertexFSR" "', argument " "1"" of type '" "Pythia8::PartonVertex *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonVertex * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonVertex_vertexFSR" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PartonVertex_vertexFSR" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PartonVertex_vertexFSR" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  (arg1)->vertexFSR(arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonVertex_vertexISR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonVertex *arg1 = (Pythia8::PartonVertex *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PartonVertex_vertexISR",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonVertex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonVertex_vertexISR" "', argument " "1"" of type '" "Pythia8::PartonVertex *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonVertex * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonVertex_vertexISR" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PartonVertex_vertexISR" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PartonVertex_vertexISR" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  (arg1)->vertexISR(arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PartonVertex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__PartonVertex, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceDecays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceDecays *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ResonanceDecays")) SWIG_fail;
  result = (Pythia8::ResonanceDecays *)new Pythia8::ResonanceDecays();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceDecays, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceDecays_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceDecays *arg1 = (Pythia8::ResonanceDecays *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::ParticleData *arg3 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg4 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ResonanceDecays_init",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceDecays, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceDecays_init" "', argument " "1"" of type '" "Pythia8::ResonanceDecays *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceDecays * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ResonanceDecays_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ResonanceDecays_init" "', argument " "3"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ParticleData * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ResonanceDecays_init" "', argument " "4"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Rndm * >(argp4);
  (arg1)->init(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceDecays_next__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceDecays *arg1 = (Pythia8::ResonanceDecays *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ResonanceDecays_next",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceDecays, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceDecays_next" "', argument " "1"" of type '" "Pythia8::ResonanceDecays *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceDecays * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ResonanceDecays_next" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ResonanceDecays_next" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ResonanceDecays_next" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (bool)(arg1)->next(*arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceDecays_next__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceDecays *arg1 = (Pythia8::ResonanceDecays *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResonanceDecays_next",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceDecays, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResonanceDecays_next" "', argument " "1"" of type '" "Pythia8::ResonanceDecays *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceDecays * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ResonanceDecays_next" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ResonanceDecays_next" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->next(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResonanceDecays_next(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResonanceDecays, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ResonanceDecays_next__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResonanceDecays, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ResonanceDecays_next__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ResonanceDecays_next'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ResonanceDecays::next(Pythia8::Event &,int)\n"
    "    Pythia8::ResonanceDecays::next(Pythia8::Event &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceDecays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceDecays *arg1 = (Pythia8::ResonanceDecays *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceDecays",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceDecays, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceDecays" "', argument " "1"" of type '" "Pythia8::ResonanceDecays *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceDecays * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceDecays_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceDecays, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceS *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceS",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceS" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResonanceS *)new Pythia8::ResonanceS(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceS, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceS *arg1 = (Pythia8::ResonanceS *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceS",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceS, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceS" "', argument " "1"" of type '" "Pythia8::ResonanceS *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceS * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceS_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceS, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceZp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceZp *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceZp",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceZp" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResonanceZp *)new Pythia8::ResonanceZp(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceZp, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceZp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceZp *arg1 = (Pythia8::ResonanceZp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceZp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceZp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceZp" "', argument " "1"" of type '" "Pythia8::ResonanceZp *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceZp * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceZp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceZp, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RHadrons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RHadrons *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RHadrons")) SWIG_fail;
  result = (Pythia8::RHadrons *)new Pythia8::RHadrons();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__RHadrons, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RHadrons_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RHadrons *arg1 = (Pythia8::RHadrons *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:RHadrons_init",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RHadrons, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RHadrons_init" "', argument " "1"" of type '" "Pythia8::RHadrons *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RHadrons * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RHadrons_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RHadrons_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RHadrons_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RHadrons_init" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "RHadrons_init" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  result = (bool)(arg1)->init(arg2,*arg3,arg4,arg5);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RHadrons_fragPtrs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RHadrons *arg1 = (Pythia8::RHadrons *) 0 ;
  Pythia8::StringFlav *arg2 = (Pythia8::StringFlav *) 0 ;
  Pythia8::StringZ *arg3 = (Pythia8::StringZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RHadrons_fragPtrs",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RHadrons, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RHadrons_fragPtrs" "', argument " "1"" of type '" "Pythia8::RHadrons *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RHadrons * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RHadrons_fragPtrs" "', argument " "2"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::StringFlav * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__StringZ, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RHadrons_fragPtrs" "', argument " "3"" of type '" "Pythia8::StringZ *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::StringZ * >(argp3);
  (arg1)->fragPtrs(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RHadrons_produce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RHadrons *arg1 = (Pythia8::RHadrons *) 0 ;
  Pythia8::ColConfig *arg2 = 0 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RHadrons_produce",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RHadrons, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RHadrons_produce" "', argument " "1"" of type '" "Pythia8::RHadrons *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RHadrons * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__ColConfig,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RHadrons_produce" "', argument " "2"" of type '" "Pythia8::ColConfig &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RHadrons_produce" "', argument " "2"" of type '" "Pythia8::ColConfig &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ColConfig * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RHadrons_produce" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RHadrons_produce" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  result = (bool)(arg1)->produce(*arg2,*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RHadrons_decay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RHadrons *arg1 = (Pythia8::RHadrons *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RHadrons_decay",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RHadrons, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RHadrons_decay" "', argument " "1"" of type '" "Pythia8::RHadrons *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RHadrons * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RHadrons_decay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RHadrons_decay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->decay(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RHadrons_givesRHadron(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RHadrons *arg1 = (Pythia8::RHadrons *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RHadrons_givesRHadron",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RHadrons, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RHadrons_givesRHadron" "', argument " "1"" of type '" "Pythia8::RHadrons *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RHadrons * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RHadrons_givesRHadron" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->givesRHadron(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RHadrons_exist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RHadrons *arg1 = (Pythia8::RHadrons *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RHadrons_exist",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RHadrons, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RHadrons_exist" "', argument " "1"" of type '" "Pythia8::RHadrons *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RHadrons * >(argp1);
  result = (bool)(arg1)->exist();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RHadrons_trace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RHadrons *arg1 = (Pythia8::RHadrons *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RHadrons_trace",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RHadrons, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RHadrons_trace" "', argument " "1"" of type '" "Pythia8::RHadrons *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RHadrons * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RHadrons_trace" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->trace(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RHadrons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RHadrons *arg1 = (Pythia8::RHadrons *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RHadrons",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RHadrons, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RHadrons" "', argument " "1"" of type '" "Pythia8::RHadrons *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RHadrons * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RHadrons_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__RHadrons, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RopeDipoleEnd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RopeDipoleEnd")) SWIG_fail;
  result = (Pythia8::RopeDipoleEnd *)new Pythia8::RopeDipoleEnd();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__RopeDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RopeDipoleEnd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Event *arg1 = (Pythia8::Event *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::RopeDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_RopeDipoleEnd",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RopeDipoleEnd" "', argument " "1"" of type '" "Pythia8::Event *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Event * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RopeDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::RopeDipoleEnd *)new Pythia8::RopeDipoleEnd(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__RopeDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_RopeDipoleEnd(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_RopeDipoleEnd__SWIG_0(self, args);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_RopeDipoleEnd__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RopeDipoleEnd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::RopeDipoleEnd::RopeDipoleEnd()\n"
    "    Pythia8::RopeDipoleEnd::RopeDipoleEnd(Pythia8::Event *,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RopeDipoleEnd_getParticlePtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipoleEnd *arg1 = (Pythia8::RopeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RopeDipoleEnd_getParticlePtr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipoleEnd_getParticlePtr" "', argument " "1"" of type '" "Pythia8::RopeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipoleEnd * >(argp1);
  result = (Pythia8::Particle *)(arg1)->getParticlePtr();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipoleEnd_getNe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipoleEnd *arg1 = (Pythia8::RopeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RopeDipoleEnd_getNe",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipoleEnd_getNe" "', argument " "1"" of type '" "Pythia8::RopeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipoleEnd * >(argp1);
  result = (int)(arg1)->getNe();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipoleEnd_labrap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipoleEnd *arg1 = (Pythia8::RopeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RopeDipoleEnd_labrap",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipoleEnd_labrap" "', argument " "1"" of type '" "Pythia8::RopeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipoleEnd * >(argp1);
  result = (double)(arg1)->labrap();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipoleEnd_rap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipoleEnd *arg1 = (Pythia8::RopeDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RopeDipoleEnd_rap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipoleEnd_rap" "', argument " "1"" of type '" "Pythia8::RopeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RopeDipoleEnd_rap" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->rap(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipoleEnd_rap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipoleEnd *arg1 = (Pythia8::RopeDipoleEnd *) 0 ;
  double arg2 ;
  Pythia8::RotBstMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RopeDipoleEnd_rap",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipoleEnd_rap" "', argument " "1"" of type '" "Pythia8::RopeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RopeDipoleEnd_rap" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__RotBstMatrix,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RopeDipoleEnd_rap" "', argument " "3"" of type '" "Pythia8::RotBstMatrix &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RopeDipoleEnd_rap" "', argument " "3"" of type '" "Pythia8::RotBstMatrix &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp3);
  result = (double)(arg1)->rap(arg2,*arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipoleEnd_rap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__RopeDipoleEnd, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RopeDipoleEnd_rap__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__RopeDipoleEnd, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__RotBstMatrix, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RopeDipoleEnd_rap__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'RopeDipoleEnd_rap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::RopeDipoleEnd::rap(double)\n"
    "    Pythia8::RopeDipoleEnd::rap(double,Pythia8::RotBstMatrix &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_RopeDipoleEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipoleEnd *arg1 = (Pythia8::RopeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RopeDipoleEnd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipoleEnd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RopeDipoleEnd" "', argument " "1"" of type '" "Pythia8::RopeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipoleEnd * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RopeDipoleEnd_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__RopeDipoleEnd, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_OverlappingRopeDipole(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  double arg2 ;
  Pythia8::RotBstMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::OverlappingRopeDipole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_OverlappingRopeDipole",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OverlappingRopeDipole" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_OverlappingRopeDipole" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__RotBstMatrix,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_OverlappingRopeDipole" "', argument " "3"" of type '" "Pythia8::RotBstMatrix &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OverlappingRopeDipole" "', argument " "3"" of type '" "Pythia8::RotBstMatrix &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp3);
  result = (Pythia8::OverlappingRopeDipole *)new Pythia8::OverlappingRopeDipole(arg1,arg2,*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__OverlappingRopeDipole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OverlappingRopeDipole_overlap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::OverlappingRopeDipole *arg1 = (Pythia8::OverlappingRopeDipole *) 0 ;
  double arg2 ;
  Pythia8::Vec4 arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:OverlappingRopeDipole_overlap",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__OverlappingRopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OverlappingRopeDipole_overlap" "', argument " "1"" of type '" "Pythia8::OverlappingRopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::OverlappingRopeDipole * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OverlappingRopeDipole_overlap" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OverlappingRopeDipole_overlap" "', argument " "3"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OverlappingRopeDipole_overlap" "', argument " "3"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "OverlappingRopeDipole_overlap" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->overlap(arg2,arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OverlappingRopeDipole_hadronized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::OverlappingRopeDipole *arg1 = (Pythia8::OverlappingRopeDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OverlappingRopeDipole_hadronized",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__OverlappingRopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OverlappingRopeDipole_hadronized" "', argument " "1"" of type '" "Pythia8::OverlappingRopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::OverlappingRopeDipole * >(argp1);
  result = (bool)(arg1)->hadronized();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OverlappingRopeDipole_dir_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::OverlappingRopeDipole *arg1 = (Pythia8::OverlappingRopeDipole *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OverlappingRopeDipole_dir_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__OverlappingRopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OverlappingRopeDipole_dir_set" "', argument " "1"" of type '" "Pythia8::OverlappingRopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::OverlappingRopeDipole * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OverlappingRopeDipole_dir_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->dir = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OverlappingRopeDipole_dir_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::OverlappingRopeDipole *arg1 = (Pythia8::OverlappingRopeDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OverlappingRopeDipole_dir_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__OverlappingRopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OverlappingRopeDipole_dir_get" "', argument " "1"" of type '" "Pythia8::OverlappingRopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::OverlappingRopeDipole * >(argp1);
  result = (int) ((arg1)->dir);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OverlappingRopeDipole_y1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::OverlappingRopeDipole *arg1 = (Pythia8::OverlappingRopeDipole *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OverlappingRopeDipole_y1_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__OverlappingRopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OverlappingRopeDipole_y1_set" "', argument " "1"" of type '" "Pythia8::OverlappingRopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::OverlappingRopeDipole * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OverlappingRopeDipole_y1_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->y1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OverlappingRopeDipole_y1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::OverlappingRopeDipole *arg1 = (Pythia8::OverlappingRopeDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OverlappingRopeDipole_y1_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__OverlappingRopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OverlappingRopeDipole_y1_get" "', argument " "1"" of type '" "Pythia8::OverlappingRopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::OverlappingRopeDipole * >(argp1);
  result = (double) ((arg1)->y1);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OverlappingRopeDipole_y2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::OverlappingRopeDipole *arg1 = (Pythia8::OverlappingRopeDipole *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OverlappingRopeDipole_y2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__OverlappingRopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OverlappingRopeDipole_y2_set" "', argument " "1"" of type '" "Pythia8::OverlappingRopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::OverlappingRopeDipole * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OverlappingRopeDipole_y2_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->y2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OverlappingRopeDipole_y2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::OverlappingRopeDipole *arg1 = (Pythia8::OverlappingRopeDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OverlappingRopeDipole_y2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__OverlappingRopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OverlappingRopeDipole_y2_get" "', argument " "1"" of type '" "Pythia8::OverlappingRopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::OverlappingRopeDipole * >(argp1);
  result = (double) ((arg1)->y2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OverlappingRopeDipole_b1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::OverlappingRopeDipole *arg1 = (Pythia8::OverlappingRopeDipole *) 0 ;
  Pythia8::Vec4 *arg2 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OverlappingRopeDipole_b1_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__OverlappingRopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OverlappingRopeDipole_b1_set" "', argument " "1"" of type '" "Pythia8::OverlappingRopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::OverlappingRopeDipole * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OverlappingRopeDipole_b1_set" "', argument " "2"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  if (arg1) (arg1)->b1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OverlappingRopeDipole_b1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::OverlappingRopeDipole *arg1 = (Pythia8::OverlappingRopeDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OverlappingRopeDipole_b1_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__OverlappingRopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OverlappingRopeDipole_b1_get" "', argument " "1"" of type '" "Pythia8::OverlappingRopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::OverlappingRopeDipole * >(argp1);
  result = (Pythia8::Vec4 *)& ((arg1)->b1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OverlappingRopeDipole_b2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::OverlappingRopeDipole *arg1 = (Pythia8::OverlappingRopeDipole *) 0 ;
  Pythia8::Vec4 *arg2 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:OverlappingRopeDipole_b2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__OverlappingRopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OverlappingRopeDipole_b2_set" "', argument " "1"" of type '" "Pythia8::OverlappingRopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::OverlappingRopeDipole * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OverlappingRopeDipole_b2_set" "', argument " "2"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  if (arg1) (arg1)->b2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_OverlappingRopeDipole_b2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::OverlappingRopeDipole *arg1 = (Pythia8::OverlappingRopeDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:OverlappingRopeDipole_b2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__OverlappingRopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OverlappingRopeDipole_b2_get" "', argument " "1"" of type '" "Pythia8::OverlappingRopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::OverlappingRopeDipole * >(argp1);
  result = (Pythia8::Vec4 *)& ((arg1)->b2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_OverlappingRopeDipole(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::OverlappingRopeDipole *arg1 = (Pythia8::OverlappingRopeDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_OverlappingRopeDipole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__OverlappingRopeDipole, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OverlappingRopeDipole" "', argument " "1"" of type '" "Pythia8::OverlappingRopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::OverlappingRopeDipole * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *OverlappingRopeDipole_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__OverlappingRopeDipole, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RopeDipole(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipoleEnd arg1 ;
  Pythia8::RopeDipoleEnd arg2 ;
  int arg3 ;
  Pythia8::Info *arg4 = (Pythia8::Info *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::RopeDipole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_RopeDipole",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__RopeDipoleEnd,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RopeDipole" "', argument " "1"" of type '" "Pythia8::RopeDipoleEnd""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RopeDipole" "', argument " "1"" of type '" "Pythia8::RopeDipoleEnd""'");
    } else {
      Pythia8::RopeDipoleEnd * temp = reinterpret_cast< Pythia8::RopeDipoleEnd * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__RopeDipoleEnd,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RopeDipole" "', argument " "2"" of type '" "Pythia8::RopeDipoleEnd""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RopeDipole" "', argument " "2"" of type '" "Pythia8::RopeDipoleEnd""'");
    } else {
      Pythia8::RopeDipoleEnd * temp = reinterpret_cast< Pythia8::RopeDipoleEnd * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RopeDipole" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RopeDipole" "', argument " "4"" of type '" "Pythia8::Info *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Info * >(argp4);
  result = (Pythia8::RopeDipole *)new Pythia8::RopeDipole(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__RopeDipole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_addExcitation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  double arg2 ;
  Pythia8::Particle *arg3 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RopeDipole_addExcitation",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_addExcitation" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RopeDipole_addExcitation" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RopeDipole_addExcitation" "', argument " "3"" of type '" "Pythia8::Particle *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Particle * >(argp3);
  (arg1)->addExcitation(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_d1Ptr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::RopeDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RopeDipole_d1Ptr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_d1Ptr" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  result = (Pythia8::RopeDipoleEnd *)(arg1)->d1Ptr();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__RopeDipoleEnd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_d2Ptr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::RopeDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RopeDipole_d2Ptr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_d2Ptr" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  result = (Pythia8::RopeDipoleEnd *)(arg1)->d2Ptr();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__RopeDipoleEnd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_getDipoleRestFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::RotBstMatrix result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RopeDipole_getDipoleRestFrame",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_getDipoleRestFrame" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  result = (arg1)->getDipoleRestFrame();
  resultobj = SWIG_NewPointerObj((new Pythia8::RotBstMatrix(static_cast< const Pythia8::RotBstMatrix& >(result))), SWIGTYPE_p_Pythia8__RotBstMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_getDipoleLabFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::RotBstMatrix result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RopeDipole_getDipoleLabFrame",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_getDipoleLabFrame" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  result = (arg1)->getDipoleLabFrame();
  resultobj = SWIG_NewPointerObj((new Pythia8::RotBstMatrix(static_cast< const Pythia8::RotBstMatrix& >(result))), SWIGTYPE_p_Pythia8__RotBstMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_dipoleMomentum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RopeDipole_dipoleMomentum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_dipoleMomentum" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  result = (arg1)->dipoleMomentum();
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_bInterpolateDip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RopeDipole_bInterpolateDip",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_bInterpolateDip" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RopeDipole_bInterpolateDip" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RopeDipole_bInterpolateDip" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (arg1)->bInterpolateDip(arg2,arg3);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_bInterpolateLab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RopeDipole_bInterpolateLab",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_bInterpolateLab" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RopeDipole_bInterpolateLab" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RopeDipole_bInterpolateLab" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (arg1)->bInterpolateLab(arg2,arg3);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_bInterpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  double arg2 ;
  Pythia8::RotBstMatrix arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:RopeDipole_bInterpolate",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_bInterpolate" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RopeDipole_bInterpolate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__RotBstMatrix,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RopeDipole_bInterpolate" "', argument " "3"" of type '" "Pythia8::RotBstMatrix""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RopeDipole_bInterpolate" "', argument " "3"" of type '" "Pythia8::RotBstMatrix""'");
    } else {
      Pythia8::RotBstMatrix * temp = reinterpret_cast< Pythia8::RotBstMatrix * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RopeDipole_bInterpolate" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (arg1)->bInterpolate(arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_getOverlaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  std::pair< int,int > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:RopeDipole_getOverlaps",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_getOverlaps" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RopeDipole_getOverlaps" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RopeDipole_getOverlaps" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RopeDipole_getOverlaps" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (arg1)->getOverlaps(arg2,arg3,arg4);
  resultobj = swig::from(static_cast< std::pair< int,int > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_addOverlappingDipole(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  Pythia8::OverlappingRopeDipole *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RopeDipole_addOverlappingDipole",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_addOverlappingDipole" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__OverlappingRopeDipole,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RopeDipole_addOverlappingDipole" "', argument " "2"" of type '" "Pythia8::OverlappingRopeDipole &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RopeDipole_addOverlappingDipole" "', argument " "2"" of type '" "Pythia8::OverlappingRopeDipole &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::OverlappingRopeDipole * >(argp2);
  (arg1)->addOverlappingDipole(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_maxRapidity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RopeDipole_maxRapidity",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_maxRapidity" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RopeDipole_maxRapidity" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->maxRapidity(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_minRapidity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RopeDipole_minRapidity",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_minRapidity" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RopeDipole_minRapidity" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->minRapidity(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_maxRapidity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  double arg2 ;
  Pythia8::RotBstMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RopeDipole_maxRapidity",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_maxRapidity" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RopeDipole_maxRapidity" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__RotBstMatrix,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RopeDipole_maxRapidity" "', argument " "3"" of type '" "Pythia8::RotBstMatrix &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RopeDipole_maxRapidity" "', argument " "3"" of type '" "Pythia8::RotBstMatrix &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp3);
  result = (double)(arg1)->maxRapidity(arg2,*arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_maxRapidity(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__RopeDipole, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RopeDipole_maxRapidity__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__RopeDipole, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__RotBstMatrix, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RopeDipole_maxRapidity__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'RopeDipole_maxRapidity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::RopeDipole::maxRapidity(double)\n"
    "    Pythia8::RopeDipole::maxRapidity(double,Pythia8::RotBstMatrix &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RopeDipole_minRapidity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  double arg2 ;
  Pythia8::RotBstMatrix *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RopeDipole_minRapidity",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_minRapidity" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RopeDipole_minRapidity" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__RotBstMatrix,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RopeDipole_minRapidity" "', argument " "3"" of type '" "Pythia8::RotBstMatrix &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RopeDipole_minRapidity" "', argument " "3"" of type '" "Pythia8::RotBstMatrix &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::RotBstMatrix * >(argp3);
  result = (double)(arg1)->minRapidity(arg2,*arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_minRapidity(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__RopeDipole, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RopeDipole_minRapidity__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__RopeDipole, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__RotBstMatrix, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RopeDipole_minRapidity__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'RopeDipole_minRapidity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::RopeDipole::minRapidity(double)\n"
    "    Pythia8::RopeDipole::minRapidity(double,Pythia8::RotBstMatrix &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RopeDipole_propagateInit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RopeDipole_propagateInit",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_propagateInit" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RopeDipole_propagateInit" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->propagateInit(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_propagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RopeDipole_propagate",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_propagate" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RopeDipole_propagate" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RopeDipole_propagate" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->propagate(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_splitMomentum__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  Pythia8::Vec4 arg2 ;
  Pythia8::Particle *arg3 = (Pythia8::Particle *) 0 ;
  Pythia8::Particle *arg4 = (Pythia8::Particle *) 0 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:RopeDipole_splitMomentum",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_splitMomentum" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RopeDipole_splitMomentum" "', argument " "2"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RopeDipole_splitMomentum" "', argument " "2"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RopeDipole_splitMomentum" "', argument " "3"" of type '" "Pythia8::Particle *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Particle * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RopeDipole_splitMomentum" "', argument " "4"" of type '" "Pythia8::Particle *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Particle * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RopeDipole_splitMomentum" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  (arg1)->splitMomentum(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_splitMomentum__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  Pythia8::Vec4 arg2 ;
  Pythia8::Particle *arg3 = (Pythia8::Particle *) 0 ;
  Pythia8::Particle *arg4 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:RopeDipole_splitMomentum",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_splitMomentum" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RopeDipole_splitMomentum" "', argument " "2"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RopeDipole_splitMomentum" "', argument " "2"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RopeDipole_splitMomentum" "', argument " "3"" of type '" "Pythia8::Particle *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Particle * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RopeDipole_splitMomentum" "', argument " "4"" of type '" "Pythia8::Particle *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Particle * >(argp4);
  (arg1)->splitMomentum(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_splitMomentum(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__RopeDipole, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_RopeDipole_splitMomentum__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__RopeDipole, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__Particle, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_RopeDipole_splitMomentum__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'RopeDipole_splitMomentum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::RopeDipole::splitMomentum(Pythia8::Vec4,Pythia8::Particle *,Pythia8::Particle *,double)\n"
    "    Pythia8::RopeDipole::splitMomentum(Pythia8::Vec4,Pythia8::Particle *,Pythia8::Particle *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RopeDipole_excitationsToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  double arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RopeDipole_excitationsToString",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_excitationsToString" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RopeDipole_excitationsToString" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RopeDipole_excitationsToString" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RopeDipole_excitationsToString" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  (arg1)->excitationsToString(arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_hadronized__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RopeDipole_hadronized",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_hadronized" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  result = (bool)(arg1)->hadronized();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_index(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RopeDipole_index",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_index" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  result = (int)(arg1)->index();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_recoil__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RopeDipole_recoil",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_recoil" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RopeDipole_recoil" "', argument " "2"" of type '" "Pythia8::Vec4 &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RopeDipole_recoil" "', argument " "2"" of type '" "Pythia8::Vec4 &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RopeDipole_recoil" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->recoil(*arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_recoil__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RopeDipole_recoil",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_recoil" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RopeDipole_recoil" "', argument " "2"" of type '" "Pythia8::Vec4 &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RopeDipole_recoil" "', argument " "2"" of type '" "Pythia8::Vec4 &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  result = (bool)(arg1)->recoil(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_recoil(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__RopeDipole, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RopeDipole_recoil__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__RopeDipole, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RopeDipole_recoil__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'RopeDipole_recoil'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::RopeDipole::recoil(Pythia8::Vec4 &,bool)\n"
    "    Pythia8::RopeDipole::recoil(Pythia8::Vec4 &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RopeDipole_hadronized__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RopeDipole_hadronized",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_hadronized" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RopeDipole_hadronized" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->hadronized(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeDipole_hadronized(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__RopeDipole, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RopeDipole_hadronized__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__RopeDipole, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RopeDipole_hadronized__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'RopeDipole_hadronized'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::RopeDipole::hadronized()\n"
    "    Pythia8::RopeDipole::hadronized(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_RopeDipole_nExcitations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:RopeDipole_nExcitations",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeDipole_nExcitations" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  result = (int)(arg1)->nExcitations();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RopeDipole(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeDipole *arg1 = (Pythia8::RopeDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RopeDipole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeDipole, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RopeDipole" "', argument " "1"" of type '" "Pythia8::RopeDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeDipole * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RopeDipole_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__RopeDipole, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Ropewalk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Ropewalk *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Ropewalk")) SWIG_fail;
  result = (Pythia8::Ropewalk *)new Pythia8::Ropewalk();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Ropewalk, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Ropewalk_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Ropewalk *arg1 = (Pythia8::Ropewalk *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::Rndm *arg4 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Ropewalk_init",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Ropewalk, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ropewalk_init" "', argument " "1"" of type '" "Pythia8::Ropewalk *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Ropewalk * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ropewalk_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ropewalk_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Ropewalk_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Ropewalk_init" "', argument " "4"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Rndm * >(argp4);
  result = (bool)(arg1)->init(arg2,*arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Ropewalk_extractDipoles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Ropewalk *arg1 = (Pythia8::Ropewalk *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  Pythia8::ColConfig *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Ropewalk_extractDipoles",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Ropewalk, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ropewalk_extractDipoles" "', argument " "1"" of type '" "Pythia8::Ropewalk *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Ropewalk * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ropewalk_extractDipoles" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Ropewalk_extractDipoles" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__ColConfig,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ropewalk_extractDipoles" "', argument " "3"" of type '" "Pythia8::ColConfig &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Ropewalk_extractDipoles" "', argument " "3"" of type '" "Pythia8::ColConfig &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ColConfig * >(argp3);
  result = (bool)(arg1)->extractDipoles(*arg2,*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Ropewalk_calculateOverlaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Ropewalk *arg1 = (Pythia8::Ropewalk *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Ropewalk_calculateOverlaps",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Ropewalk, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ropewalk_calculateOverlaps" "', argument " "1"" of type '" "Pythia8::Ropewalk *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Ropewalk * >(argp1);
  result = (bool)(arg1)->calculateOverlaps();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Ropewalk_getKappaHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Ropewalk *arg1 = (Pythia8::Ropewalk *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Ropewalk_getKappaHere",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Ropewalk, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ropewalk_getKappaHere" "', argument " "1"" of type '" "Pythia8::Ropewalk *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Ropewalk * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ropewalk_getKappaHere" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Ropewalk_getKappaHere" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Ropewalk_getKappaHere" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->getKappaHere(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Ropewalk_multiplicity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Ropewalk *arg1 = (Pythia8::Ropewalk *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Ropewalk_multiplicity",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Ropewalk, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ropewalk_multiplicity" "', argument " "1"" of type '" "Pythia8::Ropewalk *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Ropewalk * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ropewalk_multiplicity" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Ropewalk_multiplicity" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)(arg1)->multiplicity(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Ropewalk_averageKappa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Ropewalk *arg1 = (Pythia8::Ropewalk *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Ropewalk_averageKappa",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Ropewalk, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ropewalk_averageKappa" "', argument " "1"" of type '" "Pythia8::Ropewalk *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Ropewalk * >(argp1);
  result = (double)(arg1)->averageKappa();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Ropewalk_select(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Ropewalk *arg1 = (Pythia8::Ropewalk *) 0 ;
  int arg2 ;
  int arg3 ;
  Pythia8::Rndm *arg4 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  std::pair< int,int > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Ropewalk_select",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Ropewalk, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ropewalk_select" "', argument " "1"" of type '" "Pythia8::Ropewalk *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Ropewalk * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ropewalk_select" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Ropewalk_select" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Ropewalk_select" "', argument " "4"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Rndm * >(argp4);
  result = (arg1)->select(arg2,arg3,arg4);
  resultobj = swig::from(static_cast< std::pair< int,int > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Ropewalk_shoveTheDipoles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Ropewalk *arg1 = (Pythia8::Ropewalk *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Ropewalk_shoveTheDipoles",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Ropewalk, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ropewalk_shoveTheDipoles" "', argument " "1"" of type '" "Pythia8::Ropewalk *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Ropewalk * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ropewalk_shoveTheDipoles" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Ropewalk_shoveTheDipoles" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  (arg1)->shoveTheDipoles(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Ropewalk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Ropewalk *arg1 = (Pythia8::Ropewalk *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Ropewalk",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Ropewalk, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ropewalk" "', argument " "1"" of type '" "Pythia8::Ropewalk *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Ropewalk * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Ropewalk_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Ropewalk, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_RopeFragPars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeFragPars *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_RopeFragPars")) SWIG_fail;
  result = (Pythia8::RopeFragPars *)new Pythia8::RopeFragPars();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__RopeFragPars, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeFragPars_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeFragPars *arg1 = (Pythia8::RopeFragPars *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:RopeFragPars_init",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeFragPars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeFragPars_init" "', argument " "1"" of type '" "Pythia8::RopeFragPars *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeFragPars * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RopeFragPars_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RopeFragPars_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RopeFragPars_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  (arg1)->init(arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_RopeFragPars_getEffectiveParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeFragPars *arg1 = (Pythia8::RopeFragPars *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigValueWrapper< std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:RopeFragPars_getEffectiveParameters",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeFragPars, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RopeFragPars_getEffectiveParameters" "', argument " "1"" of type '" "Pythia8::RopeFragPars *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeFragPars * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RopeFragPars_getEffectiveParameters" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (arg1)->getEffectiveParameters(arg2);
  resultobj = SWIG_NewPointerObj((new std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > >(static_cast< const std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > >& >(result))), SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_RopeFragPars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::RopeFragPars *arg1 = (Pythia8::RopeFragPars *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_RopeFragPars",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__RopeFragPars, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RopeFragPars" "', argument " "1"" of type '" "Pythia8::RopeFragPars *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::RopeFragPars * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *RopeFragPars_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__RopeFragPars, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_FlavourRope(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FlavourRope *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_FlavourRope")) SWIG_fail;
  result = (Pythia8::FlavourRope *)new Pythia8::FlavourRope();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__FlavourRope, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FlavourRope_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FlavourRope *arg1 = (Pythia8::FlavourRope *) 0 ;
  Pythia8::Settings *arg2 = (Pythia8::Settings *) 0 ;
  Pythia8::Rndm *arg3 = (Pythia8::Rndm *) 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Info *arg5 = (Pythia8::Info *) 0 ;
  Pythia8::Ropewalk *arg6 = (Pythia8::Ropewalk *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:FlavourRope_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FlavourRope, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlavourRope_init" "', argument " "1"" of type '" "Pythia8::FlavourRope *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FlavourRope * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FlavourRope_init" "', argument " "2"" of type '" "Pythia8::Settings *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FlavourRope_init" "', argument " "3"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Rndm * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FlavourRope_init" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "FlavourRope_init" "', argument " "5"" of type '" "Pythia8::Info *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Info * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__Ropewalk, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "FlavourRope_init" "', argument " "6"" of type '" "Pythia8::Ropewalk *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::Ropewalk * >(argp6);
  (arg1)->init(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FlavourRope_doChangeFragPar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FlavourRope *arg1 = (Pythia8::FlavourRope *) 0 ;
  Pythia8::StringFlav *arg2 = (Pythia8::StringFlav *) 0 ;
  Pythia8::StringZ *arg3 = (Pythia8::StringZ *) 0 ;
  Pythia8::StringPT *arg4 = (Pythia8::StringPT *) 0 ;
  double arg5 ;
  std::vector< int,std::allocator< int > > arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:FlavourRope_doChangeFragPar",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FlavourRope, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlavourRope_doChangeFragPar" "', argument " "1"" of type '" "Pythia8::FlavourRope *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FlavourRope * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FlavourRope_doChangeFragPar" "', argument " "2"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::StringFlav * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__StringZ, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FlavourRope_doChangeFragPar" "', argument " "3"" of type '" "Pythia8::StringZ *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::StringZ * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__StringPT, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FlavourRope_doChangeFragPar" "', argument " "4"" of type '" "Pythia8::StringPT *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::StringPT * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FlavourRope_doChangeFragPar" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "FlavourRope_doChangeFragPar" "', argument " "6"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "FlavourRope_doChangeFragPar" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  result = (bool)(arg1)->doChangeFragPar(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FlavourRope_setEnhancement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FlavourRope *arg1 = (Pythia8::FlavourRope *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FlavourRope_setEnhancement",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FlavourRope, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlavourRope_setEnhancement" "', argument " "1"" of type '" "Pythia8::FlavourRope *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FlavourRope * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlavourRope_setEnhancement" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setEnhancement(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_FlavourRope_setEventPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FlavourRope *arg1 = (Pythia8::FlavourRope *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:FlavourRope_setEventPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FlavourRope, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlavourRope_setEventPtr" "', argument " "1"" of type '" "Pythia8::FlavourRope *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FlavourRope * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FlavourRope_setEventPtr" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FlavourRope_setEventPtr" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  (arg1)->setEventPtr(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_FlavourRope(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::FlavourRope *arg1 = (Pythia8::FlavourRope *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_FlavourRope",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__FlavourRope, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FlavourRope" "', argument " "1"" of type '" "Pythia8::FlavourRope *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::FlavourRope * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *FlavourRope_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__FlavourRope, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SUSYResonanceWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SUSYResonanceWidths *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SUSYResonanceWidths")) SWIG_fail;
  result = (Pythia8::SUSYResonanceWidths *)new Pythia8::SUSYResonanceWidths();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SUSYResonanceWidths, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SUSYResonanceWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SUSYResonanceWidths *arg1 = (Pythia8::SUSYResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SUSYResonanceWidths",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SUSYResonanceWidths, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SUSYResonanceWidths" "', argument " "1"" of type '" "Pythia8::SUSYResonanceWidths *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SUSYResonanceWidths * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SUSYResonanceWidths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SUSYResonanceWidths, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceSquark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceSquark *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceSquark",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceSquark" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResonanceSquark *)new Pythia8::ResonanceSquark(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceSquark, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceSquark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceSquark *arg1 = (Pythia8::ResonanceSquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceSquark",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceSquark, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceSquark" "', argument " "1"" of type '" "Pythia8::ResonanceSquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceSquark * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceSquark_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceSquark, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceGluino(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceGluino *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceGluino",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceGluino" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResonanceGluino *)new Pythia8::ResonanceGluino(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceGluino, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceGluino(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceGluino *arg1 = (Pythia8::ResonanceGluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceGluino",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceGluino, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceGluino" "', argument " "1"" of type '" "Pythia8::ResonanceGluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceGluino * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceGluino_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceGluino, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceNeut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceNeut *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceNeut",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceNeut" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResonanceNeut *)new Pythia8::ResonanceNeut(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceNeut, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceNeut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceNeut *arg1 = (Pythia8::ResonanceNeut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceNeut",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceNeut, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceNeut" "', argument " "1"" of type '" "Pythia8::ResonanceNeut *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceNeut * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceNeut_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceNeut, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceChar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceChar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceChar",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceChar" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResonanceChar *)new Pythia8::ResonanceChar(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceChar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceChar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceChar *arg1 = (Pythia8::ResonanceChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceChar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceChar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceChar" "', argument " "1"" of type '" "Pythia8::ResonanceChar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceChar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceChar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceChar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResonanceSlepton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResonanceSlepton *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResonanceSlepton",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResonanceSlepton" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResonanceSlepton *)new Pythia8::ResonanceSlepton(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceSlepton, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResonanceSlepton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResonanceSlepton *arg1 = (Pythia8::ResonanceSlepton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResonanceSlepton",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResonanceSlepton, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResonanceSlepton" "', argument " "1"" of type '" "Pythia8::ResonanceSlepton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResonanceSlepton * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResonanceSlepton_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResonanceSlepton, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TauDecays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TauDecays *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TauDecays")) SWIG_fail;
  result = (Pythia8::TauDecays *)new Pythia8::TauDecays();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TauDecays, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TauDecays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TauDecays *arg1 = (Pythia8::TauDecays *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TauDecays",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TauDecays, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TauDecays" "', argument " "1"" of type '" "Pythia8::TauDecays *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TauDecays * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TauDecays_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TauDecays *arg1 = (Pythia8::TauDecays *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = (Pythia8::Settings *) 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  Pythia8::Couplings *arg6 = (Pythia8::Couplings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:TauDecays_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TauDecays, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TauDecays_init" "', argument " "1"" of type '" "Pythia8::TauDecays *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TauDecays * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TauDecays_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TauDecays_init" "', argument " "3"" of type '" "Pythia8::Settings *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TauDecays_init" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TauDecays_init" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TauDecays_init" "', argument " "6"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::Couplings * >(argp6);
  (arg1)->init(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TauDecays_decay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TauDecays *arg1 = (Pythia8::TauDecays *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TauDecays_decay",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TauDecays, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TauDecays_decay" "', argument " "1"" of type '" "Pythia8::TauDecays *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TauDecays * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TauDecays_decay" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TauDecays_decay" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TauDecays_decay" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  result = (bool)(arg1)->decay(arg2,*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TauDecays_internalMechanism(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TauDecays *arg1 = (Pythia8::TauDecays *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TauDecays_internalMechanism",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TauDecays, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TauDecays_internalMechanism" "', argument " "1"" of type '" "Pythia8::TauDecays *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TauDecays * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TauDecays_internalMechanism" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TauDecays_internalMechanism" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->internalMechanism(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TauDecays_externalMechanism(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TauDecays *arg1 = (Pythia8::TauDecays *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TauDecays_externalMechanism",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TauDecays, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TauDecays_externalMechanism" "', argument " "1"" of type '" "Pythia8::TauDecays *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TauDecays * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TauDecays_externalMechanism" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TauDecays_externalMechanism" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->externalMechanism(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TauDecays_createChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TauDecays *arg1 = (Pythia8::TauDecays *) 0 ;
  Pythia8::HelicityParticle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TauDecays_createChildren",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TauDecays, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TauDecays_createChildren" "', argument " "1"" of type '" "Pythia8::TauDecays *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TauDecays * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__HelicityParticle,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TauDecays_createChildren" "', argument " "2"" of type '" "Pythia8::HelicityParticle""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TauDecays_createChildren" "', argument " "2"" of type '" "Pythia8::HelicityParticle""'");
    } else {
      Pythia8::HelicityParticle * temp = reinterpret_cast< Pythia8::HelicityParticle * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (arg1)->createChildren(arg2);
  resultobj = SWIG_NewPointerObj((new std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >(static_cast< const std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >& >(result))), SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TauDecays_isotropicDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TauDecays *arg1 = (Pythia8::TauDecays *) 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TauDecays_isotropicDecay",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TauDecays, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TauDecays_isotropicDecay" "', argument " "1"" of type '" "Pythia8::TauDecays *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TauDecays * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TauDecays_isotropicDecay" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TauDecays_isotropicDecay" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp2);
  (arg1)->isotropicDecay(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TauDecays_writeDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TauDecays *arg1 = (Pythia8::TauDecays *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TauDecays_writeDecay",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TauDecays, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TauDecays_writeDecay" "', argument " "1"" of type '" "Pythia8::TauDecays *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TauDecays * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TauDecays_writeDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TauDecays_writeDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TauDecays_writeDecay" "', argument " "3"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TauDecays_writeDecay" "', argument " "3"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > * >(argp3);
  (arg1)->writeDecay(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TauDecays_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__TauDecays, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sphericity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  int arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Sphericity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Sphericity",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sphericity" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sphericity" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::Sphericity *)new Pythia8::Sphericity(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sphericity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sphericity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sphericity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sphericity",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sphericity" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  result = (Pythia8::Sphericity *)new Pythia8::Sphericity(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sphericity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sphericity__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sphericity *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sphericity")) SWIG_fail;
  result = (Pythia8::Sphericity *)new Pythia8::Sphericity();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sphericity, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sphericity(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Sphericity__SWIG_2(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Sphericity__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Sphericity__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Sphericity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Sphericity::Sphericity(double,int)\n"
    "    Pythia8::Sphericity::Sphericity(double)\n"
    "    Pythia8::Sphericity::Sphericity()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Sphericity_analyze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sphericity *arg1 = (Pythia8::Sphericity *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Sphericity_analyze",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sphericity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sphericity_analyze" "', argument " "1"" of type '" "Pythia8::Sphericity *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sphericity * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sphericity_analyze" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sphericity_analyze" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->analyze((Pythia8::Event const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sphericity_sphericity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sphericity *arg1 = (Pythia8::Sphericity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sphericity_sphericity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sphericity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sphericity_sphericity" "', argument " "1"" of type '" "Pythia8::Sphericity const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sphericity * >(argp1);
  result = (double)((Pythia8::Sphericity const *)arg1)->sphericity();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sphericity_aplanarity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sphericity *arg1 = (Pythia8::Sphericity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sphericity_aplanarity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sphericity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sphericity_aplanarity" "', argument " "1"" of type '" "Pythia8::Sphericity const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sphericity * >(argp1);
  result = (double)((Pythia8::Sphericity const *)arg1)->aplanarity();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sphericity_eigenValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sphericity *arg1 = (Pythia8::Sphericity *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Sphericity_eigenValue",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sphericity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sphericity_eigenValue" "', argument " "1"" of type '" "Pythia8::Sphericity const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sphericity * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sphericity_eigenValue" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::Sphericity const *)arg1)->eigenValue(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sphericity_eventAxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sphericity *arg1 = (Pythia8::Sphericity *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Sphericity_eventAxis",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sphericity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sphericity_eventAxis" "', argument " "1"" of type '" "Pythia8::Sphericity const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sphericity * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sphericity_eventAxis" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((Pythia8::Sphericity const *)arg1)->eventAxis(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sphericity_nError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sphericity *arg1 = (Pythia8::Sphericity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sphericity_nError",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sphericity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sphericity_nError" "', argument " "1"" of type '" "Pythia8::Sphericity const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sphericity * >(argp1);
  result = (int)((Pythia8::Sphericity const *)arg1)->nError();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sphericity___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sphericity *arg1 = (Pythia8::Sphericity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sphericity___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sphericity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sphericity___str__" "', argument " "1"" of type '" "Pythia8::Sphericity *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sphericity * >(argp1);
  result = Pythia8_Sphericity___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sphericity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sphericity *arg1 = (Pythia8::Sphericity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sphericity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sphericity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sphericity" "', argument " "1"" of type '" "Pythia8::Sphericity *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sphericity * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sphericity_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sphericity, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Thrust__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Thrust *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Thrust",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Thrust" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Thrust *)new Pythia8::Thrust(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Thrust, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Thrust__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Thrust *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Thrust")) SWIG_fail;
  result = (Pythia8::Thrust *)new Pythia8::Thrust();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Thrust, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Thrust(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Thrust__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Thrust__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Thrust'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Thrust::Thrust(int)\n"
    "    Pythia8::Thrust::Thrust()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Thrust_analyze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Thrust *arg1 = (Pythia8::Thrust *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Thrust_analyze",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Thrust, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Thrust_analyze" "', argument " "1"" of type '" "Pythia8::Thrust *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Thrust * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Thrust_analyze" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Thrust_analyze" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->analyze((Pythia8::Event const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Thrust_thrust(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Thrust *arg1 = (Pythia8::Thrust *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Thrust_thrust",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Thrust, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Thrust_thrust" "', argument " "1"" of type '" "Pythia8::Thrust const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Thrust * >(argp1);
  result = (double)((Pythia8::Thrust const *)arg1)->thrust();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Thrust_tMajor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Thrust *arg1 = (Pythia8::Thrust *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Thrust_tMajor",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Thrust, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Thrust_tMajor" "', argument " "1"" of type '" "Pythia8::Thrust const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Thrust * >(argp1);
  result = (double)((Pythia8::Thrust const *)arg1)->tMajor();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Thrust_tMinor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Thrust *arg1 = (Pythia8::Thrust *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Thrust_tMinor",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Thrust, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Thrust_tMinor" "', argument " "1"" of type '" "Pythia8::Thrust const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Thrust * >(argp1);
  result = (double)((Pythia8::Thrust const *)arg1)->tMinor();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Thrust_oblateness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Thrust *arg1 = (Pythia8::Thrust *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Thrust_oblateness",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Thrust, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Thrust_oblateness" "', argument " "1"" of type '" "Pythia8::Thrust const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Thrust * >(argp1);
  result = (double)((Pythia8::Thrust const *)arg1)->oblateness();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Thrust_eventAxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Thrust *arg1 = (Pythia8::Thrust *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Thrust_eventAxis",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Thrust, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Thrust_eventAxis" "', argument " "1"" of type '" "Pythia8::Thrust const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Thrust * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Thrust_eventAxis" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((Pythia8::Thrust const *)arg1)->eventAxis(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Thrust_nError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Thrust *arg1 = (Pythia8::Thrust *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Thrust_nError",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Thrust, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Thrust_nError" "', argument " "1"" of type '" "Pythia8::Thrust const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Thrust * >(argp1);
  result = (int)((Pythia8::Thrust const *)arg1)->nError();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Thrust___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Thrust *arg1 = (Pythia8::Thrust *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Thrust___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Thrust, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Thrust___str__" "', argument " "1"" of type '" "Pythia8::Thrust *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Thrust * >(argp1);
  result = Pythia8_Thrust___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Thrust(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Thrust *arg1 = (Pythia8::Thrust *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Thrust",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Thrust, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Thrust" "', argument " "1"" of type '" "Pythia8::Thrust *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Thrust * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Thrust_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Thrust, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SingleClusterJet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 arg1 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::SingleClusterJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_SingleClusterJet",&obj0,&obj1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SingleClusterJet" "', argument " "1"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SingleClusterJet" "', argument " "1"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SingleClusterJet" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::SingleClusterJet *)new Pythia8::SingleClusterJet(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SingleClusterJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SingleClusterJet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::SingleClusterJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SingleClusterJet",&obj0)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SingleClusterJet" "', argument " "1"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SingleClusterJet" "', argument " "1"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = (Pythia8::SingleClusterJet *)new Pythia8::SingleClusterJet(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SingleClusterJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SingleClusterJet__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleClusterJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SingleClusterJet")) SWIG_fail;
  result = (Pythia8::SingleClusterJet *)new Pythia8::SingleClusterJet();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SingleClusterJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SingleClusterJet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_SingleClusterJet__SWIG_2(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SingleClusterJet__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SingleClusterJet__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SingleClusterJet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SingleClusterJet::SingleClusterJet(Pythia8::Vec4,int)\n"
    "    Pythia8::SingleClusterJet::SingleClusterJet(Pythia8::Vec4)\n"
    "    Pythia8::SingleClusterJet::SingleClusterJet()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SingleClusterJet_pJet_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleClusterJet *arg1 = (Pythia8::SingleClusterJet *) 0 ;
  Pythia8::Vec4 *arg2 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleClusterJet_pJet_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleClusterJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleClusterJet_pJet_set" "', argument " "1"" of type '" "Pythia8::SingleClusterJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleClusterJet * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SingleClusterJet_pJet_set" "', argument " "2"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  if (arg1) (arg1)->pJet = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleClusterJet_pJet_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleClusterJet *arg1 = (Pythia8::SingleClusterJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleClusterJet_pJet_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleClusterJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleClusterJet_pJet_get" "', argument " "1"" of type '" "Pythia8::SingleClusterJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleClusterJet * >(argp1);
  result = (Pythia8::Vec4 *)& ((arg1)->pJet);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleClusterJet_mother_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleClusterJet *arg1 = (Pythia8::SingleClusterJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleClusterJet_mother_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleClusterJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleClusterJet_mother_set" "', argument " "1"" of type '" "Pythia8::SingleClusterJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleClusterJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SingleClusterJet_mother_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->mother = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleClusterJet_mother_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleClusterJet *arg1 = (Pythia8::SingleClusterJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleClusterJet_mother_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleClusterJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleClusterJet_mother_get" "', argument " "1"" of type '" "Pythia8::SingleClusterJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleClusterJet * >(argp1);
  result = (int) ((arg1)->mother);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleClusterJet_daughter_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleClusterJet *arg1 = (Pythia8::SingleClusterJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleClusterJet_daughter_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleClusterJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleClusterJet_daughter_set" "', argument " "1"" of type '" "Pythia8::SingleClusterJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleClusterJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SingleClusterJet_daughter_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->daughter = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleClusterJet_daughter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleClusterJet *arg1 = (Pythia8::SingleClusterJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleClusterJet_daughter_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleClusterJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleClusterJet_daughter_get" "', argument " "1"" of type '" "Pythia8::SingleClusterJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleClusterJet * >(argp1);
  result = (int) ((arg1)->daughter);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleClusterJet_multiplicity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleClusterJet *arg1 = (Pythia8::SingleClusterJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleClusterJet_multiplicity_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleClusterJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleClusterJet_multiplicity_set" "', argument " "1"" of type '" "Pythia8::SingleClusterJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleClusterJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SingleClusterJet_multiplicity_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->multiplicity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleClusterJet_multiplicity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleClusterJet *arg1 = (Pythia8::SingleClusterJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleClusterJet_multiplicity_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleClusterJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleClusterJet_multiplicity_get" "', argument " "1"" of type '" "Pythia8::SingleClusterJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleClusterJet * >(argp1);
  result = (int) ((arg1)->multiplicity);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleClusterJet_isAssigned_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleClusterJet *arg1 = (Pythia8::SingleClusterJet *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleClusterJet_isAssigned_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleClusterJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleClusterJet_isAssigned_set" "', argument " "1"" of type '" "Pythia8::SingleClusterJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleClusterJet * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SingleClusterJet_isAssigned_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isAssigned = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleClusterJet_isAssigned_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleClusterJet *arg1 = (Pythia8::SingleClusterJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleClusterJet_isAssigned_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleClusterJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleClusterJet_isAssigned_get" "', argument " "1"" of type '" "Pythia8::SingleClusterJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleClusterJet * >(argp1);
  result = (bool) ((arg1)->isAssigned);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleClusterJet_pAbs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleClusterJet *arg1 = (Pythia8::SingleClusterJet *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleClusterJet_pAbs_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleClusterJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleClusterJet_pAbs_set" "', argument " "1"" of type '" "Pythia8::SingleClusterJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleClusterJet * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SingleClusterJet_pAbs_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pAbs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleClusterJet_pAbs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleClusterJet *arg1 = (Pythia8::SingleClusterJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleClusterJet_pAbs_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleClusterJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleClusterJet_pAbs_get" "', argument " "1"" of type '" "Pythia8::SingleClusterJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleClusterJet * >(argp1);
  result = (double) ((arg1)->pAbs);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleClusterJet_pTemp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleClusterJet *arg1 = (Pythia8::SingleClusterJet *) 0 ;
  Pythia8::Vec4 *arg2 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleClusterJet_pTemp_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleClusterJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleClusterJet_pTemp_set" "', argument " "1"" of type '" "Pythia8::SingleClusterJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleClusterJet * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SingleClusterJet_pTemp_set" "', argument " "2"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  if (arg1) (arg1)->pTemp = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleClusterJet_pTemp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleClusterJet *arg1 = (Pythia8::SingleClusterJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleClusterJet_pTemp_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleClusterJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleClusterJet_pTemp_get" "', argument " "1"" of type '" "Pythia8::SingleClusterJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleClusterJet * >(argp1);
  result = (Pythia8::Vec4 *)& ((arg1)->pTemp);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SingleClusterJet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleClusterJet *arg1 = (Pythia8::SingleClusterJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SingleClusterJet",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleClusterJet, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleClusterJet" "', argument " "1"" of type '" "Pythia8::SingleClusterJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleClusterJet * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SingleClusterJet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SingleClusterJet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_dist2Fun(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  Pythia8::SingleClusterJet *arg2 = 0 ;
  Pythia8::SingleClusterJet *arg3 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:dist2Fun",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dist2Fun" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__SingleClusterJet,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dist2Fun" "', argument " "2"" of type '" "Pythia8::SingleClusterJet const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dist2Fun" "', argument " "2"" of type '" "Pythia8::SingleClusterJet const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::SingleClusterJet * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__SingleClusterJet,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dist2Fun" "', argument " "3"" of type '" "Pythia8::SingleClusterJet const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dist2Fun" "', argument " "3"" of type '" "Pythia8::SingleClusterJet const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::SingleClusterJet * >(argp3);
  result = (double)Pythia8::dist2Fun(arg1,(Pythia8::SingleClusterJet const &)*arg2,(Pythia8::SingleClusterJet const &)*arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClusterJet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  int arg2 ;
  int arg3 ;
  bool arg4 ;
  bool arg5 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::ClusterJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_ClusterJet",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ClusterJet" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClusterJet" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ClusterJet" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ClusterJet" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ClusterJet" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (Pythia8::ClusterJet *)new Pythia8::ClusterJet(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ClusterJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClusterJet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  int arg2 ;
  int arg3 ;
  bool arg4 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::ClusterJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_ClusterJet",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ClusterJet" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClusterJet" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ClusterJet" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ClusterJet" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (Pythia8::ClusterJet *)new Pythia8::ClusterJet(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ClusterJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClusterJet__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  int arg2 ;
  int arg3 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::ClusterJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_ClusterJet",&obj0,&obj1,&obj2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ClusterJet" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClusterJet" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ClusterJet" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::ClusterJet *)new Pythia8::ClusterJet(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ClusterJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClusterJet__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  int arg2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::ClusterJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_ClusterJet",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ClusterJet" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClusterJet" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::ClusterJet *)new Pythia8::ClusterJet(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ClusterJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClusterJet__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  Pythia8::ClusterJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ClusterJet",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ClusterJet" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::ClusterJet *)new Pythia8::ClusterJet(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ClusterJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClusterJet__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ClusterJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ClusterJet")) SWIG_fail;
  result = (Pythia8::ClusterJet *)new Pythia8::ClusterJet();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ClusterJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ClusterJet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_ClusterJet__SWIG_5(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ClusterJet__SWIG_4(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ClusterJet__SWIG_3(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_ClusterJet__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_ClusterJet__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_ClusterJet__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ClusterJet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ClusterJet::ClusterJet(std::string,int,int,bool,bool)\n"
    "    Pythia8::ClusterJet::ClusterJet(std::string,int,int,bool)\n"
    "    Pythia8::ClusterJet::ClusterJet(std::string,int,int)\n"
    "    Pythia8::ClusterJet::ClusterJet(std::string,int)\n"
    "    Pythia8::ClusterJet::ClusterJet(std::string)\n"
    "    Pythia8::ClusterJet::ClusterJet()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ClusterJet_analyze__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ClusterJet *arg1 = (Pythia8::ClusterJet *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ClusterJet_analyze",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ClusterJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterJet_analyze" "', argument " "1"" of type '" "Pythia8::ClusterJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ClusterJet * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ClusterJet_analyze" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ClusterJet_analyze" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ClusterJet_analyze" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ClusterJet_analyze" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ClusterJet_analyze" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ClusterJet_analyze" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (bool)(arg1)->analyze((Pythia8::Event const &)*arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterJet_analyze__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ClusterJet *arg1 = (Pythia8::ClusterJet *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ClusterJet_analyze",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ClusterJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterJet_analyze" "', argument " "1"" of type '" "Pythia8::ClusterJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ClusterJet * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ClusterJet_analyze" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ClusterJet_analyze" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ClusterJet_analyze" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ClusterJet_analyze" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ClusterJet_analyze" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (bool)(arg1)->analyze((Pythia8::Event const &)*arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterJet_analyze__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ClusterJet *arg1 = (Pythia8::ClusterJet *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ClusterJet_analyze",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ClusterJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterJet_analyze" "', argument " "1"" of type '" "Pythia8::ClusterJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ClusterJet * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ClusterJet_analyze" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ClusterJet_analyze" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ClusterJet_analyze" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ClusterJet_analyze" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->analyze((Pythia8::Event const &)*arg2,arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterJet_analyze(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ClusterJet, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ClusterJet_analyze__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ClusterJet, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ClusterJet_analyze__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ClusterJet, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_ClusterJet_analyze__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ClusterJet_analyze'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ClusterJet::analyze(Pythia8::Event const &,double,double,int,int)\n"
    "    Pythia8::ClusterJet::analyze(Pythia8::Event const &,double,double,int)\n"
    "    Pythia8::ClusterJet::analyze(Pythia8::Event const &,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ClusterJet_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ClusterJet *arg1 = (Pythia8::ClusterJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ClusterJet_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ClusterJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterJet_size" "', argument " "1"" of type '" "Pythia8::ClusterJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ClusterJet * >(argp1);
  result = (int)((Pythia8::ClusterJet const *)arg1)->size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterJet_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ClusterJet *arg1 = (Pythia8::ClusterJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ClusterJet_p",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ClusterJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterJet_p" "', argument " "1"" of type '" "Pythia8::ClusterJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ClusterJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ClusterJet_p" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((Pythia8::ClusterJet const *)arg1)->p(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterJet_mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ClusterJet *arg1 = (Pythia8::ClusterJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ClusterJet_mult",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ClusterJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterJet_mult" "', argument " "1"" of type '" "Pythia8::ClusterJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ClusterJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ClusterJet_mult" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::ClusterJet const *)arg1)->mult(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterJet_jetAssignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ClusterJet *arg1 = (Pythia8::ClusterJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ClusterJet_jetAssignment",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ClusterJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterJet_jetAssignment" "', argument " "1"" of type '" "Pythia8::ClusterJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ClusterJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ClusterJet_jetAssignment" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::ClusterJet const *)arg1)->jetAssignment(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterJet_distanceSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ClusterJet *arg1 = (Pythia8::ClusterJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ClusterJet_distanceSize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ClusterJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterJet_distanceSize" "', argument " "1"" of type '" "Pythia8::ClusterJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ClusterJet * >(argp1);
  result = (int)((Pythia8::ClusterJet const *)arg1)->distanceSize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterJet_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ClusterJet *arg1 = (Pythia8::ClusterJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ClusterJet_distance",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ClusterJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterJet_distance" "', argument " "1"" of type '" "Pythia8::ClusterJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ClusterJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ClusterJet_distance" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::ClusterJet const *)arg1)->distance(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterJet_nError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ClusterJet *arg1 = (Pythia8::ClusterJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ClusterJet_nError",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ClusterJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterJet_nError" "', argument " "1"" of type '" "Pythia8::ClusterJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ClusterJet * >(argp1);
  result = (int)((Pythia8::ClusterJet const *)arg1)->nError();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ClusterJet___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ClusterJet *arg1 = (Pythia8::ClusterJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ClusterJet___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ClusterJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClusterJet___str__" "', argument " "1"" of type '" "Pythia8::ClusterJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ClusterJet * >(argp1);
  result = Pythia8_ClusterJet___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ClusterJet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ClusterJet *arg1 = (Pythia8::ClusterJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ClusterJet",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ClusterJet, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClusterJet" "', argument " "1"" of type '" "Pythia8::ClusterJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ClusterJet * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ClusterJet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ClusterJet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SingleCell__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::SingleCell *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_SingleCell",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SingleCell" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SingleCell" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SingleCell" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SingleCell" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SingleCell" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (Pythia8::SingleCell *)new Pythia8::SingleCell(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SingleCell, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SingleCell__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::SingleCell *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_SingleCell",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SingleCell" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SingleCell" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SingleCell" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SingleCell" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (Pythia8::SingleCell *)new Pythia8::SingleCell(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SingleCell, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SingleCell__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::SingleCell *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_SingleCell",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SingleCell" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SingleCell" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SingleCell" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (Pythia8::SingleCell *)new Pythia8::SingleCell(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SingleCell, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SingleCell__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::SingleCell *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_SingleCell",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SingleCell" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SingleCell" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (Pythia8::SingleCell *)new Pythia8::SingleCell(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SingleCell, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SingleCell__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::SingleCell *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SingleCell",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SingleCell" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::SingleCell *)new Pythia8::SingleCell(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SingleCell, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SingleCell__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCell *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SingleCell")) SWIG_fail;
  result = (Pythia8::SingleCell *)new Pythia8::SingleCell();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SingleCell, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SingleCell(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_SingleCell__SWIG_5(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SingleCell__SWIG_4(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SingleCell__SWIG_3(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SingleCell__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SingleCell__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_SingleCell__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SingleCell'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SingleCell::SingleCell(int,double,double,double,int)\n"
    "    Pythia8::SingleCell::SingleCell(int,double,double,double)\n"
    "    Pythia8::SingleCell::SingleCell(int,double,double)\n"
    "    Pythia8::SingleCell::SingleCell(int,double)\n"
    "    Pythia8::SingleCell::SingleCell(int)\n"
    "    Pythia8::SingleCell::SingleCell()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SingleCell_iCell_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCell *arg1 = (Pythia8::SingleCell *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleCell_iCell_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCell_iCell_set" "', argument " "1"" of type '" "Pythia8::SingleCell *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCell * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SingleCell_iCell_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iCell = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCell_iCell_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCell *arg1 = (Pythia8::SingleCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleCell_iCell_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCell_iCell_get" "', argument " "1"" of type '" "Pythia8::SingleCell *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCell * >(argp1);
  result = (int) ((arg1)->iCell);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCell_etaCell_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCell *arg1 = (Pythia8::SingleCell *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleCell_etaCell_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCell_etaCell_set" "', argument " "1"" of type '" "Pythia8::SingleCell *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCell * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SingleCell_etaCell_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->etaCell = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCell_etaCell_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCell *arg1 = (Pythia8::SingleCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleCell_etaCell_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCell_etaCell_get" "', argument " "1"" of type '" "Pythia8::SingleCell *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCell * >(argp1);
  result = (double) ((arg1)->etaCell);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCell_phiCell_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCell *arg1 = (Pythia8::SingleCell *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleCell_phiCell_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCell_phiCell_set" "', argument " "1"" of type '" "Pythia8::SingleCell *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCell * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SingleCell_phiCell_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->phiCell = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCell_phiCell_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCell *arg1 = (Pythia8::SingleCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleCell_phiCell_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCell_phiCell_get" "', argument " "1"" of type '" "Pythia8::SingleCell *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCell * >(argp1);
  result = (double) ((arg1)->phiCell);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCell_eTcell_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCell *arg1 = (Pythia8::SingleCell *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleCell_eTcell_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCell_eTcell_set" "', argument " "1"" of type '" "Pythia8::SingleCell *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCell * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SingleCell_eTcell_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->eTcell = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCell_eTcell_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCell *arg1 = (Pythia8::SingleCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleCell_eTcell_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCell_eTcell_get" "', argument " "1"" of type '" "Pythia8::SingleCell *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCell * >(argp1);
  result = (double) ((arg1)->eTcell);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCell_multiplicity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCell *arg1 = (Pythia8::SingleCell *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleCell_multiplicity_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCell_multiplicity_set" "', argument " "1"" of type '" "Pythia8::SingleCell *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCell * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SingleCell_multiplicity_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->multiplicity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCell_multiplicity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCell *arg1 = (Pythia8::SingleCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleCell_multiplicity_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCell_multiplicity_get" "', argument " "1"" of type '" "Pythia8::SingleCell *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCell * >(argp1);
  result = (int) ((arg1)->multiplicity);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCell_canBeSeed_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCell *arg1 = (Pythia8::SingleCell *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleCell_canBeSeed_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCell_canBeSeed_set" "', argument " "1"" of type '" "Pythia8::SingleCell *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCell * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SingleCell_canBeSeed_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->canBeSeed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCell_canBeSeed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCell *arg1 = (Pythia8::SingleCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleCell_canBeSeed_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCell_canBeSeed_get" "', argument " "1"" of type '" "Pythia8::SingleCell *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCell * >(argp1);
  result = (bool) ((arg1)->canBeSeed);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCell_isUsed_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCell *arg1 = (Pythia8::SingleCell *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleCell_isUsed_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCell_isUsed_set" "', argument " "1"" of type '" "Pythia8::SingleCell *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCell * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SingleCell_isUsed_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isUsed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCell_isUsed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCell *arg1 = (Pythia8::SingleCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleCell_isUsed_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCell_isUsed_get" "', argument " "1"" of type '" "Pythia8::SingleCell *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCell * >(argp1);
  result = (bool) ((arg1)->isUsed);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCell_isAssigned_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCell *arg1 = (Pythia8::SingleCell *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleCell_isAssigned_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCell_isAssigned_set" "', argument " "1"" of type '" "Pythia8::SingleCell *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCell * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SingleCell_isAssigned_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isAssigned = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCell_isAssigned_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCell *arg1 = (Pythia8::SingleCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleCell_isAssigned_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCell, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCell_isAssigned_get" "', argument " "1"" of type '" "Pythia8::SingleCell *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCell * >(argp1);
  result = (bool) ((arg1)->isAssigned);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SingleCell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCell *arg1 = (Pythia8::SingleCell *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SingleCell",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCell, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleCell" "', argument " "1"" of type '" "Pythia8::SingleCell *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCell * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SingleCell_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SingleCell, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SingleCellJet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  Pythia8::Vec4 arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Pythia8::SingleCellJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_SingleCellJet",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SingleCellJet" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SingleCellJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SingleCellJet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SingleCellJet" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SingleCellJet" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SingleCellJet" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SingleCellJet" "', argument " "7"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SingleCellJet" "', argument " "7"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  result = (Pythia8::SingleCellJet *)new Pythia8::SingleCellJet(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SingleCellJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SingleCellJet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::SingleCellJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_SingleCellJet",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SingleCellJet" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SingleCellJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SingleCellJet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SingleCellJet" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SingleCellJet" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SingleCellJet" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (Pythia8::SingleCellJet *)new Pythia8::SingleCellJet(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SingleCellJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SingleCellJet__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::SingleCellJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_SingleCellJet",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SingleCellJet" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SingleCellJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SingleCellJet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SingleCellJet" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SingleCellJet" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (Pythia8::SingleCellJet *)new Pythia8::SingleCellJet(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SingleCellJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SingleCellJet__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::SingleCellJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_SingleCellJet",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SingleCellJet" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SingleCellJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SingleCellJet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SingleCellJet" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (Pythia8::SingleCellJet *)new Pythia8::SingleCellJet(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SingleCellJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SingleCellJet__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::SingleCellJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_SingleCellJet",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SingleCellJet" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SingleCellJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SingleCellJet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (Pythia8::SingleCellJet *)new Pythia8::SingleCellJet(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SingleCellJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SingleCellJet__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::SingleCellJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_SingleCellJet",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SingleCellJet" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SingleCellJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (Pythia8::SingleCellJet *)new Pythia8::SingleCellJet(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SingleCellJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SingleCellJet__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::SingleCellJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SingleCellJet",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SingleCellJet" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  result = (Pythia8::SingleCellJet *)new Pythia8::SingleCellJet(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SingleCellJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SingleCellJet__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCellJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SingleCellJet")) SWIG_fail;
  result = (Pythia8::SingleCellJet *)new Pythia8::SingleCellJet();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SingleCellJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SingleCellJet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_SingleCellJet__SWIG_7(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SingleCellJet__SWIG_6(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SingleCellJet__SWIG_5(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SingleCellJet__SWIG_4(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SingleCellJet__SWIG_3(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_SingleCellJet__SWIG_2(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_SingleCellJet__SWIG_1(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_SingleCellJet__SWIG_0(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SingleCellJet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SingleCellJet::SingleCellJet(double,double,double,double,double,int,Pythia8::Vec4)\n"
    "    Pythia8::SingleCellJet::SingleCellJet(double,double,double,double,double,int)\n"
    "    Pythia8::SingleCellJet::SingleCellJet(double,double,double,double,double)\n"
    "    Pythia8::SingleCellJet::SingleCellJet(double,double,double,double)\n"
    "    Pythia8::SingleCellJet::SingleCellJet(double,double,double)\n"
    "    Pythia8::SingleCellJet::SingleCellJet(double,double)\n"
    "    Pythia8::SingleCellJet::SingleCellJet(double)\n"
    "    Pythia8::SingleCellJet::SingleCellJet()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SingleCellJet_eTjet_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCellJet *arg1 = (Pythia8::SingleCellJet *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleCellJet_eTjet_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCellJet_eTjet_set" "', argument " "1"" of type '" "Pythia8::SingleCellJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCellJet * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SingleCellJet_eTjet_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->eTjet = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCellJet_eTjet_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCellJet *arg1 = (Pythia8::SingleCellJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleCellJet_eTjet_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCellJet_eTjet_get" "', argument " "1"" of type '" "Pythia8::SingleCellJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCellJet * >(argp1);
  result = (double) ((arg1)->eTjet);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCellJet_etaCenter_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCellJet *arg1 = (Pythia8::SingleCellJet *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleCellJet_etaCenter_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCellJet_etaCenter_set" "', argument " "1"" of type '" "Pythia8::SingleCellJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCellJet * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SingleCellJet_etaCenter_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->etaCenter = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCellJet_etaCenter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCellJet *arg1 = (Pythia8::SingleCellJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleCellJet_etaCenter_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCellJet_etaCenter_get" "', argument " "1"" of type '" "Pythia8::SingleCellJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCellJet * >(argp1);
  result = (double) ((arg1)->etaCenter);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCellJet_phiCenter_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCellJet *arg1 = (Pythia8::SingleCellJet *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleCellJet_phiCenter_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCellJet_phiCenter_set" "', argument " "1"" of type '" "Pythia8::SingleCellJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCellJet * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SingleCellJet_phiCenter_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->phiCenter = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCellJet_phiCenter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCellJet *arg1 = (Pythia8::SingleCellJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleCellJet_phiCenter_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCellJet_phiCenter_get" "', argument " "1"" of type '" "Pythia8::SingleCellJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCellJet * >(argp1);
  result = (double) ((arg1)->phiCenter);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCellJet_etaWeighted_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCellJet *arg1 = (Pythia8::SingleCellJet *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleCellJet_etaWeighted_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCellJet_etaWeighted_set" "', argument " "1"" of type '" "Pythia8::SingleCellJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCellJet * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SingleCellJet_etaWeighted_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->etaWeighted = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCellJet_etaWeighted_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCellJet *arg1 = (Pythia8::SingleCellJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleCellJet_etaWeighted_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCellJet_etaWeighted_get" "', argument " "1"" of type '" "Pythia8::SingleCellJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCellJet * >(argp1);
  result = (double) ((arg1)->etaWeighted);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCellJet_phiWeighted_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCellJet *arg1 = (Pythia8::SingleCellJet *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleCellJet_phiWeighted_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCellJet_phiWeighted_set" "', argument " "1"" of type '" "Pythia8::SingleCellJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCellJet * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SingleCellJet_phiWeighted_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->phiWeighted = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCellJet_phiWeighted_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCellJet *arg1 = (Pythia8::SingleCellJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleCellJet_phiWeighted_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCellJet_phiWeighted_get" "', argument " "1"" of type '" "Pythia8::SingleCellJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCellJet * >(argp1);
  result = (double) ((arg1)->phiWeighted);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCellJet_multiplicity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCellJet *arg1 = (Pythia8::SingleCellJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleCellJet_multiplicity_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCellJet_multiplicity_set" "', argument " "1"" of type '" "Pythia8::SingleCellJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCellJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SingleCellJet_multiplicity_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->multiplicity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCellJet_multiplicity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCellJet *arg1 = (Pythia8::SingleCellJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleCellJet_multiplicity_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCellJet_multiplicity_get" "', argument " "1"" of type '" "Pythia8::SingleCellJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCellJet * >(argp1);
  result = (int) ((arg1)->multiplicity);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCellJet_pMassive_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCellJet *arg1 = (Pythia8::SingleCellJet *) 0 ;
  Pythia8::Vec4 *arg2 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleCellJet_pMassive_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCellJet_pMassive_set" "', argument " "1"" of type '" "Pythia8::SingleCellJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCellJet * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SingleCellJet_pMassive_set" "', argument " "2"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  if (arg1) (arg1)->pMassive = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleCellJet_pMassive_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCellJet *arg1 = (Pythia8::SingleCellJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleCellJet_pMassive_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleCellJet_pMassive_get" "', argument " "1"" of type '" "Pythia8::SingleCellJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCellJet * >(argp1);
  result = (Pythia8::Vec4 *)& ((arg1)->pMassive);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SingleCellJet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleCellJet *arg1 = (Pythia8::SingleCellJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SingleCellJet",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleCellJet, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleCellJet" "', argument " "1"" of type '" "Pythia8::SingleCellJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleCellJet * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SingleCellJet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SingleCellJet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CellJet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  Pythia8::Rndm *arg9 = (Pythia8::Rndm *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  Pythia8::CellJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_CellJet",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CellJet" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CellJet" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CellJet" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CellJet" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CellJet" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CellJet" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CellJet" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CellJet" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_CellJet" "', argument " "9"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::Rndm * >(argp9);
  result = (Pythia8::CellJet *)new Pythia8::CellJet(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CellJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CellJet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  Pythia8::CellJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:new_CellJet",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CellJet" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CellJet" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CellJet" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CellJet" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CellJet" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CellJet" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CellJet" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_CellJet" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  result = (Pythia8::CellJet *)new Pythia8::CellJet(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CellJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CellJet__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Pythia8::CellJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_CellJet",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CellJet" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CellJet" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CellJet" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CellJet" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CellJet" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CellJet" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_CellJet" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (Pythia8::CellJet *)new Pythia8::CellJet(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CellJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CellJet__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::CellJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_CellJet",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CellJet" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CellJet" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CellJet" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CellJet" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CellJet" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_CellJet" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (Pythia8::CellJet *)new Pythia8::CellJet(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CellJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CellJet__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::CellJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_CellJet",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CellJet" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CellJet" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CellJet" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CellJet" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_CellJet" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (Pythia8::CellJet *)new Pythia8::CellJet(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CellJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CellJet__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::CellJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_CellJet",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CellJet" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CellJet" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CellJet" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_CellJet" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (Pythia8::CellJet *)new Pythia8::CellJet(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CellJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CellJet__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  int arg2 ;
  int arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::CellJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_CellJet",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CellJet" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CellJet" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_CellJet" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::CellJet *)new Pythia8::CellJet(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CellJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CellJet__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  int arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::CellJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_CellJet",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CellJet" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CellJet" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::CellJet *)new Pythia8::CellJet(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CellJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CellJet__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::CellJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_CellJet",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CellJet" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  result = (Pythia8::CellJet *)new Pythia8::CellJet(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CellJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CellJet__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CellJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CellJet")) SWIG_fail;
  result = (Pythia8::CellJet *)new Pythia8::CellJet();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CellJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CellJet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 9) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_CellJet__SWIG_9(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_CellJet__SWIG_8(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_CellJet__SWIG_7(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_CellJet__SWIG_6(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_CellJet__SWIG_5(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_CellJet__SWIG_4(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_CellJet__SWIG_3(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_CellJet__SWIG_2(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_CellJet__SWIG_1(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_Pythia8__Rndm, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_new_CellJet__SWIG_0(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CellJet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::CellJet::CellJet(double,int,int,int,int,double,double,double,Pythia8::Rndm *)\n"
    "    Pythia8::CellJet::CellJet(double,int,int,int,int,double,double,double)\n"
    "    Pythia8::CellJet::CellJet(double,int,int,int,int,double,double)\n"
    "    Pythia8::CellJet::CellJet(double,int,int,int,int,double)\n"
    "    Pythia8::CellJet::CellJet(double,int,int,int,int)\n"
    "    Pythia8::CellJet::CellJet(double,int,int,int)\n"
    "    Pythia8::CellJet::CellJet(double,int,int)\n"
    "    Pythia8::CellJet::CellJet(double,int)\n"
    "    Pythia8::CellJet::CellJet(double)\n"
    "    Pythia8::CellJet::CellJet()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CellJet_analyze__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CellJet *arg1 = (Pythia8::CellJet *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:CellJet_analyze",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CellJet_analyze" "', argument " "1"" of type '" "Pythia8::CellJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CellJet * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CellJet_analyze" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CellJet_analyze" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CellJet_analyze" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CellJet_analyze" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "CellJet_analyze" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (bool)(arg1)->analyze((Pythia8::Event const &)*arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CellJet_analyze__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CellJet *arg1 = (Pythia8::CellJet *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:CellJet_analyze",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CellJet_analyze" "', argument " "1"" of type '" "Pythia8::CellJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CellJet * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CellJet_analyze" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CellJet_analyze" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CellJet_analyze" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "CellJet_analyze" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->analyze((Pythia8::Event const &)*arg2,arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CellJet_analyze__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CellJet *arg1 = (Pythia8::CellJet *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:CellJet_analyze",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CellJet_analyze" "', argument " "1"" of type '" "Pythia8::CellJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CellJet * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CellJet_analyze" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CellJet_analyze" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CellJet_analyze" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (bool)(arg1)->analyze((Pythia8::Event const &)*arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CellJet_analyze__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CellJet *arg1 = (Pythia8::CellJet *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CellJet_analyze",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CellJet_analyze" "', argument " "1"" of type '" "Pythia8::CellJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CellJet * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CellJet_analyze" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CellJet_analyze" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->analyze((Pythia8::Event const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CellJet_analyze(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__CellJet, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_CellJet_analyze__SWIG_3(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__CellJet, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CellJet_analyze__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__CellJet, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_CellJet_analyze__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__CellJet, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_CellJet_analyze__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'CellJet_analyze'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::CellJet::analyze(Pythia8::Event const &,double,double,double)\n"
    "    Pythia8::CellJet::analyze(Pythia8::Event const &,double,double)\n"
    "    Pythia8::CellJet::analyze(Pythia8::Event const &,double)\n"
    "    Pythia8::CellJet::analyze(Pythia8::Event const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CellJet_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CellJet *arg1 = (Pythia8::CellJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CellJet_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CellJet_size" "', argument " "1"" of type '" "Pythia8::CellJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CellJet * >(argp1);
  result = (int)((Pythia8::CellJet const *)arg1)->size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CellJet_eT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CellJet *arg1 = (Pythia8::CellJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CellJet_eT",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CellJet_eT" "', argument " "1"" of type '" "Pythia8::CellJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CellJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CellJet_eT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::CellJet const *)arg1)->eT(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CellJet_etaCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CellJet *arg1 = (Pythia8::CellJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CellJet_etaCenter",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CellJet_etaCenter" "', argument " "1"" of type '" "Pythia8::CellJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CellJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CellJet_etaCenter" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::CellJet const *)arg1)->etaCenter(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CellJet_phiCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CellJet *arg1 = (Pythia8::CellJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CellJet_phiCenter",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CellJet_phiCenter" "', argument " "1"" of type '" "Pythia8::CellJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CellJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CellJet_phiCenter" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::CellJet const *)arg1)->phiCenter(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CellJet_etaWeighted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CellJet *arg1 = (Pythia8::CellJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CellJet_etaWeighted",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CellJet_etaWeighted" "', argument " "1"" of type '" "Pythia8::CellJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CellJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CellJet_etaWeighted" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::CellJet const *)arg1)->etaWeighted(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CellJet_phiWeighted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CellJet *arg1 = (Pythia8::CellJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CellJet_phiWeighted",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CellJet_phiWeighted" "', argument " "1"" of type '" "Pythia8::CellJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CellJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CellJet_phiWeighted" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::CellJet const *)arg1)->phiWeighted(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CellJet_multiplicity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CellJet *arg1 = (Pythia8::CellJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CellJet_multiplicity",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CellJet_multiplicity" "', argument " "1"" of type '" "Pythia8::CellJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CellJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CellJet_multiplicity" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::CellJet const *)arg1)->multiplicity(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CellJet_pMassless(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CellJet *arg1 = (Pythia8::CellJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CellJet_pMassless",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CellJet_pMassless" "', argument " "1"" of type '" "Pythia8::CellJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CellJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CellJet_pMassless" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((Pythia8::CellJet const *)arg1)->pMassless(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CellJet_pMassive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CellJet *arg1 = (Pythia8::CellJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CellJet_pMassive",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CellJet_pMassive" "', argument " "1"" of type '" "Pythia8::CellJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CellJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CellJet_pMassive" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((Pythia8::CellJet const *)arg1)->pMassive(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CellJet_m(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CellJet *arg1 = (Pythia8::CellJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CellJet_m",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CellJet_m" "', argument " "1"" of type '" "Pythia8::CellJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CellJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CellJet_m" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::CellJet const *)arg1)->m(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CellJet_nError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CellJet *arg1 = (Pythia8::CellJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CellJet_nError",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CellJet_nError" "', argument " "1"" of type '" "Pythia8::CellJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CellJet * >(argp1);
  result = (int)((Pythia8::CellJet const *)arg1)->nError();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CellJet___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CellJet *arg1 = (Pythia8::CellJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:CellJet___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CellJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CellJet___str__" "', argument " "1"" of type '" "Pythia8::CellJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CellJet * >(argp1);
  result = Pythia8_CellJet___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CellJet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CellJet *arg1 = (Pythia8::CellJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CellJet",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CellJet, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CellJet" "', argument " "1"" of type '" "Pythia8::CellJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CellJet * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CellJet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__CellJet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_SlowJetHook(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SlowJetHook *arg1 = (Pythia8::SlowJetHook *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SlowJetHook",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SlowJetHook, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SlowJetHook" "', argument " "1"" of type '" "Pythia8::SlowJetHook *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SlowJetHook * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SlowJetHook_include(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SlowJetHook *arg1 = (Pythia8::SlowJetHook *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  Pythia8::Vec4 *arg4 = 0 ;
  double *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SlowJetHook_include",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SlowJetHook, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SlowJetHook_include" "', argument " "1"" of type '" "Pythia8::SlowJetHook *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SlowJetHook * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SlowJetHook_include" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SlowJetHook_include" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SlowJetHook_include" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Vec4,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SlowJetHook_include" "', argument " "4"" of type '" "Pythia8::Vec4 &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SlowJetHook_include" "', argument " "4"" of type '" "Pythia8::Vec4 &""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Vec4 * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SlowJetHook_include" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SlowJetHook_include" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  result = (bool)(arg1)->include(arg2,(Pythia8::Event const &)*arg3,*arg4,*arg5);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SlowJetHook_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SlowJetHook, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SingleSlowJet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::SingleSlowJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_SingleSlowJet",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SingleSlowJet" "', argument " "1"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SingleSlowJet" "', argument " "1"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SingleSlowJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SingleSlowJet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SingleSlowJet" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SingleSlowJet" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (Pythia8::SingleSlowJet *)new Pythia8::SingleSlowJet(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SingleSlowJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SingleSlowJet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::SingleSlowJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_SingleSlowJet",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SingleSlowJet" "', argument " "1"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SingleSlowJet" "', argument " "1"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SingleSlowJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SingleSlowJet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SingleSlowJet" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (Pythia8::SingleSlowJet *)new Pythia8::SingleSlowJet(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SingleSlowJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SingleSlowJet__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 arg1 ;
  double arg2 ;
  double arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::SingleSlowJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_SingleSlowJet",&obj0,&obj1,&obj2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SingleSlowJet" "', argument " "1"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SingleSlowJet" "', argument " "1"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SingleSlowJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SingleSlowJet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (Pythia8::SingleSlowJet *)new Pythia8::SingleSlowJet(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SingleSlowJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SingleSlowJet__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 arg1 ;
  double arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::SingleSlowJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_SingleSlowJet",&obj0,&obj1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SingleSlowJet" "', argument " "1"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SingleSlowJet" "', argument " "1"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SingleSlowJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (Pythia8::SingleSlowJet *)new Pythia8::SingleSlowJet(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SingleSlowJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SingleSlowJet__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::SingleSlowJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SingleSlowJet",&obj0)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SingleSlowJet" "', argument " "1"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SingleSlowJet" "', argument " "1"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  result = (Pythia8::SingleSlowJet *)new Pythia8::SingleSlowJet(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SingleSlowJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SingleSlowJet__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleSlowJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SingleSlowJet")) SWIG_fail;
  result = (Pythia8::SingleSlowJet *)new Pythia8::SingleSlowJet();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SingleSlowJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SingleSlowJet__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleSlowJet *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::SingleSlowJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SingleSlowJet",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__SingleSlowJet,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SingleSlowJet" "', argument " "1"" of type '" "Pythia8::SingleSlowJet const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SingleSlowJet" "', argument " "1"" of type '" "Pythia8::SingleSlowJet const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleSlowJet * >(argp1);
  result = (Pythia8::SingleSlowJet *)new Pythia8::SingleSlowJet((Pythia8::SingleSlowJet const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SingleSlowJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SingleSlowJet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_SingleSlowJet__SWIG_5(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SingleSlowJet__SWIG_4(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__SingleSlowJet, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SingleSlowJet__SWIG_6(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SingleSlowJet__SWIG_3(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SingleSlowJet__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SingleSlowJet__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_SingleSlowJet__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SingleSlowJet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SingleSlowJet::SingleSlowJet(Pythia8::Vec4,double,double,double,int)\n"
    "    Pythia8::SingleSlowJet::SingleSlowJet(Pythia8::Vec4,double,double,double)\n"
    "    Pythia8::SingleSlowJet::SingleSlowJet(Pythia8::Vec4,double,double)\n"
    "    Pythia8::SingleSlowJet::SingleSlowJet(Pythia8::Vec4,double)\n"
    "    Pythia8::SingleSlowJet::SingleSlowJet(Pythia8::Vec4)\n"
    "    Pythia8::SingleSlowJet::SingleSlowJet()\n"
    "    Pythia8::SingleSlowJet::SingleSlowJet(Pythia8::SingleSlowJet const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SingleSlowJet_p_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleSlowJet *arg1 = (Pythia8::SingleSlowJet *) 0 ;
  Pythia8::Vec4 *arg2 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleSlowJet_p_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleSlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleSlowJet_p_set" "', argument " "1"" of type '" "Pythia8::SingleSlowJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleSlowJet * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SingleSlowJet_p_set" "', argument " "2"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  if (arg1) (arg1)->p = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleSlowJet_p_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleSlowJet *arg1 = (Pythia8::SingleSlowJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleSlowJet_p_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleSlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleSlowJet_p_get" "', argument " "1"" of type '" "Pythia8::SingleSlowJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleSlowJet * >(argp1);
  result = (Pythia8::Vec4 *)& ((arg1)->p);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleSlowJet_pT2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleSlowJet *arg1 = (Pythia8::SingleSlowJet *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleSlowJet_pT2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleSlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleSlowJet_pT2_set" "', argument " "1"" of type '" "Pythia8::SingleSlowJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleSlowJet * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SingleSlowJet_pT2_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pT2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleSlowJet_pT2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleSlowJet *arg1 = (Pythia8::SingleSlowJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleSlowJet_pT2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleSlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleSlowJet_pT2_get" "', argument " "1"" of type '" "Pythia8::SingleSlowJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleSlowJet * >(argp1);
  result = (double) ((arg1)->pT2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleSlowJet_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleSlowJet *arg1 = (Pythia8::SingleSlowJet *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleSlowJet_y_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleSlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleSlowJet_y_set" "', argument " "1"" of type '" "Pythia8::SingleSlowJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleSlowJet * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SingleSlowJet_y_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->y = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleSlowJet_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleSlowJet *arg1 = (Pythia8::SingleSlowJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleSlowJet_y_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleSlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleSlowJet_y_get" "', argument " "1"" of type '" "Pythia8::SingleSlowJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleSlowJet * >(argp1);
  result = (double) ((arg1)->y);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleSlowJet_phi_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleSlowJet *arg1 = (Pythia8::SingleSlowJet *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleSlowJet_phi_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleSlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleSlowJet_phi_set" "', argument " "1"" of type '" "Pythia8::SingleSlowJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleSlowJet * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SingleSlowJet_phi_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->phi = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleSlowJet_phi_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleSlowJet *arg1 = (Pythia8::SingleSlowJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleSlowJet_phi_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleSlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleSlowJet_phi_get" "', argument " "1"" of type '" "Pythia8::SingleSlowJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleSlowJet * >(argp1);
  result = (double) ((arg1)->phi);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleSlowJet_mult_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleSlowJet *arg1 = (Pythia8::SingleSlowJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleSlowJet_mult_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleSlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleSlowJet_mult_set" "', argument " "1"" of type '" "Pythia8::SingleSlowJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleSlowJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SingleSlowJet_mult_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->mult = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleSlowJet_mult_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleSlowJet *arg1 = (Pythia8::SingleSlowJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleSlowJet_mult_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleSlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleSlowJet_mult_get" "', argument " "1"" of type '" "Pythia8::SingleSlowJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleSlowJet * >(argp1);
  result = (int) ((arg1)->mult);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleSlowJet_idx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleSlowJet *arg1 = (Pythia8::SingleSlowJet *) 0 ;
  std::set< int,std::less< int >,std::allocator< int > > *arg2 = (std::set< int,std::less< int >,std::allocator< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SingleSlowJet_idx_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleSlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleSlowJet_idx_set" "', argument " "1"" of type '" "Pythia8::SingleSlowJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleSlowJet * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__setT_int_std__lessT_int_t_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SingleSlowJet_idx_set" "', argument " "2"" of type '" "std::set< int,std::less< int >,std::allocator< int > > *""'"); 
  }
  arg2 = reinterpret_cast< std::set< int,std::less< int >,std::allocator< int > > * >(argp2);
  if (arg1) (arg1)->idx = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SingleSlowJet_idx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleSlowJet *arg1 = (Pythia8::SingleSlowJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::set< int,std::less< int >,std::allocator< int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SingleSlowJet_idx_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleSlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleSlowJet_idx_get" "', argument " "1"" of type '" "Pythia8::SingleSlowJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleSlowJet * >(argp1);
  result = (std::set< int,std::less< int >,std::allocator< int > > *)& ((arg1)->idx);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setT_int_std__lessT_int_t_std__allocatorT_int_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SingleSlowJet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SingleSlowJet *arg1 = (Pythia8::SingleSlowJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SingleSlowJet",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SingleSlowJet, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleSlowJet" "', argument " "1"" of type '" "Pythia8::SingleSlowJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SingleSlowJet * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SingleSlowJet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SingleSlowJet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SlowJet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  int arg6 ;
  Pythia8::SlowJetHook *arg7 = (Pythia8::SlowJetHook *) 0 ;
  bool arg8 ;
  bool arg9 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  Pythia8::SlowJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_SlowJet",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SlowJet" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SlowJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SlowJet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SlowJet" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SlowJet" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SlowJet" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__SlowJetHook, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SlowJet" "', argument " "7"" of type '" "Pythia8::SlowJetHook *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::SlowJetHook * >(argp7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SlowJet" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SlowJet" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  result = (Pythia8::SlowJet *)new Pythia8::SlowJet(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SlowJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SlowJet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  int arg6 ;
  Pythia8::SlowJetHook *arg7 = (Pythia8::SlowJetHook *) 0 ;
  bool arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  Pythia8::SlowJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:new_SlowJet",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SlowJet" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SlowJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SlowJet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SlowJet" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SlowJet" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SlowJet" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__SlowJetHook, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SlowJet" "', argument " "7"" of type '" "Pythia8::SlowJetHook *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::SlowJetHook * >(argp7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SlowJet" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  result = (Pythia8::SlowJet *)new Pythia8::SlowJet(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SlowJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SlowJet__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  int arg6 ;
  Pythia8::SlowJetHook *arg7 = (Pythia8::SlowJetHook *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Pythia8::SlowJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_SlowJet",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SlowJet" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SlowJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SlowJet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SlowJet" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SlowJet" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SlowJet" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__SlowJetHook, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_SlowJet" "', argument " "7"" of type '" "Pythia8::SlowJetHook *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::SlowJetHook * >(argp7);
  result = (Pythia8::SlowJet *)new Pythia8::SlowJet(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SlowJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SlowJet__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  int arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::SlowJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_SlowJet",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SlowJet" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SlowJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SlowJet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SlowJet" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SlowJet" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SlowJet" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (Pythia8::SlowJet *)new Pythia8::SlowJet(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SlowJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SlowJet__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::SlowJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_SlowJet",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SlowJet" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SlowJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SlowJet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SlowJet" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SlowJet" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (Pythia8::SlowJet *)new Pythia8::SlowJet(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SlowJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SlowJet__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::SlowJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_SlowJet",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SlowJet" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SlowJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SlowJet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SlowJet" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (Pythia8::SlowJet *)new Pythia8::SlowJet(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SlowJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SlowJet__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::SlowJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_SlowJet",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SlowJet" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SlowJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SlowJet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (Pythia8::SlowJet *)new Pythia8::SlowJet(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SlowJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SlowJet__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::SlowJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_SlowJet",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SlowJet" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SlowJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (Pythia8::SlowJet *)new Pythia8::SlowJet(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SlowJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SlowJet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 9) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SlowJet__SWIG_7(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SlowJet__SWIG_6(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SlowJet__SWIG_5(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_SlowJet__SWIG_4(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_SlowJet__SWIG_3(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__SlowJetHook, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_SlowJet__SWIG_2(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__SlowJetHook, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_SlowJet__SWIG_1(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__SlowJetHook, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_SlowJet__SWIG_0(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SlowJet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SlowJet::SlowJet(int,double,double,double,int,int,Pythia8::SlowJetHook *,bool,bool)\n"
    "    Pythia8::SlowJet::SlowJet(int,double,double,double,int,int,Pythia8::SlowJetHook *,bool)\n"
    "    Pythia8::SlowJet::SlowJet(int,double,double,double,int,int,Pythia8::SlowJetHook *)\n"
    "    Pythia8::SlowJet::SlowJet(int,double,double,double,int,int)\n"
    "    Pythia8::SlowJet::SlowJet(int,double,double,double,int)\n"
    "    Pythia8::SlowJet::SlowJet(int,double,double,double)\n"
    "    Pythia8::SlowJet::SlowJet(int,double,double)\n"
    "    Pythia8::SlowJet::SlowJet(int,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SlowJet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SlowJet *arg1 = (Pythia8::SlowJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SlowJet",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SlowJet, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SlowJet" "', argument " "1"" of type '" "Pythia8::SlowJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SlowJet * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SlowJet_analyze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SlowJet *arg1 = (Pythia8::SlowJet *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SlowJet_analyze",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SlowJet_analyze" "', argument " "1"" of type '" "Pythia8::SlowJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SlowJet * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SlowJet_analyze" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SlowJet_analyze" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->analyze((Pythia8::Event const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SlowJet_setup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SlowJet *arg1 = (Pythia8::SlowJet *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SlowJet_setup",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SlowJet_setup" "', argument " "1"" of type '" "Pythia8::SlowJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SlowJet * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SlowJet_setup" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SlowJet_setup" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->setup((Pythia8::Event const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SlowJet_doStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SlowJet *arg1 = (Pythia8::SlowJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SlowJet_doStep",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SlowJet_doStep" "', argument " "1"" of type '" "Pythia8::SlowJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SlowJet * >(argp1);
  result = (bool)(arg1)->doStep();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SlowJet_doNSteps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SlowJet *arg1 = (Pythia8::SlowJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SlowJet_doNSteps",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SlowJet_doNSteps" "', argument " "1"" of type '" "Pythia8::SlowJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SlowJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SlowJet_doNSteps" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->doNSteps(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SlowJet_stopAtN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SlowJet *arg1 = (Pythia8::SlowJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SlowJet_stopAtN",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SlowJet_stopAtN" "', argument " "1"" of type '" "Pythia8::SlowJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SlowJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SlowJet_stopAtN" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->stopAtN(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SlowJet_sizeOrig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SlowJet *arg1 = (Pythia8::SlowJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SlowJet_sizeOrig",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SlowJet_sizeOrig" "', argument " "1"" of type '" "Pythia8::SlowJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SlowJet * >(argp1);
  result = (int)((Pythia8::SlowJet const *)arg1)->sizeOrig();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SlowJet_sizeJet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SlowJet *arg1 = (Pythia8::SlowJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SlowJet_sizeJet",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SlowJet_sizeJet" "', argument " "1"" of type '" "Pythia8::SlowJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SlowJet * >(argp1);
  result = (int)((Pythia8::SlowJet const *)arg1)->sizeJet();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SlowJet_sizeAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SlowJet *arg1 = (Pythia8::SlowJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SlowJet_sizeAll",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SlowJet_sizeAll" "', argument " "1"" of type '" "Pythia8::SlowJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SlowJet * >(argp1);
  result = (int)((Pythia8::SlowJet const *)arg1)->sizeAll();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SlowJet_pT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SlowJet *arg1 = (Pythia8::SlowJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SlowJet_pT",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SlowJet_pT" "', argument " "1"" of type '" "Pythia8::SlowJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SlowJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SlowJet_pT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::SlowJet const *)arg1)->pT(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SlowJet_y(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SlowJet *arg1 = (Pythia8::SlowJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SlowJet_y",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SlowJet_y" "', argument " "1"" of type '" "Pythia8::SlowJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SlowJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SlowJet_y" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::SlowJet const *)arg1)->y(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SlowJet_phi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SlowJet *arg1 = (Pythia8::SlowJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SlowJet_phi",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SlowJet_phi" "', argument " "1"" of type '" "Pythia8::SlowJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SlowJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SlowJet_phi" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::SlowJet const *)arg1)->phi(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SlowJet_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SlowJet *arg1 = (Pythia8::SlowJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SlowJet_p",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SlowJet_p" "', argument " "1"" of type '" "Pythia8::SlowJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SlowJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SlowJet_p" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((Pythia8::SlowJet const *)arg1)->p(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SlowJet_m(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SlowJet *arg1 = (Pythia8::SlowJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SlowJet_m",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SlowJet_m" "', argument " "1"" of type '" "Pythia8::SlowJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SlowJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SlowJet_m" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::SlowJet const *)arg1)->m(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SlowJet_multiplicity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SlowJet *arg1 = (Pythia8::SlowJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SlowJet_multiplicity",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SlowJet_multiplicity" "', argument " "1"" of type '" "Pythia8::SlowJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SlowJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SlowJet_multiplicity" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::SlowJet const *)arg1)->multiplicity(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SlowJet_iNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SlowJet *arg1 = (Pythia8::SlowJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SlowJet_iNext",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SlowJet_iNext" "', argument " "1"" of type '" "Pythia8::SlowJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SlowJet * >(argp1);
  result = (int)((Pythia8::SlowJet const *)arg1)->iNext();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SlowJet_jNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SlowJet *arg1 = (Pythia8::SlowJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SlowJet_jNext",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SlowJet_jNext" "', argument " "1"" of type '" "Pythia8::SlowJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SlowJet * >(argp1);
  result = (int)((Pythia8::SlowJet const *)arg1)->jNext();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SlowJet_dNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SlowJet *arg1 = (Pythia8::SlowJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SlowJet_dNext",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SlowJet_dNext" "', argument " "1"" of type '" "Pythia8::SlowJet const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SlowJet * >(argp1);
  result = (double)((Pythia8::SlowJet const *)arg1)->dNext();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SlowJet_constituents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SlowJet *arg1 = (Pythia8::SlowJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< int,std::allocator< int > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SlowJet_constituents",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SlowJet_constituents" "', argument " "1"" of type '" "Pythia8::SlowJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SlowJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SlowJet_constituents" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (arg1)->constituents(arg2);
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SlowJet_clusConstituents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SlowJet *arg1 = (Pythia8::SlowJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< int,std::allocator< int > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SlowJet_clusConstituents",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SlowJet_clusConstituents" "', argument " "1"" of type '" "Pythia8::SlowJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SlowJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SlowJet_clusConstituents" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (arg1)->clusConstituents(arg2);
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SlowJet_jetAssignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SlowJet *arg1 = (Pythia8::SlowJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SlowJet_jetAssignment",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SlowJet_jetAssignment" "', argument " "1"" of type '" "Pythia8::SlowJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SlowJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SlowJet_jetAssignment" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->jetAssignment(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SlowJet_removeJet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SlowJet *arg1 = (Pythia8::SlowJet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SlowJet_removeJet",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SlowJet_removeJet" "', argument " "1"" of type '" "Pythia8::SlowJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SlowJet * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SlowJet_removeJet" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->removeJet(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SlowJet___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SlowJet *arg1 = (Pythia8::SlowJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SlowJet___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SlowJet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SlowJet___str__" "', argument " "1"" of type '" "Pythia8::SlowJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SlowJet * >(argp1);
  result = Pythia8_SlowJet___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SlowJet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SlowJet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ResolvedParton__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::ResolvedParton *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_ResolvedParton",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResolvedParton" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ResolvedParton" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ResolvedParton" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ResolvedParton" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (Pythia8::ResolvedParton *)new Pythia8::ResolvedParton(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResolvedParton, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ResolvedParton__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::ResolvedParton *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_ResolvedParton",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResolvedParton" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ResolvedParton" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ResolvedParton" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (Pythia8::ResolvedParton *)new Pythia8::ResolvedParton(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResolvedParton, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ResolvedParton__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::ResolvedParton *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_ResolvedParton",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResolvedParton" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ResolvedParton" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::ResolvedParton *)new Pythia8::ResolvedParton(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResolvedParton, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ResolvedParton__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ResolvedParton *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ResolvedParton",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ResolvedParton" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ResolvedParton *)new Pythia8::ResolvedParton(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResolvedParton, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ResolvedParton__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ResolvedParton")) SWIG_fail;
  result = (Pythia8::ResolvedParton *)new Pythia8::ResolvedParton();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResolvedParton, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ResolvedParton(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_ResolvedParton__SWIG_4(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ResolvedParton__SWIG_3(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ResolvedParton__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_ResolvedParton__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_ResolvedParton__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ResolvedParton'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ResolvedParton::ResolvedParton(int,int,double,int)\n"
    "    Pythia8::ResolvedParton::ResolvedParton(int,int,double)\n"
    "    Pythia8::ResolvedParton::ResolvedParton(int,int)\n"
    "    Pythia8::ResolvedParton::ResolvedParton(int)\n"
    "    Pythia8::ResolvedParton::ResolvedParton()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_iPos__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResolvedParton_iPos",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_iPos" "', argument " "1"" of type '" "Pythia8::ResolvedParton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResolvedParton_iPos" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->iPos(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_id__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResolvedParton_id",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_id" "', argument " "1"" of type '" "Pythia8::ResolvedParton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResolvedParton_id" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->id(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_x__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResolvedParton_x",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_x" "', argument " "1"" of type '" "Pythia8::ResolvedParton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResolvedParton_x" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->x(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ResolvedParton_update",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_update" "', argument " "1"" of type '" "Pythia8::ResolvedParton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResolvedParton_update" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ResolvedParton_update" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ResolvedParton_update" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->update(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_companion__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResolvedParton_companion",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_companion" "', argument " "1"" of type '" "Pythia8::ResolvedParton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResolvedParton_companion" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->companion(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_xqCompanion__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResolvedParton_xqCompanion",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_xqCompanion" "', argument " "1"" of type '" "Pythia8::ResolvedParton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResolvedParton_xqCompanion" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->xqCompanion(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_p__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  Pythia8::Vec4 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResolvedParton_p",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_p" "', argument " "1"" of type '" "Pythia8::ResolvedParton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ResolvedParton_p" "', argument " "2"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ResolvedParton_p" "', argument " "2"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  (arg1)->p(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_px__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResolvedParton_px",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_px" "', argument " "1"" of type '" "Pythia8::ResolvedParton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResolvedParton_px" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->px(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_py__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResolvedParton_py",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_py" "', argument " "1"" of type '" "Pythia8::ResolvedParton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResolvedParton_py" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->py(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_pz__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResolvedParton_pz",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_pz" "', argument " "1"" of type '" "Pythia8::ResolvedParton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResolvedParton_pz" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->pz(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_e__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResolvedParton_e",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_e" "', argument " "1"" of type '" "Pythia8::ResolvedParton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResolvedParton_e" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->e(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_m__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResolvedParton_m",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_m" "', argument " "1"" of type '" "Pythia8::ResolvedParton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResolvedParton_m" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->m(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_col__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResolvedParton_col",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_col" "', argument " "1"" of type '" "Pythia8::ResolvedParton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResolvedParton_col" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->col(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_acol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResolvedParton_acol",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_acol" "', argument " "1"" of type '" "Pythia8::ResolvedParton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResolvedParton_acol" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->acol(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_cols__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ResolvedParton_cols",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_cols" "', argument " "1"" of type '" "Pythia8::ResolvedParton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResolvedParton_cols" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ResolvedParton_cols" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->cols(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_cols__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResolvedParton_cols",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_cols" "', argument " "1"" of type '" "Pythia8::ResolvedParton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResolvedParton_cols" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->cols(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_cols__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResolvedParton_cols",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_cols" "', argument " "1"" of type '" "Pythia8::ResolvedParton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  (arg1)->cols();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_cols(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResolvedParton_cols__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResolvedParton_cols__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ResolvedParton_cols__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ResolvedParton_cols'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ResolvedParton::cols(int,int)\n"
    "    Pythia8::ResolvedParton::cols(int)\n"
    "    Pythia8::ResolvedParton::cols()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_scalePT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResolvedParton_scalePT",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_scalePT" "', argument " "1"" of type '" "Pythia8::ResolvedParton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResolvedParton_scalePT" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->scalePT(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_scaleX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ResolvedParton_scaleX",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_scaleX" "', argument " "1"" of type '" "Pythia8::ResolvedParton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ResolvedParton_scaleX" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->scaleX(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_iPos__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResolvedParton_iPos",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_iPos" "', argument " "1"" of type '" "Pythia8::ResolvedParton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  result = (int)((Pythia8::ResolvedParton const *)arg1)->iPos();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_iPos(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResolvedParton_iPos__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResolvedParton_iPos__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ResolvedParton_iPos'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ResolvedParton::iPos(int)\n"
    "    Pythia8::ResolvedParton::iPos() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_id__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResolvedParton_id",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_id" "', argument " "1"" of type '" "Pythia8::ResolvedParton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  result = (int)((Pythia8::ResolvedParton const *)arg1)->id();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_id(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResolvedParton_id__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResolvedParton_id__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ResolvedParton_id'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ResolvedParton::id(int)\n"
    "    Pythia8::ResolvedParton::id() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_x__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResolvedParton_x",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_x" "', argument " "1"" of type '" "Pythia8::ResolvedParton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  result = (double)((Pythia8::ResolvedParton const *)arg1)->x();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_x(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResolvedParton_x__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResolvedParton_x__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ResolvedParton_x'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ResolvedParton::x(double)\n"
    "    Pythia8::ResolvedParton::x() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_companion__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResolvedParton_companion",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_companion" "', argument " "1"" of type '" "Pythia8::ResolvedParton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  result = (int)((Pythia8::ResolvedParton const *)arg1)->companion();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_companion(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResolvedParton_companion__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResolvedParton_companion__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ResolvedParton_companion'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ResolvedParton::companion(int)\n"
    "    Pythia8::ResolvedParton::companion() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_isValence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResolvedParton_isValence",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_isValence" "', argument " "1"" of type '" "Pythia8::ResolvedParton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  result = (bool)((Pythia8::ResolvedParton const *)arg1)->isValence();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_isUnmatched(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResolvedParton_isUnmatched",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_isUnmatched" "', argument " "1"" of type '" "Pythia8::ResolvedParton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  result = (bool)((Pythia8::ResolvedParton const *)arg1)->isUnmatched();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_isCompanion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResolvedParton_isCompanion",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_isCompanion" "', argument " "1"" of type '" "Pythia8::ResolvedParton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  result = (bool)((Pythia8::ResolvedParton const *)arg1)->isCompanion();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_isFromBeam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResolvedParton_isFromBeam",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_isFromBeam" "', argument " "1"" of type '" "Pythia8::ResolvedParton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  result = (bool)((Pythia8::ResolvedParton const *)arg1)->isFromBeam();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_xqCompanion__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResolvedParton_xqCompanion",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_xqCompanion" "', argument " "1"" of type '" "Pythia8::ResolvedParton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  result = (double)((Pythia8::ResolvedParton const *)arg1)->xqCompanion();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_xqCompanion(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResolvedParton_xqCompanion__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResolvedParton_xqCompanion__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ResolvedParton_xqCompanion'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ResolvedParton::xqCompanion(double)\n"
    "    Pythia8::ResolvedParton::xqCompanion() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_p__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResolvedParton_p",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_p" "', argument " "1"" of type '" "Pythia8::ResolvedParton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  result = ((Pythia8::ResolvedParton const *)arg1)->p();
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_p(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResolvedParton_p__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ResolvedParton_p__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ResolvedParton_p'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ResolvedParton::p(Pythia8::Vec4)\n"
    "    Pythia8::ResolvedParton::p() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_px__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResolvedParton_px",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_px" "', argument " "1"" of type '" "Pythia8::ResolvedParton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  result = (double)((Pythia8::ResolvedParton const *)arg1)->px();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_px(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResolvedParton_px__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResolvedParton_px__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ResolvedParton_px'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ResolvedParton::px(double)\n"
    "    Pythia8::ResolvedParton::px() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_py__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResolvedParton_py",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_py" "', argument " "1"" of type '" "Pythia8::ResolvedParton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  result = (double)((Pythia8::ResolvedParton const *)arg1)->py();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_py(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResolvedParton_py__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResolvedParton_py__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ResolvedParton_py'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ResolvedParton::py(double)\n"
    "    Pythia8::ResolvedParton::py() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_pz__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResolvedParton_pz",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_pz" "', argument " "1"" of type '" "Pythia8::ResolvedParton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  result = (double)((Pythia8::ResolvedParton const *)arg1)->pz();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_pz(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResolvedParton_pz__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResolvedParton_pz__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ResolvedParton_pz'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ResolvedParton::pz(double)\n"
    "    Pythia8::ResolvedParton::pz() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_e__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResolvedParton_e",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_e" "', argument " "1"" of type '" "Pythia8::ResolvedParton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  result = (double)((Pythia8::ResolvedParton const *)arg1)->e();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_e(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResolvedParton_e__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResolvedParton_e__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ResolvedParton_e'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ResolvedParton::e(double)\n"
    "    Pythia8::ResolvedParton::e() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_m__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResolvedParton_m",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_m" "', argument " "1"" of type '" "Pythia8::ResolvedParton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  result = (double)((Pythia8::ResolvedParton const *)arg1)->m();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_m(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResolvedParton_m__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResolvedParton_m__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ResolvedParton_m'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ResolvedParton::m(double)\n"
    "    Pythia8::ResolvedParton::m() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_pT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResolvedParton_pT",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_pT" "', argument " "1"" of type '" "Pythia8::ResolvedParton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  result = (double)((Pythia8::ResolvedParton const *)arg1)->pT();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_mT2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResolvedParton_mT2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_mT2" "', argument " "1"" of type '" "Pythia8::ResolvedParton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  result = (double)((Pythia8::ResolvedParton const *)arg1)->mT2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_pPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResolvedParton_pPos",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_pPos" "', argument " "1"" of type '" "Pythia8::ResolvedParton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  result = (double)((Pythia8::ResolvedParton const *)arg1)->pPos();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_pNeg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResolvedParton_pNeg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_pNeg" "', argument " "1"" of type '" "Pythia8::ResolvedParton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  result = (double)((Pythia8::ResolvedParton const *)arg1)->pNeg();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_col__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResolvedParton_col",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_col" "', argument " "1"" of type '" "Pythia8::ResolvedParton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  result = (int)((Pythia8::ResolvedParton const *)arg1)->col();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_col(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResolvedParton_col__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResolvedParton_col__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ResolvedParton_col'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ResolvedParton::col(int)\n"
    "    Pythia8::ResolvedParton::col() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_acol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResolvedParton_acol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_acol" "', argument " "1"" of type '" "Pythia8::ResolvedParton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  result = (int)((Pythia8::ResolvedParton const *)arg1)->acol();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_acol(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResolvedParton_acol__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ResolvedParton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResolvedParton_acol__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ResolvedParton_acol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ResolvedParton::acol(int)\n"
    "    Pythia8::ResolvedParton::acol() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_pTfactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResolvedParton_pTfactor",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_pTfactor" "', argument " "1"" of type '" "Pythia8::ResolvedParton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  result = (double)((Pythia8::ResolvedParton const *)arg1)->pTfactor();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_hasCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResolvedParton_hasCol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_hasCol" "', argument " "1"" of type '" "Pythia8::ResolvedParton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  result = (bool)((Pythia8::ResolvedParton const *)arg1)->hasCol();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ResolvedParton_hasAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ResolvedParton_hasAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResolvedParton_hasAcol" "', argument " "1"" of type '" "Pythia8::ResolvedParton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  result = (bool)((Pythia8::ResolvedParton const *)arg1)->hasAcol();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ResolvedParton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ResolvedParton *arg1 = (Pythia8::ResolvedParton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ResolvedParton",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ResolvedParton, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResolvedParton" "', argument " "1"" of type '" "Pythia8::ResolvedParton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ResolvedParton * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ResolvedParton_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ResolvedParton, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BeamParticle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BeamParticle")) SWIG_fail;
  result = (Pythia8::BeamParticle *)new Pythia8::BeamParticle();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__BeamParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  Pythia8::Info *arg6 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg7 = 0 ;
  Pythia8::ParticleData *arg8 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg9 = (Pythia8::Rndm *) 0 ;
  Pythia8::PDF *arg10 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg11 = (Pythia8::PDF *) 0 ;
  bool arg12 ;
  Pythia8::StringFlav *arg13 = (Pythia8::StringFlav *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:BeamParticle_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_init" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_init" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_init" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BeamParticle_init" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BeamParticle_init" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BeamParticle_init" "', argument " "6"" of type '" "Pythia8::Info *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::Info * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BeamParticle_init" "', argument " "7"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BeamParticle_init" "', argument " "7"" of type '" "Pythia8::Settings &""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::Settings * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "BeamParticle_init" "', argument " "8"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::ParticleData * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "BeamParticle_init" "', argument " "9"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::Rndm * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "BeamParticle_init" "', argument " "10"" of type '" "Pythia8::PDF *""'"); 
  }
  arg10 = reinterpret_cast< Pythia8::PDF * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "BeamParticle_init" "', argument " "11"" of type '" "Pythia8::PDF *""'"); 
  }
  arg11 = reinterpret_cast< Pythia8::PDF * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "BeamParticle_init" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  res13 = SWIG_ConvertPtr(obj12, &argp13,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "BeamParticle_init" "', argument " "13"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg13 = reinterpret_cast< Pythia8::StringFlav * >(argp13);
  (arg1)->init(arg2,arg3,arg4,arg5,arg6,*arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_initPDFPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::PDF *arg2 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg3 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:BeamParticle_initPDFPtr",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_initPDFPtr" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BeamParticle_initPDFPtr" "', argument " "2"" of type '" "Pythia8::PDF *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PDF * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BeamParticle_initPDFPtr" "', argument " "3"" of type '" "Pythia8::PDF *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PDF * >(argp3);
  (arg1)->initPDFPtr(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_initUnres(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::PDF *arg2 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_initUnres",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_initUnres" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BeamParticle_initUnres" "', argument " "2"" of type '" "Pythia8::PDF *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PDF * >(argp2);
  (arg1)->initUnres(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_newValenceContent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_newValenceContent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_newValenceContent" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  (arg1)->newValenceContent();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_newPzE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:BeamParticle_newPzE",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_newPzE" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_newPzE" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_newPzE" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->newPzE(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_newM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_newM",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_newM" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_newM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->newM(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_id",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_id" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (int)((Pythia8::BeamParticle const *)arg1)->id();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_idVMD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_idVMD",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_idVMD" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (int)((Pythia8::BeamParticle const *)arg1)->idVMD();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_p",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_p" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = ((Pythia8::BeamParticle const *)arg1)->p();
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_px(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_px",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_px" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (double)((Pythia8::BeamParticle const *)arg1)->px();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_py(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_py",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_py" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (double)((Pythia8::BeamParticle const *)arg1)->py();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_pz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_pz",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_pz" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (double)((Pythia8::BeamParticle const *)arg1)->pz();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_e(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_e",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_e" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (double)((Pythia8::BeamParticle const *)arg1)->e();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_m(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_m",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_m" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (double)((Pythia8::BeamParticle const *)arg1)->m();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_mVMD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_mVMD",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_mVMD" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (double)((Pythia8::BeamParticle const *)arg1)->mVMD();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_scaleVMD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_scaleVMD",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_scaleVMD" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (double)((Pythia8::BeamParticle const *)arg1)->scaleVMD();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_isLepton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_isLepton",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_isLepton" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (bool)((Pythia8::BeamParticle const *)arg1)->isLepton();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_isUnresolved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_isUnresolved",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_isUnresolved" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (bool)((Pythia8::BeamParticle const *)arg1)->isUnresolved();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_isHadron(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_isHadron",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_isHadron" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (bool)((Pythia8::BeamParticle const *)arg1)->isHadron();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_isMeson(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_isMeson",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_isMeson" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (bool)((Pythia8::BeamParticle const *)arg1)->isMeson();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_isBaryon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_isBaryon",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_isBaryon" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (bool)((Pythia8::BeamParticle const *)arg1)->isBaryon();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_isGamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_isGamma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_isGamma" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (bool)((Pythia8::BeamParticle const *)arg1)->isGamma();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_hasResGamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_hasResGamma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_hasResGamma" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (bool)((Pythia8::BeamParticle const *)arg1)->hasResGamma();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_hasVMDstate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_hasVMDstate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_hasVMDstate" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (bool)((Pythia8::BeamParticle const *)arg1)->hasVMDstate();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_xMax__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_xMax",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_xMax" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_xMax" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->xMax(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_xMax__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_xMax",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_xMax" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (double)(arg1)->xMax();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_xMax(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BeamParticle_xMax__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BeamParticle_xMax__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BeamParticle_xMax'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::BeamParticle::xMax(int)\n"
    "    Pythia8::BeamParticle::xMax()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BeamParticle_xfHard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:BeamParticle_xfHard",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_xfHard" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_xfHard" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_xfHard" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BeamParticle_xfHard" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->xfHard(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_xfMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:BeamParticle_xfMax",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_xfMax" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_xfMax" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_xfMax" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BeamParticle_xfMax" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->xfMax(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_xfFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:BeamParticle_xfFlux",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_xfFlux" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_xfFlux" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_xfFlux" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BeamParticle_xfFlux" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->xfFlux(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_xfApprox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:BeamParticle_xfApprox",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_xfApprox" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_xfApprox" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_xfApprox" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BeamParticle_xfApprox" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->xfApprox(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_xfGamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:BeamParticle_xfGamma",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_xfGamma" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_xfGamma" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_xfGamma" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BeamParticle_xfGamma" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->xfGamma(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_xfSame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:BeamParticle_xfSame",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_xfSame" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_xfSame" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_xfSame" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BeamParticle_xfSame" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->xfSame(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_xf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:BeamParticle_xf",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_xf" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_xf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_xf" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BeamParticle_xf" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->xf(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_xfVal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:BeamParticle_xfVal",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_xfVal" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_xfVal" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_xfVal" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BeamParticle_xfVal" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->xfVal(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_xfSea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:BeamParticle_xfSea",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_xfSea" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_xfSea" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_xfSea" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BeamParticle_xfSea" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->xfSea(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_xfMPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:BeamParticle_xfMPI",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_xfMPI" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_xfMPI" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_xfMPI" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BeamParticle_xfMPI" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->xfMPI(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_xfISR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:BeamParticle_xfISR",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_xfISR" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_xfISR" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_xfISR" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BeamParticle_xfISR" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BeamParticle_xfISR" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)(arg1)->xfISR(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_insideBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:BeamParticle_insideBounds",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_insideBounds" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_insideBounds" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_insideBounds" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (bool)(arg1)->insideBounds(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_alphaS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_alphaS",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_alphaS" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_alphaS" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->alphaS(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_mQuarkPDF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_mQuarkPDF",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_mQuarkPDF" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_mQuarkPDF" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->mQuarkPDF(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_nMembers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_nMembers",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_nMembers" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (int)(arg1)->nMembers();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_calcPDFEnvelope__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:BeamParticle_calcPDFEnvelope",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_calcPDFEnvelope" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_calcPDFEnvelope" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_calcPDFEnvelope" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BeamParticle_calcPDFEnvelope" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BeamParticle_calcPDFEnvelope" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  (arg1)->calcPDFEnvelope(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_calcPDFEnvelope__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  std::pair< int,int > arg2 ;
  SwigValueWrapper< std::pair< double,double > > arg3 ;
  double arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:BeamParticle_calcPDFEnvelope",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_calcPDFEnvelope" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  {
    std::pair< int,int > *ptr = (std::pair< int,int > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BeamParticle_calcPDFEnvelope" "', argument " "2"" of type '" "std::pair< int,int >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__pairT_double_double_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BeamParticle_calcPDFEnvelope" "', argument " "3"" of type '" "std::pair< double,double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BeamParticle_calcPDFEnvelope" "', argument " "3"" of type '" "std::pair< double,double >""'");
    } else {
      std::pair< double,double > * temp = reinterpret_cast< std::pair< double,double > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BeamParticle_calcPDFEnvelope" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BeamParticle_calcPDFEnvelope" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  (arg1)->calcPDFEnvelope(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_calcPDFEnvelope(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_BeamParticle_calcPDFEnvelope__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::pair< int,int >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__pairT_double_double_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_BeamParticle_calcPDFEnvelope__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BeamParticle_calcPDFEnvelope'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::BeamParticle::calcPDFEnvelope(int,double,double,int)\n"
    "    Pythia8::BeamParticle::calcPDFEnvelope(std::pair< int,int >,std::pair< double,double >,double,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BeamParticle_getPDFEnvelope(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::PDF::PDFEnvelope result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_getPDFEnvelope",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_getPDFEnvelope" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (arg1)->getPDFEnvelope();
  resultobj = SWIG_NewPointerObj((new Pythia8::PDF::PDFEnvelope(static_cast< const Pythia8::PDF::PDFEnvelope& >(result))), SWIGTYPE_p_Pythia8__PDF__PDFEnvelope, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_pickValSeaComp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_pickValSeaComp",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_pickValSeaComp" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (int)(arg1)->pickValSeaComp();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_initBeamKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_initBeamKind",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_initBeamKind" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  (arg1)->initBeamKind();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_size" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (int)((Pythia8::BeamParticle const *)arg1)->size();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_sizeInit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_sizeInit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_sizeInit" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (int)((Pythia8::BeamParticle const *)arg1)->sizeInit();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_clear" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_resetGamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_resetGamma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_resetGamma" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  (arg1)->resetGamma();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_resetGammaInLepton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_resetGammaInLepton",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_resetGammaInLepton" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  (arg1)->resetGammaInLepton();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_append__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:BeamParticle_append",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_append" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_append" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_append" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BeamParticle_append" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BeamParticle_append" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (int)(arg1)->append(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_append__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:BeamParticle_append",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_append" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_append" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_append" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BeamParticle_append" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (int)(arg1)->append(arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_append(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BeamParticle_append__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_BeamParticle_append__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BeamParticle_append'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::BeamParticle::append(int,int,double,int)\n"
    "    Pythia8::BeamParticle::append(int,int,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BeamParticle_popBack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_popBack",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_popBack" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  (arg1)->popBack();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_nValenceKinds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_nValenceKinds",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_nValenceKinds" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (int)((Pythia8::BeamParticle const *)arg1)->nValenceKinds();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_nValence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_nValence",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_nValence" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_nValence" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::BeamParticle const *)arg1)->nValence(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_isUnresolvedLepton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_isUnresolvedLepton",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_isUnresolvedLepton" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (bool)(arg1)->isUnresolvedLepton();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_remnantFlavours__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:BeamParticle_remnantFlavours",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_remnantFlavours" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BeamParticle_remnantFlavours" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BeamParticle_remnantFlavours" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_remnantFlavours" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->remnantFlavours(*arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_remnantFlavours__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_remnantFlavours",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_remnantFlavours" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BeamParticle_remnantFlavours" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BeamParticle_remnantFlavours" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->remnantFlavours(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_remnantFlavours(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BeamParticle_remnantFlavours__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BeamParticle_remnantFlavours__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BeamParticle_remnantFlavours'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::BeamParticle::remnantFlavours(Pythia8::Event &,bool)\n"
    "    Pythia8::BeamParticle::remnantFlavours(Pythia8::Event &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BeamParticle_remnantColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  std::vector< int,std::allocator< int > > *arg3 = 0 ;
  std::vector< int,std::allocator< int > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:BeamParticle_remnantColours",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_remnantColours" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BeamParticle_remnantColours" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BeamParticle_remnantColours" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BeamParticle_remnantColours" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BeamParticle_remnantColours" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BeamParticle_remnantColours" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BeamParticle_remnantColours" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp4);
  result = (bool)(arg1)->remnantColours(*arg2,*arg3,*arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_xRemnant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_xRemnant",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_xRemnant" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_xRemnant" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->xRemnant(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_hasJunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_hasJunction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_hasJunction" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (bool)((Pythia8::BeamParticle const *)arg1)->hasJunction();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_junctionCol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_junctionCol",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_junctionCol" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_junctionCol" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::BeamParticle const *)arg1)->junctionCol(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_junctionCol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:BeamParticle_junctionCol",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_junctionCol" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_junctionCol" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_junctionCol" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->junctionCol(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_junctionCol(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BeamParticle_junctionCol__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BeamParticle_junctionCol__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BeamParticle_junctionCol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::BeamParticle::junctionCol(int) const\n"
    "    Pythia8::BeamParticle::junctionCol(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BeamParticle_pickGluon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_pickGluon",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_pickGluon" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_pickGluon" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (bool)(arg1)->pickGluon(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_pickValence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_pickValence",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_pickValence" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (int)(arg1)->pickValence();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_pickRemnant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_pickRemnant",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_pickRemnant" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (int)((Pythia8::BeamParticle const *)arg1)->pickRemnant();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_zShare(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:BeamParticle_zShare",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_zShare" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_zShare" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_zShare" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BeamParticle_zShare" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->zShare(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_pxShare(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_pxShare",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_pxShare" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (double)((Pythia8::BeamParticle const *)arg1)->pxShare();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_pyShare(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_pyShare",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_pyShare" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (double)((Pythia8::BeamParticle const *)arg1)->pyShare();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_remnantFlavoursNew(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_remnantFlavoursNew",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_remnantFlavoursNew" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BeamParticle_remnantFlavoursNew" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BeamParticle_remnantFlavoursNew" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->remnantFlavoursNew(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_findColSetup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_findColSetup",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_findColSetup" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BeamParticle_findColSetup" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BeamParticle_findColSetup" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  (arg1)->findColSetup(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_setInitialCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_setInitialCol",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_setInitialCol" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BeamParticle_setInitialCol" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BeamParticle_setInitialCol" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  (arg1)->setInitialCol(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_updateCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_updateCol",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_updateCol" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  {
    std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *ptr = (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "BeamParticle_updateCol" "', argument " "2"" of type '" "std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->updateCol(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_getColUpdates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_getColUpdates",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_getColUpdates" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (arg1)->getColUpdates();
  resultobj = swig::from(static_cast< std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_gammaInitiatorIsVal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:BeamParticle_gammaInitiatorIsVal",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_gammaInitiatorIsVal" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_gammaInitiatorIsVal" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_gammaInitiatorIsVal" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BeamParticle_gammaInitiatorIsVal" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BeamParticle_gammaInitiatorIsVal" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (bool)(arg1)->gammaInitiatorIsVal(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_gammaInitiatorIsVal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:BeamParticle_gammaInitiatorIsVal",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_gammaInitiatorIsVal" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_gammaInitiatorIsVal" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_gammaInitiatorIsVal" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (bool)(arg1)->gammaInitiatorIsVal(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_gammaInitiatorIsVal(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BeamParticle_gammaInitiatorIsVal__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_BeamParticle_gammaInitiatorIsVal__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BeamParticle_gammaInitiatorIsVal'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::BeamParticle::gammaInitiatorIsVal(int,int,double,double)\n"
    "    Pythia8::BeamParticle::gammaInitiatorIsVal(int,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BeamParticle_getGammaValFlavour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_getGammaValFlavour",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_getGammaValFlavour" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (int)(arg1)->getGammaValFlavour();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_gammaValSeaComp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_gammaValSeaComp",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_gammaValSeaComp" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_gammaValSeaComp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)(arg1)->gammaValSeaComp(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_posVal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_posVal",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_posVal" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_posVal" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->posVal(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_gamVal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_gamVal",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_gamVal" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_gamVal" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->gamVal(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_gamVal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_gamVal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_gamVal" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (int)(arg1)->gamVal();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_gamVal(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BeamParticle_gamVal__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BeamParticle_gamVal__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BeamParticle_gamVal'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::BeamParticle::gamVal(int)\n"
    "    Pythia8::BeamParticle::gamVal()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BeamParticle_resolvedGamma__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_resolvedGamma",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_resolvedGamma" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_resolvedGamma" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->resolvedGamma(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_resolvedGamma__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_resolvedGamma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_resolvedGamma" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (bool)(arg1)->resolvedGamma();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_resolvedGamma(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BeamParticle_resolvedGamma__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BeamParticle_resolvedGamma__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BeamParticle_resolvedGamma'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::BeamParticle::resolvedGamma(bool)\n"
    "    Pythia8::BeamParticle::resolvedGamma()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BeamParticle_setGammaMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_setGammaMode",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_setGammaMode" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_setGammaMode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setGammaMode(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_getGammaMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_getGammaMode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_getGammaMode" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (int)(arg1)->getGammaMode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_isResolvedUnresolved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_isResolvedUnresolved",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_isResolvedUnresolved" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (bool)(arg1)->isResolvedUnresolved();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_setVMDstate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  bool arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:BeamParticle_setVMDstate",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_setVMDstate" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_setVMDstate" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_setVMDstate" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BeamParticle_setVMDstate" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BeamParticle_setVMDstate" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BeamParticle_setVMDstate" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  (arg1)->setVMDstate(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_setVMDstate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  bool arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:BeamParticle_setVMDstate",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_setVMDstate" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_setVMDstate" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_setVMDstate" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BeamParticle_setVMDstate" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BeamParticle_setVMDstate" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  (arg1)->setVMDstate(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_setVMDstate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_BeamParticle_setVMDstate__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_BeamParticle_setVMDstate__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BeamParticle_setVMDstate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::BeamParticle::setVMDstate(bool,int,double,double,bool)\n"
    "    Pythia8::BeamParticle::setVMDstate(bool,int,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BeamParticle_pT2gamma2qqbar__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_pT2gamma2qqbar",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_pT2gamma2qqbar" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_pT2gamma2qqbar" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->pT2gamma2qqbar(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_pT2gamma2qqbar__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_pT2gamma2qqbar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_pT2gamma2qqbar" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (double)(arg1)->pT2gamma2qqbar();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_pT2gamma2qqbar(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BeamParticle_pT2gamma2qqbar__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BeamParticle_pT2gamma2qqbar__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BeamParticle_pT2gamma2qqbar'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::BeamParticle::pT2gamma2qqbar(double)\n"
    "    Pythia8::BeamParticle::pT2gamma2qqbar()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BeamParticle_pTMPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_pTMPI",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_pTMPI" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_pTMPI" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->pTMPI(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_roomFor1Remnant__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_roomFor1Remnant",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_roomFor1Remnant" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_roomFor1Remnant" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (bool)(arg1)->roomFor1Remnant(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_roomFor1Remnant__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:BeamParticle_roomFor1Remnant",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_roomFor1Remnant" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_roomFor1Remnant" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_roomFor1Remnant" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BeamParticle_roomFor1Remnant" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->roomFor1Remnant(arg2,arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_roomFor1Remnant(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BeamParticle_roomFor1Remnant__SWIG_0(self, args);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BeamParticle_roomFor1Remnant__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BeamParticle_roomFor1Remnant'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::BeamParticle::roomFor1Remnant(double)\n"
    "    Pythia8::BeamParticle::roomFor1Remnant(int,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BeamParticle_roomFor2Remnants(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:BeamParticle_roomFor2Remnants",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_roomFor2Remnants" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_roomFor2Remnants" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_roomFor2Remnants" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BeamParticle_roomFor2Remnants" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->roomFor2Remnants(arg2,arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_roomForRemnants(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_roomForRemnants",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_roomForRemnants" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__BeamParticle,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BeamParticle_roomForRemnants" "', argument " "2"" of type '" "Pythia8::BeamParticle""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BeamParticle_roomForRemnants" "', argument " "2"" of type '" "Pythia8::BeamParticle""'");
    } else {
      Pythia8::BeamParticle * temp = reinterpret_cast< Pythia8::BeamParticle * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  result = (bool)(arg1)->roomForRemnants(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_remnantMass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_remnantMass",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_remnantMass" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_remnantMass" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->remnantMass(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_gammaPDFxDependence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:BeamParticle_gammaPDFxDependence",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_gammaPDFxDependence" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_gammaPDFxDependence" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_gammaPDFxDependence" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)(arg1)->gammaPDFxDependence(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_gammaPDFRefScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_gammaPDFRefScale",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_gammaPDFRefScale" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_gammaPDFRefScale" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->gammaPDFRefScale(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_xIntegratedPDFs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_xIntegratedPDFs",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_xIntegratedPDFs" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_xIntegratedPDFs" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->xIntegratedPDFs(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_xGammaPDF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_xGammaPDF",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_xGammaPDF" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  (arg1)->xGammaPDF();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_xGamma__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_xGamma",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_xGamma" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_xGamma" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->xGamma(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_Q2Gamma__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_Q2Gamma",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_Q2Gamma" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_Q2Gamma" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->Q2Gamma(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_newGammaKTPhi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:BeamParticle_newGammaKTPhi",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_newGammaKTPhi" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_newGammaKTPhi" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamParticle_newGammaKTPhi" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->newGammaKTPhi(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_Q2minPDF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_Q2minPDF",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_Q2minPDF" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (double)(arg1)->Q2minPDF();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_xGammaMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_xGammaMin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_xGammaMin" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (double)(arg1)->xGammaMin();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_xGammaHadr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_xGammaHadr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_xGammaHadr" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (double)(arg1)->xGammaHadr();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_gammaFluxNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_gammaFluxNorm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_gammaFluxNorm" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (double)(arg1)->gammaFluxNorm();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_xGamma__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_xGamma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_xGamma" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (double)((Pythia8::BeamParticle const *)arg1)->xGamma();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_xGamma(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BeamParticle_xGamma__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BeamParticle_xGamma__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BeamParticle_xGamma'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::BeamParticle::xGamma(double)\n"
    "    Pythia8::BeamParticle::xGamma() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BeamParticle_Q2Gamma__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_Q2Gamma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_Q2Gamma" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (double)((Pythia8::BeamParticle const *)arg1)->Q2Gamma();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_Q2Gamma(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BeamParticle_Q2Gamma__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BeamParticle_Q2Gamma__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BeamParticle_Q2Gamma'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::BeamParticle::Q2Gamma(double)\n"
    "    Pythia8::BeamParticle::Q2Gamma() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BeamParticle_gammaKTx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_gammaKTx",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_gammaKTx" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (double)((Pythia8::BeamParticle const *)arg1)->gammaKTx();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_gammaKTy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_gammaKTy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_gammaKTy" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (double)((Pythia8::BeamParticle const *)arg1)->gammaKTy();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_gammaKT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_gammaKT",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_gammaKT" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (double)((Pythia8::BeamParticle const *)arg1)->gammaKT();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_gammaPhi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_gammaPhi",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_gammaPhi" "', argument " "1"" of type '" "Pythia8::BeamParticle const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = (double)((Pythia8::BeamParticle const *)arg1)->gammaPhi();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_xPom__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_xPom",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_xPom" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_xPom" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->xPom(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_xPom__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle_xPom",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_xPom" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  (arg1)->xPom();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_xPom(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BeamParticle_xPom__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BeamParticle_xPom__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BeamParticle_xPom'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::BeamParticle::xPom(double)\n"
    "    Pythia8::BeamParticle::xPom()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BeamParticle_sampleXgamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_sampleXgamma",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_sampleXgamma" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_sampleXgamma" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->sampleXgamma(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle_sampleQ2gamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle_sampleQ2gamma",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle_sampleQ2gamma" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle_sampleQ2gamma" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->sampleQ2gamma(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BeamParticle___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle___str__" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  result = Pythia8_BeamParticle___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamParticle___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::ResolvedParton *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamParticle___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamParticle___getitem__" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BeamParticle___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    assert(!BEAMPARTICLE_ERROR); result = (Pythia8::ResolvedParton *)Pythia8_BeamParticle___getitem__(arg1,arg2);
    if (BEAMPARTICLE_ERROR) {
      BEAMPARTICLE_ERROR = 0;
      SWIG_exception(SWIG_IndexError, "Index out of bounds");
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResolvedParton, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BeamParticle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamParticle *arg1 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BeamParticle",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamParticle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BeamParticle" "', argument " "1"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamParticle * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BeamParticle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__BeamParticle, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BoseEinsteinHadron__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BoseEinsteinHadron *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BoseEinsteinHadron")) SWIG_fail;
  result = (Pythia8::BoseEinsteinHadron *)new Pythia8::BoseEinsteinHadron();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__BoseEinsteinHadron, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BoseEinsteinHadron__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  Pythia8::Vec4 arg3 ;
  double arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::BoseEinsteinHadron *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_BoseEinsteinHadron",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoseEinsteinHadron" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BoseEinsteinHadron" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BoseEinsteinHadron" "', argument " "3"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoseEinsteinHadron" "', argument " "3"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_BoseEinsteinHadron" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (Pythia8::BoseEinsteinHadron *)new Pythia8::BoseEinsteinHadron(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__BoseEinsteinHadron, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_BoseEinsteinHadron(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_BoseEinsteinHadron__SWIG_0(self, args);
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_BoseEinsteinHadron__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BoseEinsteinHadron'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::BoseEinsteinHadron::BoseEinsteinHadron()\n"
    "    Pythia8::BoseEinsteinHadron::BoseEinsteinHadron(int,int,Pythia8::Vec4,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_BoseEinsteinHadron_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BoseEinsteinHadron *arg1 = (Pythia8::BoseEinsteinHadron *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BoseEinsteinHadron_id_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BoseEinsteinHadron, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoseEinsteinHadron_id_set" "', argument " "1"" of type '" "Pythia8::BoseEinsteinHadron *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BoseEinsteinHadron * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoseEinsteinHadron_id_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoseEinsteinHadron_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BoseEinsteinHadron *arg1 = (Pythia8::BoseEinsteinHadron *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BoseEinsteinHadron_id_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BoseEinsteinHadron, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoseEinsteinHadron_id_get" "', argument " "1"" of type '" "Pythia8::BoseEinsteinHadron *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BoseEinsteinHadron * >(argp1);
  result = (int) ((arg1)->id);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoseEinsteinHadron_iPos_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BoseEinsteinHadron *arg1 = (Pythia8::BoseEinsteinHadron *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BoseEinsteinHadron_iPos_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BoseEinsteinHadron, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoseEinsteinHadron_iPos_set" "', argument " "1"" of type '" "Pythia8::BoseEinsteinHadron *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BoseEinsteinHadron * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoseEinsteinHadron_iPos_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iPos = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoseEinsteinHadron_iPos_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BoseEinsteinHadron *arg1 = (Pythia8::BoseEinsteinHadron *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BoseEinsteinHadron_iPos_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BoseEinsteinHadron, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoseEinsteinHadron_iPos_get" "', argument " "1"" of type '" "Pythia8::BoseEinsteinHadron *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BoseEinsteinHadron * >(argp1);
  result = (int) ((arg1)->iPos);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoseEinsteinHadron_p_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BoseEinsteinHadron *arg1 = (Pythia8::BoseEinsteinHadron *) 0 ;
  Pythia8::Vec4 *arg2 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BoseEinsteinHadron_p_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BoseEinsteinHadron, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoseEinsteinHadron_p_set" "', argument " "1"" of type '" "Pythia8::BoseEinsteinHadron *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BoseEinsteinHadron * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoseEinsteinHadron_p_set" "', argument " "2"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  if (arg1) (arg1)->p = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoseEinsteinHadron_p_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BoseEinsteinHadron *arg1 = (Pythia8::BoseEinsteinHadron *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BoseEinsteinHadron_p_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BoseEinsteinHadron, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoseEinsteinHadron_p_get" "', argument " "1"" of type '" "Pythia8::BoseEinsteinHadron *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BoseEinsteinHadron * >(argp1);
  result = (Pythia8::Vec4 *)& ((arg1)->p);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoseEinsteinHadron_pShift_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BoseEinsteinHadron *arg1 = (Pythia8::BoseEinsteinHadron *) 0 ;
  Pythia8::Vec4 *arg2 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BoseEinsteinHadron_pShift_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BoseEinsteinHadron, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoseEinsteinHadron_pShift_set" "', argument " "1"" of type '" "Pythia8::BoseEinsteinHadron *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BoseEinsteinHadron * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoseEinsteinHadron_pShift_set" "', argument " "2"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  if (arg1) (arg1)->pShift = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoseEinsteinHadron_pShift_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BoseEinsteinHadron *arg1 = (Pythia8::BoseEinsteinHadron *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BoseEinsteinHadron_pShift_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BoseEinsteinHadron, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoseEinsteinHadron_pShift_get" "', argument " "1"" of type '" "Pythia8::BoseEinsteinHadron *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BoseEinsteinHadron * >(argp1);
  result = (Pythia8::Vec4 *)& ((arg1)->pShift);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoseEinsteinHadron_pComp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BoseEinsteinHadron *arg1 = (Pythia8::BoseEinsteinHadron *) 0 ;
  Pythia8::Vec4 *arg2 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BoseEinsteinHadron_pComp_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BoseEinsteinHadron, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoseEinsteinHadron_pComp_set" "', argument " "1"" of type '" "Pythia8::BoseEinsteinHadron *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BoseEinsteinHadron * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoseEinsteinHadron_pComp_set" "', argument " "2"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  if (arg1) (arg1)->pComp = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoseEinsteinHadron_pComp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BoseEinsteinHadron *arg1 = (Pythia8::BoseEinsteinHadron *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BoseEinsteinHadron_pComp_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BoseEinsteinHadron, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoseEinsteinHadron_pComp_get" "', argument " "1"" of type '" "Pythia8::BoseEinsteinHadron *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BoseEinsteinHadron * >(argp1);
  result = (Pythia8::Vec4 *)& ((arg1)->pComp);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoseEinsteinHadron_m2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BoseEinsteinHadron *arg1 = (Pythia8::BoseEinsteinHadron *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BoseEinsteinHadron_m2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BoseEinsteinHadron, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoseEinsteinHadron_m2_set" "', argument " "1"" of type '" "Pythia8::BoseEinsteinHadron *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BoseEinsteinHadron * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoseEinsteinHadron_m2_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->m2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoseEinsteinHadron_m2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BoseEinsteinHadron *arg1 = (Pythia8::BoseEinsteinHadron *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:BoseEinsteinHadron_m2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BoseEinsteinHadron, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoseEinsteinHadron_m2_get" "', argument " "1"" of type '" "Pythia8::BoseEinsteinHadron *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BoseEinsteinHadron * >(argp1);
  result = (double) ((arg1)->m2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BoseEinsteinHadron(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BoseEinsteinHadron *arg1 = (Pythia8::BoseEinsteinHadron *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BoseEinsteinHadron",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BoseEinsteinHadron, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BoseEinsteinHadron" "', argument " "1"" of type '" "Pythia8::BoseEinsteinHadron *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BoseEinsteinHadron * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BoseEinsteinHadron_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__BoseEinsteinHadron, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BoseEinstein(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BoseEinstein *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BoseEinstein")) SWIG_fail;
  result = (Pythia8::BoseEinstein *)new Pythia8::BoseEinstein();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__BoseEinstein, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoseEinstein_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BoseEinstein *arg1 = (Pythia8::BoseEinstein *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::ParticleData *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:BoseEinstein_init",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BoseEinstein, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoseEinstein_init" "', argument " "1"" of type '" "Pythia8::BoseEinstein *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BoseEinstein * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoseEinstein_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BoseEinstein_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoseEinstein_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__ParticleData,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BoseEinstein_init" "', argument " "4"" of type '" "Pythia8::ParticleData &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoseEinstein_init" "', argument " "4"" of type '" "Pythia8::ParticleData &""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  result = (bool)(arg1)->init(arg2,*arg3,*arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BoseEinstein_shiftEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BoseEinstein *arg1 = (Pythia8::BoseEinstein *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BoseEinstein_shiftEvent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BoseEinstein, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoseEinstein_shiftEvent" "', argument " "1"" of type '" "Pythia8::BoseEinstein *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BoseEinstein * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoseEinstein_shiftEvent" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoseEinstein_shiftEvent" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->shiftEvent(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_BoseEinstein(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BoseEinstein *arg1 = (Pythia8::BoseEinstein *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BoseEinstein",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BoseEinstein, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BoseEinstein" "', argument " "1"" of type '" "Pythia8::BoseEinstein *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BoseEinstein * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BoseEinstein_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__BoseEinstein, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_ColourTracing_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourTracing *arg1 = (Pythia8::ColourTracing *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourTracing_init",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourTracing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourTracing_init" "', argument " "1"" of type '" "Pythia8::ColourTracing *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourTracing * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColourTracing_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  (arg1)->init(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourTracing_setupColList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourTracing *arg1 = (Pythia8::ColourTracing *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourTracing_setupColList",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourTracing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourTracing_setupColList" "', argument " "1"" of type '" "Pythia8::ColourTracing *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourTracing * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColourTracing_setupColList" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ColourTracing_setupColList" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->setupColList(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourTracing_traceFromAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourTracing *arg1 = (Pythia8::ColourTracing *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  int arg4 ;
  int arg5 ;
  std::vector< int,std::allocator< int > > *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ColourTracing_traceFromAcol",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourTracing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourTracing_traceFromAcol" "', argument " "1"" of type '" "Pythia8::ColourTracing *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourTracing * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColourTracing_traceFromAcol" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ColourTracing_traceFromAcol" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ColourTracing_traceFromAcol" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ColourTracing_traceFromAcol" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ColourTracing_traceFromAcol" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ColourTracing_traceFromAcol" "', argument " "6"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ColourTracing_traceFromAcol" "', argument " "6"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  arg6 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp6);
  result = (bool)(arg1)->traceFromAcol(arg2,*arg3,arg4,arg5,*arg6);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourTracing_traceFromCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourTracing *arg1 = (Pythia8::ColourTracing *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  int arg4 ;
  int arg5 ;
  std::vector< int,std::allocator< int > > *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ColourTracing_traceFromCol",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourTracing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourTracing_traceFromCol" "', argument " "1"" of type '" "Pythia8::ColourTracing *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourTracing * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColourTracing_traceFromCol" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ColourTracing_traceFromCol" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ColourTracing_traceFromCol" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ColourTracing_traceFromCol" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ColourTracing_traceFromCol" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ColourTracing_traceFromCol" "', argument " "6"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ColourTracing_traceFromCol" "', argument " "6"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  arg6 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp6);
  result = (bool)(arg1)->traceFromCol(arg2,*arg3,arg4,arg5,*arg6);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourTracing_traceInLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourTracing *arg1 = (Pythia8::ColourTracing *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  std::vector< int,std::allocator< int > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ColourTracing_traceInLoop",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourTracing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourTracing_traceInLoop" "', argument " "1"" of type '" "Pythia8::ColourTracing *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourTracing * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColourTracing_traceInLoop" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ColourTracing_traceInLoop" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ColourTracing_traceInLoop" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ColourTracing_traceInLoop" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp3);
  result = (bool)(arg1)->traceInLoop(*arg2,*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourTracing_finished(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourTracing *arg1 = (Pythia8::ColourTracing *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourTracing_finished",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourTracing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourTracing_finished" "', argument " "1"" of type '" "Pythia8::ColourTracing *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourTracing * >(argp1);
  result = (bool)(arg1)->finished();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourTracing_colFinished(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourTracing *arg1 = (Pythia8::ColourTracing *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourTracing_colFinished",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourTracing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourTracing_colFinished" "', argument " "1"" of type '" "Pythia8::ColourTracing *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourTracing * >(argp1);
  result = (bool)(arg1)->colFinished();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourTracing_getJunChains(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourTracing *arg1 = (Pythia8::ColourTracing *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourTracing_getJunChains",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourTracing, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourTracing_getJunChains" "', argument " "1"" of type '" "Pythia8::ColourTracing *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourTracing * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColourTracing_getJunChains" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ColourTracing_getJunChains" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (arg1)->getJunChains(*arg2);
  resultobj = swig::from(static_cast< std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ColourTracing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourTracing *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ColourTracing")) SWIG_fail;
  result = (Pythia8::ColourTracing *)new Pythia8::ColourTracing();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ColourTracing, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ColourTracing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourTracing *arg1 = (Pythia8::ColourTracing *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ColourTracing",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourTracing, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ColourTracing" "', argument " "1"" of type '" "Pythia8::ColourTracing *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourTracing * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ColourTracing_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ColourTracing, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_GammaKinematics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaKinematics *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_GammaKinematics")) SWIG_fail;
  result = (Pythia8::GammaKinematics *)new Pythia8::GammaKinematics();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__GammaKinematics, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GammaKinematics_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaKinematics *arg1 = (Pythia8::GammaKinematics *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = (Pythia8::Settings *) 0 ;
  Pythia8::Rndm *arg4 = (Pythia8::Rndm *) 0 ;
  Pythia8::BeamParticle *arg5 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg6 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:GammaKinematics_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GammaKinematics_init" "', argument " "1"" of type '" "Pythia8::GammaKinematics *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaKinematics * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GammaKinematics_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GammaKinematics_init" "', argument " "3"" of type '" "Pythia8::Settings *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GammaKinematics_init" "', argument " "4"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Rndm * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GammaKinematics_init" "', argument " "5"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::BeamParticle * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "GammaKinematics_init" "', argument " "6"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::BeamParticle * >(argp6);
  result = (bool)(arg1)->init(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GammaKinematics_sampleKTgamma__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaKinematics *arg1 = (Pythia8::GammaKinematics *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GammaKinematics_sampleKTgamma",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GammaKinematics_sampleKTgamma" "', argument " "1"" of type '" "Pythia8::GammaKinematics *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaKinematics * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GammaKinematics_sampleKTgamma" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)(arg1)->sampleKTgamma(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GammaKinematics_sampleKTgamma__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaKinematics *arg1 = (Pythia8::GammaKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GammaKinematics_sampleKTgamma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GammaKinematics_sampleKTgamma" "', argument " "1"" of type '" "Pythia8::GammaKinematics *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaKinematics * >(argp1);
  result = (bool)(arg1)->sampleKTgamma();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GammaKinematics_sampleKTgamma(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__GammaKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_GammaKinematics_sampleKTgamma__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__GammaKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_GammaKinematics_sampleKTgamma__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GammaKinematics_sampleKTgamma'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::GammaKinematics::sampleKTgamma(bool)\n"
    "    Pythia8::GammaKinematics::sampleKTgamma()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_GammaKinematics_deriveKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaKinematics *arg1 = (Pythia8::GammaKinematics *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:GammaKinematics_deriveKin",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GammaKinematics_deriveKin" "', argument " "1"" of type '" "Pythia8::GammaKinematics *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaKinematics * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GammaKinematics_deriveKin" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GammaKinematics_deriveKin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GammaKinematics_deriveKin" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GammaKinematics_deriveKin" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (bool)(arg1)->deriveKin(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GammaKinematics_finalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaKinematics *arg1 = (Pythia8::GammaKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GammaKinematics_finalize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GammaKinematics_finalize" "', argument " "1"" of type '" "Pythia8::GammaKinematics *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaKinematics * >(argp1);
  result = (bool)(arg1)->finalize();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GammaKinematics_fluxWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaKinematics *arg1 = (Pythia8::GammaKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GammaKinematics_fluxWeight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GammaKinematics_fluxWeight" "', argument " "1"" of type '" "Pythia8::GammaKinematics *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaKinematics * >(argp1);
  result = (double)(arg1)->fluxWeight();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GammaKinematics_calcNewSHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaKinematics *arg1 = (Pythia8::GammaKinematics *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:GammaKinematics_calcNewSHat",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GammaKinematics_calcNewSHat" "', argument " "1"" of type '" "Pythia8::GammaKinematics *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaKinematics * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GammaKinematics_calcNewSHat" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)(arg1)->calcNewSHat(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GammaKinematics_getQ2gamma1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaKinematics *arg1 = (Pythia8::GammaKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GammaKinematics_getQ2gamma1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GammaKinematics_getQ2gamma1" "', argument " "1"" of type '" "Pythia8::GammaKinematics const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaKinematics * >(argp1);
  result = (double)((Pythia8::GammaKinematics const *)arg1)->getQ2gamma1();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GammaKinematics_getQ2gamma2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaKinematics *arg1 = (Pythia8::GammaKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GammaKinematics_getQ2gamma2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GammaKinematics_getQ2gamma2" "', argument " "1"" of type '" "Pythia8::GammaKinematics const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaKinematics * >(argp1);
  result = (double)((Pythia8::GammaKinematics const *)arg1)->getQ2gamma2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GammaKinematics_getQ2min1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaKinematics *arg1 = (Pythia8::GammaKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GammaKinematics_getQ2min1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GammaKinematics_getQ2min1" "', argument " "1"" of type '" "Pythia8::GammaKinematics const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaKinematics * >(argp1);
  result = (double)((Pythia8::GammaKinematics const *)arg1)->getQ2min1();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GammaKinematics_getQ2min2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaKinematics *arg1 = (Pythia8::GammaKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GammaKinematics_getQ2min2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GammaKinematics_getQ2min2" "', argument " "1"" of type '" "Pythia8::GammaKinematics const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaKinematics * >(argp1);
  result = (double)((Pythia8::GammaKinematics const *)arg1)->getQ2min2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GammaKinematics_getPhi1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaKinematics *arg1 = (Pythia8::GammaKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GammaKinematics_getPhi1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GammaKinematics_getPhi1" "', argument " "1"" of type '" "Pythia8::GammaKinematics const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaKinematics * >(argp1);
  result = (double)((Pythia8::GammaKinematics const *)arg1)->getPhi1();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GammaKinematics_getPhi2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaKinematics *arg1 = (Pythia8::GammaKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GammaKinematics_getPhi2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GammaKinematics_getPhi2" "', argument " "1"" of type '" "Pythia8::GammaKinematics const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaKinematics * >(argp1);
  result = (double)((Pythia8::GammaKinematics const *)arg1)->getPhi2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GammaKinematics_getKT1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaKinematics *arg1 = (Pythia8::GammaKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GammaKinematics_getKT1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GammaKinematics_getKT1" "', argument " "1"" of type '" "Pythia8::GammaKinematics const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaKinematics * >(argp1);
  result = (double)((Pythia8::GammaKinematics const *)arg1)->getKT1();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GammaKinematics_getKT2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaKinematics *arg1 = (Pythia8::GammaKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GammaKinematics_getKT2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GammaKinematics_getKT2" "', argument " "1"" of type '" "Pythia8::GammaKinematics const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaKinematics * >(argp1);
  result = (double)((Pythia8::GammaKinematics const *)arg1)->getKT2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GammaKinematics_eCMsub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaKinematics *arg1 = (Pythia8::GammaKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GammaKinematics_eCMsub",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GammaKinematics_eCMsub" "', argument " "1"" of type '" "Pythia8::GammaKinematics const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaKinematics * >(argp1);
  result = (double)((Pythia8::GammaKinematics const *)arg1)->eCMsub();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GammaKinematics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GammaKinematics *arg1 = (Pythia8::GammaKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_GammaKinematics",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GammaKinematics, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GammaKinematics" "', argument " "1"" of type '" "Pythia8::GammaKinematics *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GammaKinematics * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GammaKinematics_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__GammaKinematics, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_HardProcess_hardIncoming1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HardProcess_hardIncoming1_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_hardIncoming1_set" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HardProcess_hardIncoming1_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->hardIncoming1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_hardIncoming1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardProcess_hardIncoming1_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_hardIncoming1_get" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  result = (int) ((arg1)->hardIncoming1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_hardIncoming2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HardProcess_hardIncoming2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_hardIncoming2_set" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HardProcess_hardIncoming2_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->hardIncoming2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_hardIncoming2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardProcess_hardIncoming2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_hardIncoming2_get" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  result = (int) ((arg1)->hardIncoming2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_hardOutgoing1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = (std::vector< int,std::allocator< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HardProcess_hardOutgoing1_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_hardOutgoing1_set" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HardProcess_hardOutgoing1_set" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  if (arg1) (arg1)->hardOutgoing1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_hardOutgoing1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int,std::allocator< int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardProcess_hardOutgoing1_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_hardOutgoing1_get" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  result = (std::vector< int,std::allocator< int > > *)& ((arg1)->hardOutgoing1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_hardOutgoing2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = (std::vector< int,std::allocator< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HardProcess_hardOutgoing2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_hardOutgoing2_set" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HardProcess_hardOutgoing2_set" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  if (arg1) (arg1)->hardOutgoing2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_hardOutgoing2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int,std::allocator< int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardProcess_hardOutgoing2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_hardOutgoing2_get" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  result = (std::vector< int,std::allocator< int > > *)& ((arg1)->hardOutgoing2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_hardIntermediate_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = (std::vector< int,std::allocator< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HardProcess_hardIntermediate_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_hardIntermediate_set" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HardProcess_hardIntermediate_set" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  if (arg1) (arg1)->hardIntermediate = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_hardIntermediate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int,std::allocator< int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardProcess_hardIntermediate_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_hardIntermediate_get" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  result = (std::vector< int,std::allocator< int > > *)& ((arg1)->hardIntermediate);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  Pythia8::Event *arg2 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HardProcess_state_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_state_set" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HardProcess_state_set" "', argument " "2"" of type '" "Pythia8::Event *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  if (arg1) (arg1)->state = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Event *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardProcess_state_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_state_get" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  result = (Pythia8::Event *)& ((arg1)->state);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_PosOutgoing1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = (std::vector< int,std::allocator< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HardProcess_PosOutgoing1_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_PosOutgoing1_set" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HardProcess_PosOutgoing1_set" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  if (arg1) (arg1)->PosOutgoing1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_PosOutgoing1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int,std::allocator< int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardProcess_PosOutgoing1_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_PosOutgoing1_get" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  result = (std::vector< int,std::allocator< int > > *)& ((arg1)->PosOutgoing1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_PosOutgoing2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = (std::vector< int,std::allocator< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HardProcess_PosOutgoing2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_PosOutgoing2_set" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HardProcess_PosOutgoing2_set" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  if (arg1) (arg1)->PosOutgoing2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_PosOutgoing2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int,std::allocator< int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardProcess_PosOutgoing2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_PosOutgoing2_get" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  result = (std::vector< int,std::allocator< int > > *)& ((arg1)->PosOutgoing2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_PosIntermediate_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = (std::vector< int,std::allocator< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HardProcess_PosIntermediate_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_PosIntermediate_set" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HardProcess_PosIntermediate_set" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  if (arg1) (arg1)->PosIntermediate = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_PosIntermediate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< int,std::allocator< int > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardProcess_PosIntermediate_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_PosIntermediate_get" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  result = (std::vector< int,std::allocator< int > > *)& ((arg1)->PosIntermediate);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_tms_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HardProcess_tms_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_tms_set" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HardProcess_tms_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->tms = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_tms_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardProcess_tms_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_tms_get" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  result = (double) ((arg1)->tms);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HardProcess__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HardProcess")) SWIG_fail;
  result = (Pythia8::HardProcess *)new Pythia8::HardProcess();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HardProcess, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HardProcess(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HardProcess",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HardProcess" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HardProcess__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::HardProcess *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_HardProcess",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__HardProcess,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HardProcess" "', argument " "1"" of type '" "Pythia8::HardProcess const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HardProcess" "', argument " "1"" of type '" "Pythia8::HardProcess const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  result = (Pythia8::HardProcess *)new Pythia8::HardProcess((Pythia8::HardProcess const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HardProcess, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HardProcess__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  Pythia8::ParticleData *arg2 = (Pythia8::ParticleData *) 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::HardProcess *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_HardProcess",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_HardProcess" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HardProcess" "', argument " "2"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ParticleData * >(argp2);
  result = (Pythia8::HardProcess *)new Pythia8::HardProcess(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HardProcess, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HardProcess(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_HardProcess__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__HardProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HardProcess__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_HardProcess__SWIG_2(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_HardProcess'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::HardProcess::HardProcess()\n"
    "    Pythia8::HardProcess::HardProcess(Pythia8::HardProcess const &)\n"
    "    Pythia8::HardProcess::HardProcess(std::string,Pythia8::ParticleData *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HardProcess_initOnProcess(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  std::string arg2 ;
  Pythia8::ParticleData *arg3 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:HardProcess_initOnProcess",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_initOnProcess" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HardProcess_initOnProcess" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HardProcess_initOnProcess" "', argument " "3"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ParticleData * >(argp3);
  (arg1)->initOnProcess(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_initOnLHEF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  std::string arg2 ;
  Pythia8::ParticleData *arg3 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:HardProcess_initOnLHEF",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_initOnLHEF" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HardProcess_initOnLHEF" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HardProcess_initOnLHEF" "', argument " "3"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ParticleData * >(argp3);
  (arg1)->initOnLHEF(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_translateLHEFString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HardProcess_translateLHEFString",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_translateLHEFString" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HardProcess_translateLHEFString" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->translateLHEFString(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_translateProcessString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HardProcess_translateProcessString",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_translateProcessString" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HardProcess_translateProcessString" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->translateProcessString(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardProcess_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_clear" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_allowCandidates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  int arg2 ;
  std::vector< int,std::allocator< int > > arg3 ;
  std::vector< int,std::allocator< int > > arg4 ;
  Pythia8::Event *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:HardProcess_allowCandidates",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_allowCandidates" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HardProcess_allowCandidates" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HardProcess_allowCandidates" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HardProcess_allowCandidates" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "HardProcess_allowCandidates" "', argument " "5"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HardProcess_allowCandidates" "', argument " "5"" of type '" "Pythia8::Event const &""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Event * >(argp5);
  result = (bool)(arg1)->allowCandidates(arg2,arg3,arg4,(Pythia8::Event const &)*arg5);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_storeCandidates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:HardProcess_storeCandidates",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_storeCandidates" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HardProcess_storeCandidates" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HardProcess_storeCandidates" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HardProcess_storeCandidates" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->storeCandidates((Pythia8::Event const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_matchesAnyOutgoing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:HardProcess_matchesAnyOutgoing",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_matchesAnyOutgoing" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HardProcess_matchesAnyOutgoing" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HardProcess_matchesAnyOutgoing" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HardProcess_matchesAnyOutgoing" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  result = (bool)(arg1)->matchesAnyOutgoing(arg2,(Pythia8::Event const &)*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_findOtherCandidates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:HardProcess_findOtherCandidates",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_findOtherCandidates" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HardProcess_findOtherCandidates" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HardProcess_findOtherCandidates" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HardProcess_findOtherCandidates" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HardProcess_findOtherCandidates" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (bool)(arg1)->findOtherCandidates(arg2,(Pythia8::Event const &)*arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_exchangeCandidates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  std::vector< int,std::allocator< int > > arg2 ;
  std::vector< int,std::allocator< int > > arg3 ;
  std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > > arg4 ;
  std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > > arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:HardProcess_exchangeCandidates",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_exchangeCandidates" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HardProcess_exchangeCandidates" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HardProcess_exchangeCandidates" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > > *ptr = (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > > *)0;
    int res = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HardProcess_exchangeCandidates" "', argument " "4"" of type '" "std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > > *ptr = (std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > > *)0;
    int res = swig::asptr(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HardProcess_exchangeCandidates" "', argument " "5"" of type '" "std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > >""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->exchangeCandidates(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_nQuarksOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardProcess_nQuarksOut",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_nQuarksOut" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  result = (int)(arg1)->nQuarksOut();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_nLeptonOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardProcess_nLeptonOut",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_nLeptonOut" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  result = (int)(arg1)->nLeptonOut();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_nBosonsOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardProcess_nBosonsOut",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_nBosonsOut" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  result = (int)(arg1)->nBosonsOut();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_nQuarksIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardProcess_nQuarksIn",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_nQuarksIn" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  result = (int)(arg1)->nQuarksIn();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_nLeptonIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardProcess_nLeptonIn",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_nLeptonIn" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  result = (int)(arg1)->nLeptonIn();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_hasResInCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardProcess_hasResInCurrent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_hasResInCurrent" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  result = (int)(arg1)->hasResInCurrent();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_nResInCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardProcess_nResInCurrent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_nResInCurrent" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  result = (int)(arg1)->nResInCurrent();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_hasResInProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardProcess_hasResInProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_hasResInProc" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  result = (bool)(arg1)->hasResInProc();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess_listCandidates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardProcess_listCandidates",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess_listCandidates" "', argument " "1"" of type '" "Pythia8::HardProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  ((Pythia8::HardProcess const *)arg1)->listCandidates();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardProcess___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardProcess *arg1 = (Pythia8::HardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardProcess___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardProcess___str__" "', argument " "1"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardProcess * >(argp1);
  result = Pythia8_HardProcess___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HardProcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HardProcess, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MergingHooks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::MergingHooks *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MergingHooks",&obj0)) SWIG_fail;
  arg1 = obj0;
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (Pythia8::MergingHooks *)new SwigDirector_MergingHooks(arg1); 
  } else {
    result = (Pythia8::MergingHooks *)new Pythia8::MergingHooks(); 
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MergingHooks, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MergingHooks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MergingHooks",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MergingHooks" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_tmsDefinition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_tmsDefinition",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_tmsDefinition" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_tmsDefinition" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_tmsDefinition" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::MergingHooks::tmsDefinition((Pythia8::Event const &)*arg2);
    } else {
      result = (double)(arg1)->tmsDefinition((Pythia8::Event const &)*arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_dampenIfFailCuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_dampenIfFailCuts",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_dampenIfFailCuts" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_dampenIfFailCuts" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_dampenIfFailCuts" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::MergingHooks::dampenIfFailCuts((Pythia8::Event const &)*arg2);
    } else {
      result = (double)(arg1)->dampenIfFailCuts((Pythia8::Event const &)*arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_canCutOnRecState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_canCutOnRecState",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_canCutOnRecState" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::MergingHooks::canCutOnRecState();
    } else {
      result = (bool)(arg1)->canCutOnRecState();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doCutOnRecState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doCutOnRecState",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doCutOnRecState" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_doCutOnRecState" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_doCutOnRecState" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::MergingHooks::doCutOnRecState((Pythia8::Event const &)*arg2);
    } else {
      result = (bool)(arg1)->doCutOnRecState((Pythia8::Event const &)*arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_canVetoTrialEmission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_canVetoTrialEmission",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_canVetoTrialEmission" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::MergingHooks::canVetoTrialEmission();
    } else {
      result = (bool)(arg1)->canVetoTrialEmission();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doVetoTrialEmission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MergingHooks_doVetoTrialEmission",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doVetoTrialEmission" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_doVetoTrialEmission" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_doVetoTrialEmission" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MergingHooks_doVetoTrialEmission" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_doVetoTrialEmission" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::MergingHooks::doVetoTrialEmission((Pythia8::Event const &)*arg2,(Pythia8::Event const &)*arg3);
    } else {
      result = (bool)(arg1)->doVetoTrialEmission((Pythia8::Event const &)*arg2,(Pythia8::Event const &)*arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_hardProcessME(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_hardProcessME",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_hardProcessME" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_hardProcessME" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_hardProcessME" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::MergingHooks::hardProcessME((Pythia8::Event const &)*arg2);
    } else {
      result = (double)(arg1)->hardProcessME((Pythia8::Event const &)*arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_init",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_init" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::MergingHooks::init();
    } else {
      (arg1)->init();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_initPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Settings *arg2 = (Pythia8::Settings *) 0 ;
  Pythia8::Info *arg3 = (Pythia8::Info *) 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::PartonSystems *arg5 = (Pythia8::PartonSystems *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:MergingHooks_initPtr",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_initPtr" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_initPtr" "', argument " "2"" of type '" "Pythia8::Settings *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MergingHooks_initPtr" "', argument " "3"" of type '" "Pythia8::Info *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Info * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MergingHooks_initPtr" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MergingHooks_initPtr" "', argument " "5"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::PartonSystems * >(argp5);
  (arg1)->initPtr(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_tms__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_tms",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_tms" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double)(arg1)->tms();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_tmsCut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_tmsCut",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_tmsCut" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double)(arg1)->tmsCut();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_tms__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_tms",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_tms" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_tms" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->tms(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_tms(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MergingHooks, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MergingHooks_tms__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MergingHooks, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MergingHooks_tms__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MergingHooks_tms'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::MergingHooks::tms()\n"
    "    Pythia8::MergingHooks::tms(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MergingHooks_dRijMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_dRijMS",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_dRijMS" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double)(arg1)->dRijMS();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_pTiMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_pTiMS",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_pTiMS" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double)(arg1)->pTiMS();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_QijMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_QijMS",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_QijMS" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double)(arg1)->QijMS();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nMaxJets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_nMaxJets",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nMaxJets" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int)(arg1)->nMaxJets();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nMaxJetsNLO(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_nMaxJetsNLO",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nMaxJetsNLO" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int)(arg1)->nMaxJetsNLO();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_getProcessString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_getProcessString",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_getProcessString" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (arg1)->getProcessString();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nHardOutPartons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_nHardOutPartons",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nHardOutPartons" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int)(arg1)->nHardOutPartons();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nHardOutLeptons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_nHardOutLeptons",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nHardOutLeptons" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int)(arg1)->nHardOutLeptons();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nHardOutBosons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_nHardOutBosons",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nHardOutBosons" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int)(arg1)->nHardOutBosons();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nHardInPartons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_nHardInPartons",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nHardInPartons" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int)(arg1)->nHardInPartons();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nHardInLeptons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_nHardInLeptons",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nHardInLeptons" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int)(arg1)->nHardInLeptons();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nResInCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_nResInCurrent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nResInCurrent" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int)(arg1)->nResInCurrent();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doUserMerging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doUserMerging",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doUserMerging" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->doUserMerging();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doMGMerging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doMGMerging",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doMGMerging" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->doMGMerging();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doKTMerging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doKTMerging",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doKTMerging" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->doKTMerging();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doPTLundMerging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doPTLundMerging",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doPTLundMerging" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->doPTLundMerging();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doCutBasedMerging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doCutBasedMerging",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doCutBasedMerging" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->doCutBasedMerging();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doCKKWLMerging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doCKKWLMerging",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doCKKWLMerging" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->doCKKWLMerging();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doUMEPSTree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doUMEPSTree",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doUMEPSTree" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->doUMEPSTree();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doUMEPSSubt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doUMEPSSubt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doUMEPSSubt" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->doUMEPSSubt();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doUMEPSMerging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doUMEPSMerging",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doUMEPSMerging" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->doUMEPSMerging();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doNL3Tree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doNL3Tree",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doNL3Tree" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->doNL3Tree();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doNL3Loop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doNL3Loop",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doNL3Loop" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->doNL3Loop();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doNL3Subt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doNL3Subt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doNL3Subt" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->doNL3Subt();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doNL3Merging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doNL3Merging",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doNL3Merging" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->doNL3Merging();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doUNLOPSTree(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doUNLOPSTree",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doUNLOPSTree" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->doUNLOPSTree();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doUNLOPSLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doUNLOPSLoop",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doUNLOPSLoop" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->doUNLOPSLoop();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doUNLOPSSubt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doUNLOPSSubt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doUNLOPSSubt" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->doUNLOPSSubt();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doUNLOPSSubtNLO(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doUNLOPSSubtNLO",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doUNLOPSSubtNLO" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->doUNLOPSSubtNLO();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doUNLOPSMerging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doUNLOPSMerging",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doUNLOPSMerging" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->doUNLOPSMerging();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nRecluster(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_nRecluster",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nRecluster" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int)(arg1)->nRecluster();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_nRequested",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nRequested" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int)(arg1)->nRequested();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_isFirstEmission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_isFirstEmission",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_isFirstEmission" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_isFirstEmission" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_isFirstEmission" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->isFirstEmission((Pythia8::Event const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_hasEffectiveG2EW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_hasEffectiveG2EW",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_hasEffectiveG2EW" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->hasEffectiveG2EW();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_allowEffectiveVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  std::vector< int,std::allocator< int > > arg2 ;
  std::vector< int,std::allocator< int > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MergingHooks_allowEffectiveVertex",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_allowEffectiveVertex" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MergingHooks_allowEffectiveVertex" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MergingHooks_allowEffectiveVertex" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->allowEffectiveVertex(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_bareEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Event result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MergingHooks_bareEvent",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_bareEvent" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_bareEvent" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_bareEvent" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MergingHooks_bareEvent" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (arg1)->bareEvent((Pythia8::Event const &)*arg2,arg3);
  resultobj = SWIG_NewPointerObj((new Pythia8::Event(static_cast< const Pythia8::Event& >(result))), SWIGTYPE_p_Pythia8__Event, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_reattachResonanceDecays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_reattachResonanceDecays",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_reattachResonanceDecays" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_reattachResonanceDecays" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_reattachResonanceDecays" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->reattachResonanceDecays(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_isInHard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MergingHooks_isInHard",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_isInHard" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_isInHard" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MergingHooks_isInHard" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_isInHard" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  result = (bool)(arg1)->isInHard(arg2,(Pythia8::Event const &)*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_getNumberOfClusteringSteps__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MergingHooks_getNumberOfClusteringSteps",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_getNumberOfClusteringSteps" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_getNumberOfClusteringSteps" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_getNumberOfClusteringSteps" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MergingHooks_getNumberOfClusteringSteps" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Pythia8::MergingHooks::getNumberOfClusteringSteps((Pythia8::Event const &)*arg2,arg3);
    } else {
      result = (int)(arg1)->getNumberOfClusteringSteps((Pythia8::Event const &)*arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_getNumberOfClusteringSteps__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_getNumberOfClusteringSteps",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_getNumberOfClusteringSteps" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_getNumberOfClusteringSteps" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_getNumberOfClusteringSteps" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Pythia8::MergingHooks::getNumberOfClusteringSteps((Pythia8::Event const &)*arg2);
    } else {
      result = (int)(arg1)->getNumberOfClusteringSteps((Pythia8::Event const &)*arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_getNumberOfClusteringSteps(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MergingHooks, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MergingHooks_getNumberOfClusteringSteps__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MergingHooks, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MergingHooks_getNumberOfClusteringSteps__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MergingHooks_getNumberOfClusteringSteps'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::MergingHooks::getNumberOfClusteringSteps(Pythia8::Event const &,bool)\n"
    "    Pythia8::MergingHooks::getNumberOfClusteringSteps(Pythia8::Event const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MergingHooks_orderHistories(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_orderHistories",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_orderHistories" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_orderHistories" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->orderHistories(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_allowCutOnRecState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_allowCutOnRecState",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_allowCutOnRecState" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_allowCutOnRecState" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->allowCutOnRecState(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doWeakClustering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doWeakClustering",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doWeakClustering" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_doWeakClustering" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->doWeakClustering(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_checkAgainstCut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Particle *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_checkAgainstCut",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_checkAgainstCut" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Particle,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_checkAgainstCut" "', argument " "2"" of type '" "Pythia8::Particle const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_checkAgainstCut" "', argument " "2"" of type '" "Pythia8::Particle const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Particle * >(argp2);
  result = (bool)(arg1)->checkAgainstCut((Pythia8::Particle const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_tmsNow__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_tmsNow",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_tmsNow" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_tmsNow" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_tmsNow" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::MergingHooks::tmsNow((Pythia8::Event const &)*arg2);
    } else {
      result = (double)(arg1)->tmsNow((Pythia8::Event const &)*arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_rhoms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MergingHooks_rhoms",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_rhoms" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_rhoms" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_rhoms" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MergingHooks_rhoms" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (double)(arg1)->rhoms((Pythia8::Event const &)*arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_kTms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_kTms",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_kTms" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_kTms" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_kTms" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (double)(arg1)->kTms((Pythia8::Event const &)*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_cutbasedms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_cutbasedms",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_cutbasedms" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_cutbasedms" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_cutbasedms" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (double)(arg1)->cutbasedms((Pythia8::Event const &)*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doIgnoreEmissions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doIgnoreEmissions",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doIgnoreEmissions" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_doIgnoreEmissions" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->doIgnoreEmissions(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_canVetoEmission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_canVetoEmission",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_canVetoEmission" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::MergingHooks::canVetoEmission();
    } else {
      result = (bool)(arg1)->canVetoEmission();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doVetoEmission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doVetoEmission",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doVetoEmission" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_doVetoEmission" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_doVetoEmission" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::MergingHooks::doVetoEmission((Pythia8::Event const &)*arg2);
    } else {
      result = (bool)(arg1)->doVetoEmission((Pythia8::Event const &)*arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_useShowerPluginSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_useShowerPluginSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_useShowerPluginSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_useShowerPluginSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->useShowerPluginSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_useShowerPluginSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_useShowerPluginSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_useShowerPluginSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->useShowerPluginSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_useShowerPlugin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_useShowerPlugin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_useShowerPlugin" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::MergingHooks::useShowerPlugin();
    } else {
      result = (bool)(arg1)->useShowerPlugin();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_includeWGTinXSEC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_includeWGTinXSEC",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_includeWGTinXSEC" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->includeWGTinXSEC();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nHardNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_nHardNow",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nHardNow" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int)(arg1)->nHardNow();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_tmsHardNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_tmsHardNow",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_tmsHardNow" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double)(arg1)->tmsHardNow();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nJetsNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_nJetsNow",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nJetsNow" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int)(arg1)->nJetsNow();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_tmsNow__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_tmsNow",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_tmsNow" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double)(arg1)->tmsNow();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_tmsNow(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MergingHooks, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MergingHooks_tmsNow__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MergingHooks, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MergingHooks_tmsNow__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MergingHooks_tmsNow'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::MergingHooks::tmsNow(Pythia8::Event const &)\n"
    "    Pythia8::MergingHooks::tmsNow()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MergingHooks_setHardProcessPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::HardProcess *arg2 = (Pythia8::HardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_setHardProcessPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_setHardProcessPtr" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_setHardProcessPtr" "', argument " "2"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::HardProcess * >(argp2);
  (arg1)->setHardProcessPtr(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_useOwnHardProcess_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_useOwnHardProcess_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_useOwnHardProcess_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_useOwnHardProcess_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->useOwnHardProcess = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_useOwnHardProcess_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_useOwnHardProcess_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_useOwnHardProcess_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->useOwnHardProcess);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_hardProcess_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::HardProcess *arg2 = (Pythia8::HardProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_hardProcess_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_hardProcess_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__HardProcess, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_hardProcess_set" "', argument " "2"" of type '" "Pythia8::HardProcess *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::HardProcess * >(argp2);
  if (arg1) (arg1)->hardProcess = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_hardProcess_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::HardProcess *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_hardProcess_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_hardProcess_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (Pythia8::HardProcess *) ((arg1)->hardProcess);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HardProcess, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_infoPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_infoPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_infoPtr_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_infoPtr_set" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  if (arg1) (arg1)->infoPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_infoPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Info *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_infoPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_infoPtr_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (Pythia8::Info *) ((arg1)->infoPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_settingsPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Settings *arg2 = (Pythia8::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_settingsPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_settingsPtr_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Settings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_settingsPtr_set" "', argument " "2"" of type '" "Pythia8::Settings *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  if (arg1) (arg1)->settingsPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_settingsPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Settings *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_settingsPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_settingsPtr_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (Pythia8::Settings *) ((arg1)->settingsPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_particleDataPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::ParticleData *arg2 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_particleDataPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_particleDataPtr_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ParticleData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_particleDataPtr_set" "', argument " "2"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ParticleData * >(argp2);
  if (arg1) (arg1)->particleDataPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_particleDataPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ParticleData *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_particleDataPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_particleDataPtr_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (Pythia8::ParticleData *) ((arg1)->particleDataPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_partonSystemsPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::PartonSystems *arg2 = (Pythia8::PartonSystems *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_partonSystemsPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_partonSystemsPtr_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PartonSystems, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_partonSystemsPtr_set" "', argument " "2"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PartonSystems * >(argp2);
  if (arg1) (arg1)->partonSystemsPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_partonSystemsPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::PartonSystems *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_partonSystemsPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_partonSystemsPtr_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (Pythia8::PartonSystems *) ((arg1)->partonSystemsPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_showers_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::PartonLevel *arg2 = (Pythia8::PartonLevel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_showers_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_showers_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PartonLevel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_showers_set" "', argument " "2"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PartonLevel * >(argp2);
  if (arg1) (arg1)->showers = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_showers_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::PartonLevel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_showers_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_showers_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (Pythia8::PartonLevel *) ((arg1)->showers);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_setShowerPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::PartonLevel *arg2 = (Pythia8::PartonLevel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_setShowerPointer",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_setShowerPointer" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_setShowerPointer" "', argument " "2"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PartonLevel * >(argp2);
  (arg1)->setShowerPointer(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_AlphaS_FSRSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::AlphaStrong *arg2 = (Pythia8::AlphaStrong *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_AlphaS_FSRSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_AlphaS_FSRSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_AlphaS_FSRSave_set" "', argument " "2"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::AlphaStrong * >(argp2);
  if (arg1) (arg1)->AlphaS_FSRSave = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_AlphaS_FSRSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::AlphaStrong *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_AlphaS_FSRSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_AlphaS_FSRSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (Pythia8::AlphaStrong *)& ((arg1)->AlphaS_FSRSave);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_AlphaS_ISRSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::AlphaStrong *arg2 = (Pythia8::AlphaStrong *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_AlphaS_ISRSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_AlphaS_ISRSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_AlphaS_ISRSave_set" "', argument " "2"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::AlphaStrong * >(argp2);
  if (arg1) (arg1)->AlphaS_ISRSave = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_AlphaS_ISRSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::AlphaStrong *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_AlphaS_ISRSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_AlphaS_ISRSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (Pythia8::AlphaStrong *)& ((arg1)->AlphaS_ISRSave);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_AlphaEM_FSRSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::AlphaEM *arg2 = (Pythia8::AlphaEM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_AlphaEM_FSRSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_AlphaEM_FSRSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_AlphaEM_FSRSave_set" "', argument " "2"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::AlphaEM * >(argp2);
  if (arg1) (arg1)->AlphaEM_FSRSave = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_AlphaEM_FSRSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::AlphaEM *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_AlphaEM_FSRSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_AlphaEM_FSRSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (Pythia8::AlphaEM *)& ((arg1)->AlphaEM_FSRSave);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_AlphaEM_ISRSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::AlphaEM *arg2 = (Pythia8::AlphaEM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_AlphaEM_ISRSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_AlphaEM_ISRSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_AlphaEM_ISRSave_set" "', argument " "2"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::AlphaEM * >(argp2);
  if (arg1) (arg1)->AlphaEM_ISRSave = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_AlphaEM_ISRSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::AlphaEM *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_AlphaEM_ISRSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_AlphaEM_ISRSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (Pythia8::AlphaEM *)& ((arg1)->AlphaEM_ISRSave);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_lheInputFile_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_lheInputFile_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_lheInputFile_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_lheInputFile_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_lheInputFile_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->lheInputFile = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_lheInputFile_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_lheInputFile_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_lheInputFile_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (std::string *) & ((arg1)->lheInputFile);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doUserMergingSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doUserMergingSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doUserMergingSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_doUserMergingSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->doUserMergingSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doUserMergingSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doUserMergingSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doUserMergingSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->doUserMergingSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doMGMergingSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doMGMergingSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doMGMergingSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_doMGMergingSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->doMGMergingSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doMGMergingSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doMGMergingSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doMGMergingSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->doMGMergingSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doKTMergingSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doKTMergingSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doKTMergingSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_doKTMergingSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->doKTMergingSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doKTMergingSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doKTMergingSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doKTMergingSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->doKTMergingSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doPTLundMergingSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doPTLundMergingSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doPTLundMergingSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_doPTLundMergingSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->doPTLundMergingSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doPTLundMergingSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doPTLundMergingSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doPTLundMergingSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->doPTLundMergingSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doCutBasedMergingSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doCutBasedMergingSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doCutBasedMergingSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_doCutBasedMergingSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->doCutBasedMergingSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doCutBasedMergingSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doCutBasedMergingSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doCutBasedMergingSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->doCutBasedMergingSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_includeMassiveSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_includeMassiveSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_includeMassiveSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_includeMassiveSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->includeMassiveSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_includeMassiveSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_includeMassiveSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_includeMassiveSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->includeMassiveSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_enforceStrongOrderingSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_enforceStrongOrderingSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_enforceStrongOrderingSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_enforceStrongOrderingSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->enforceStrongOrderingSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_enforceStrongOrderingSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_enforceStrongOrderingSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_enforceStrongOrderingSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->enforceStrongOrderingSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_orderInRapiditySave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_orderInRapiditySave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_orderInRapiditySave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_orderInRapiditySave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->orderInRapiditySave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_orderInRapiditySave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_orderInRapiditySave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_orderInRapiditySave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->orderInRapiditySave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_pickByFullPSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_pickByFullPSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_pickByFullPSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_pickByFullPSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->pickByFullPSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_pickByFullPSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_pickByFullPSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_pickByFullPSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->pickByFullPSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_pickByPoPT2Save_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_pickByPoPT2Save_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_pickByPoPT2Save_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_pickByPoPT2Save_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->pickByPoPT2Save = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_pickByPoPT2Save_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_pickByPoPT2Save_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_pickByPoPT2Save_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->pickByPoPT2Save);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_includeRedundantSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_includeRedundantSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_includeRedundantSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_includeRedundantSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->includeRedundantSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_includeRedundantSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_includeRedundantSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_includeRedundantSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->includeRedundantSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_pickBySumPTSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_pickBySumPTSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_pickBySumPTSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_pickBySumPTSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->pickBySumPTSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_pickBySumPTSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_pickBySumPTSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_pickBySumPTSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->pickBySumPTSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_allowColourShufflingSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_allowColourShufflingSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_allowColourShufflingSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_allowColourShufflingSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->allowColourShufflingSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_allowColourShufflingSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_allowColourShufflingSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_allowColourShufflingSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->allowColourShufflingSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_resetHardQRenSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_resetHardQRenSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_resetHardQRenSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_resetHardQRenSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->resetHardQRenSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_resetHardQRenSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_resetHardQRenSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_resetHardQRenSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->resetHardQRenSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_resetHardQFacSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_resetHardQFacSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_resetHardQFacSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_resetHardQFacSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->resetHardQFacSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_resetHardQFacSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_resetHardQFacSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_resetHardQFacSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->resetHardQFacSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_unorderedScalePrescipSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_unorderedScalePrescipSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_unorderedScalePrescipSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_unorderedScalePrescipSave_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->unorderedScalePrescipSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_unorderedScalePrescipSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_unorderedScalePrescipSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_unorderedScalePrescipSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int) ((arg1)->unorderedScalePrescipSave);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_unorderedASscalePrescipSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_unorderedASscalePrescipSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_unorderedASscalePrescipSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_unorderedASscalePrescipSave_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->unorderedASscalePrescipSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_unorderedASscalePrescipSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_unorderedASscalePrescipSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_unorderedASscalePrescipSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int) ((arg1)->unorderedASscalePrescipSave);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_unorderedPDFscalePrescipSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_unorderedPDFscalePrescipSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_unorderedPDFscalePrescipSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_unorderedPDFscalePrescipSave_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->unorderedPDFscalePrescipSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_unorderedPDFscalePrescipSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_unorderedPDFscalePrescipSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_unorderedPDFscalePrescipSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int) ((arg1)->unorderedPDFscalePrescipSave);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_incompleteScalePrescipSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_incompleteScalePrescipSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_incompleteScalePrescipSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_incompleteScalePrescipSave_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->incompleteScalePrescipSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_incompleteScalePrescipSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_incompleteScalePrescipSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_incompleteScalePrescipSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int) ((arg1)->incompleteScalePrescipSave);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_ktTypeSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_ktTypeSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_ktTypeSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_ktTypeSave_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->ktTypeSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_ktTypeSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_ktTypeSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_ktTypeSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int) ((arg1)->ktTypeSave);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nReclusterSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_nReclusterSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nReclusterSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_nReclusterSave_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->nReclusterSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nReclusterSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_nReclusterSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nReclusterSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int) ((arg1)->nReclusterSave);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nQuarksMergeSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_nQuarksMergeSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nQuarksMergeSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_nQuarksMergeSave_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->nQuarksMergeSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nQuarksMergeSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_nQuarksMergeSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nQuarksMergeSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int) ((arg1)->nQuarksMergeSave);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nRequestedSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_nRequestedSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nRequestedSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_nRequestedSave_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->nRequestedSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nRequestedSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_nRequestedSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nRequestedSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int) ((arg1)->nRequestedSave);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_scaleSeparationFactorSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_scaleSeparationFactorSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_scaleSeparationFactorSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_scaleSeparationFactorSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->scaleSeparationFactorSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_scaleSeparationFactorSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_scaleSeparationFactorSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_scaleSeparationFactorSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->scaleSeparationFactorSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nonJoinedNormSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_nonJoinedNormSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nonJoinedNormSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_nonJoinedNormSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->nonJoinedNormSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nonJoinedNormSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_nonJoinedNormSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nonJoinedNormSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->nonJoinedNormSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_fsrInRecNormSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_fsrInRecNormSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_fsrInRecNormSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_fsrInRecNormSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->fsrInRecNormSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_fsrInRecNormSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_fsrInRecNormSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_fsrInRecNormSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->fsrInRecNormSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_herwigAcollFSRSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_herwigAcollFSRSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_herwigAcollFSRSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_herwigAcollFSRSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->herwigAcollFSRSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_herwigAcollFSRSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_herwigAcollFSRSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_herwigAcollFSRSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->herwigAcollFSRSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_herwigAcollISRSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_herwigAcollISRSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_herwigAcollISRSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_herwigAcollISRSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->herwigAcollISRSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_herwigAcollISRSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_herwigAcollISRSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_herwigAcollISRSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->herwigAcollISRSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_pT0ISRSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_pT0ISRSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_pT0ISRSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_pT0ISRSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pT0ISRSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_pT0ISRSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_pT0ISRSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_pT0ISRSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->pT0ISRSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_pTcutSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_pTcutSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_pTcutSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_pTcutSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pTcutSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_pTcutSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_pTcutSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_pTcutSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->pTcutSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doNL3TreeSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doNL3TreeSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doNL3TreeSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_doNL3TreeSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->doNL3TreeSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doNL3TreeSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doNL3TreeSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doNL3TreeSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->doNL3TreeSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doNL3LoopSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doNL3LoopSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doNL3LoopSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_doNL3LoopSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->doNL3LoopSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doNL3LoopSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doNL3LoopSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doNL3LoopSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->doNL3LoopSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doNL3SubtSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doNL3SubtSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doNL3SubtSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_doNL3SubtSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->doNL3SubtSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doNL3SubtSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doNL3SubtSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doNL3SubtSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->doNL3SubtSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doUNLOPSTreeSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doUNLOPSTreeSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doUNLOPSTreeSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_doUNLOPSTreeSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->doUNLOPSTreeSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doUNLOPSTreeSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doUNLOPSTreeSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doUNLOPSTreeSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->doUNLOPSTreeSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doUNLOPSLoopSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doUNLOPSLoopSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doUNLOPSLoopSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_doUNLOPSLoopSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->doUNLOPSLoopSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doUNLOPSLoopSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doUNLOPSLoopSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doUNLOPSLoopSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->doUNLOPSLoopSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doUNLOPSSubtSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doUNLOPSSubtSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doUNLOPSSubtSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_doUNLOPSSubtSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->doUNLOPSSubtSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doUNLOPSSubtSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doUNLOPSSubtSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doUNLOPSSubtSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->doUNLOPSSubtSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doUNLOPSSubtNLOSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doUNLOPSSubtNLOSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doUNLOPSSubtNLOSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_doUNLOPSSubtNLOSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->doUNLOPSSubtNLOSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doUNLOPSSubtNLOSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doUNLOPSSubtNLOSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doUNLOPSSubtNLOSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->doUNLOPSSubtNLOSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doUMEPSTreeSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doUMEPSTreeSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doUMEPSTreeSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_doUMEPSTreeSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->doUMEPSTreeSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doUMEPSTreeSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doUMEPSTreeSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doUMEPSTreeSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->doUMEPSTreeSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doUMEPSSubtSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doUMEPSSubtSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doUMEPSSubtSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_doUMEPSSubtSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->doUMEPSSubtSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doUMEPSSubtSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doUMEPSSubtSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doUMEPSSubtSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->doUMEPSSubtSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doEstimateXSection_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doEstimateXSection_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doEstimateXSection_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_doEstimateXSection_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->doEstimateXSection = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doEstimateXSection_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doEstimateXSection_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doEstimateXSection_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->doEstimateXSection);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_applyVeto_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_applyVeto_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_applyVeto_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_applyVeto_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->applyVeto = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_applyVeto_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_applyVeto_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_applyVeto_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->applyVeto);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_inputEvent_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Event *arg2 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_inputEvent_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_inputEvent_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_inputEvent_set" "', argument " "2"" of type '" "Pythia8::Event *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  if (arg1) (arg1)->inputEvent = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_inputEvent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Event *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_inputEvent_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_inputEvent_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (Pythia8::Event *)& ((arg1)->inputEvent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_resonances_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *arg2 = (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_resonances_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_resonances_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_resonances_set" "', argument " "2"" of type '" "std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > * >(argp2);
  if (arg1) (arg1)->resonances = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_resonances_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_resonances_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_resonances_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *)& ((arg1)->resonances);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doRemoveDecayProducts_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doRemoveDecayProducts_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doRemoveDecayProducts_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_doRemoveDecayProducts_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->doRemoveDecayProducts = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doRemoveDecayProducts_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doRemoveDecayProducts_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doRemoveDecayProducts_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->doRemoveDecayProducts);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_muMISave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_muMISave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_muMISave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_muMISave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->muMISave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_muMISave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_muMISave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_muMISave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->muMISave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_kFactor0jSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_kFactor0jSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_kFactor0jSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_kFactor0jSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->kFactor0jSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_kFactor0jSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_kFactor0jSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_kFactor0jSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->kFactor0jSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_kFactor1jSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_kFactor1jSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_kFactor1jSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_kFactor1jSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->kFactor1jSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_kFactor1jSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_kFactor1jSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_kFactor1jSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->kFactor1jSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_kFactor2jSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_kFactor2jSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_kFactor2jSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_kFactor2jSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->kFactor2jSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_kFactor2jSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_kFactor2jSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_kFactor2jSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->kFactor2jSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_tmsValueSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_tmsValueSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_tmsValueSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_tmsValueSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->tmsValueSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_tmsValueSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_tmsValueSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_tmsValueSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->tmsValueSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_tmsValueNow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_tmsValueNow_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_tmsValueNow_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_tmsValueNow_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->tmsValueNow = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_tmsValueNow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_tmsValueNow_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_tmsValueNow_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->tmsValueNow);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_DparameterSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_DparameterSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_DparameterSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_DparameterSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->DparameterSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_DparameterSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_DparameterSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_DparameterSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->DparameterSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nJetMaxSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_nJetMaxSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nJetMaxSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_nJetMaxSave_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->nJetMaxSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nJetMaxSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_nJetMaxSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nJetMaxSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int) ((arg1)->nJetMaxSave);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nJetMaxNLOSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_nJetMaxNLOSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nJetMaxNLOSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_nJetMaxNLOSave_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->nJetMaxNLOSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nJetMaxNLOSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_nJetMaxNLOSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nJetMaxNLOSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int) ((arg1)->nJetMaxNLOSave);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_processSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_processSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_processSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_processSave_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_processSave_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->processSave = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_processSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_processSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_processSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (std::string *) & ((arg1)->processSave);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_tmsListSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = (std::vector< double,std::allocator< double > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_tmsListSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_tmsListSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_tmsListSave_set" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp2);
  if (arg1) (arg1)->tmsListSave = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_tmsListSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_tmsListSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_tmsListSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (std::vector< double,std::allocator< double > > *)& ((arg1)->tmsListSave);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doOrderHistoriesSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doOrderHistoriesSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doOrderHistoriesSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_doOrderHistoriesSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->doOrderHistoriesSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doOrderHistoriesSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doOrderHistoriesSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doOrderHistoriesSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->doOrderHistoriesSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doCutOnRecStateSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doCutOnRecStateSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doCutOnRecStateSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_doCutOnRecStateSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->doCutOnRecStateSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doCutOnRecStateSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doCutOnRecStateSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doCutOnRecStateSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->doCutOnRecStateSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doWeakClusteringSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doWeakClusteringSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doWeakClusteringSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_doWeakClusteringSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->doWeakClusteringSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doWeakClusteringSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doWeakClusteringSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doWeakClusteringSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->doWeakClusteringSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doSQCDClusteringSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doSQCDClusteringSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doSQCDClusteringSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_doSQCDClusteringSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->doSQCDClusteringSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doSQCDClusteringSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doSQCDClusteringSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doSQCDClusteringSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->doSQCDClusteringSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_muFSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_muFSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_muFSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_muFSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->muFSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_muFSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_muFSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_muFSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->muFSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_muRSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_muRSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_muRSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_muRSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->muRSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_muRSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_muRSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_muRSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->muRSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_muFinMESave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_muFinMESave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_muFinMESave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_muFinMESave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->muFinMESave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_muFinMESave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_muFinMESave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_muFinMESave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->muFinMESave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_muRinMESave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_muRinMESave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_muRinMESave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_muRinMESave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->muRinMESave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_muRinMESave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_muRinMESave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_muRinMESave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->muRinMESave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doIgnoreEmissionsSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doIgnoreEmissionsSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doIgnoreEmissionsSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_doIgnoreEmissionsSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->doIgnoreEmissionsSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doIgnoreEmissionsSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doIgnoreEmissionsSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doIgnoreEmissionsSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->doIgnoreEmissionsSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doIgnoreStepSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doIgnoreStepSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doIgnoreStepSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_doIgnoreStepSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->doIgnoreStepSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doIgnoreStepSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doIgnoreStepSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doIgnoreStepSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->doIgnoreStepSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_pTsave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_pTsave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_pTsave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_pTsave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pTsave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_pTsave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_pTsave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_pTsave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->pTsave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_weightCKKWL1Save_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_weightCKKWL1Save_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_weightCKKWL1Save_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_weightCKKWL1Save_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->weightCKKWL1Save = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_weightCKKWL1Save_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_weightCKKWL1Save_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_weightCKKWL1Save_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->weightCKKWL1Save);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_weightCKKWL2Save_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_weightCKKWL2Save_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_weightCKKWL2Save_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_weightCKKWL2Save_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->weightCKKWL2Save = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_weightCKKWL2Save_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_weightCKKWL2Save_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_weightCKKWL2Save_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->weightCKKWL2Save);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nMinMPISave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_nMinMPISave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nMinMPISave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_nMinMPISave_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->nMinMPISave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nMinMPISave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_nMinMPISave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nMinMPISave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int) ((arg1)->nMinMPISave);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_weightCKKWLSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_weightCKKWLSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_weightCKKWLSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_weightCKKWLSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->weightCKKWLSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_weightCKKWLSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_weightCKKWLSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_weightCKKWLSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->weightCKKWLSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_weightFIRSTSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_weightFIRSTSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_weightFIRSTSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_weightFIRSTSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->weightFIRSTSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_weightFIRSTSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_weightFIRSTSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_weightFIRSTSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->weightFIRSTSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nJetMaxLocal_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_nJetMaxLocal_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nJetMaxLocal_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_nJetMaxLocal_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->nJetMaxLocal = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nJetMaxLocal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_nJetMaxLocal_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nJetMaxLocal_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int) ((arg1)->nJetMaxLocal);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nJetMaxNLOLocal_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_nJetMaxNLOLocal_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nJetMaxNLOLocal_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_nJetMaxNLOLocal_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->nJetMaxNLOLocal = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nJetMaxNLOLocal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_nJetMaxNLOLocal_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nJetMaxNLOLocal_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int) ((arg1)->nJetMaxNLOLocal);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_hasJetMaxLocal_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_hasJetMaxLocal_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_hasJetMaxLocal_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_hasJetMaxLocal_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->hasJetMaxLocal = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_hasJetMaxLocal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_hasJetMaxLocal_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_hasJetMaxLocal_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->hasJetMaxLocal);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_includeWGTinXSECSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_includeWGTinXSECSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_includeWGTinXSECSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_includeWGTinXSECSave_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->includeWGTinXSECSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_includeWGTinXSECSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_includeWGTinXSECSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_includeWGTinXSECSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool) ((arg1)->includeWGTinXSECSave);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nHardNowSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_nHardNowSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nHardNowSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_nHardNowSave_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->nHardNowSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nHardNowSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_nHardNowSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nHardNowSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int) ((arg1)->nHardNowSave);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nJetNowSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_nJetNowSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nJetNowSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_nJetNowSave_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->nJetNowSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nJetNowSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_nJetNowSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nJetNowSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int) ((arg1)->nJetNowSave);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_tmsHardNowSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_tmsHardNowSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_tmsHardNowSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_tmsHardNowSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->tmsHardNowSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_tmsHardNowSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_tmsHardNowSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_tmsHardNowSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->tmsHardNowSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_tmsNowSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_tmsNowSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_tmsNowSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_tmsNowSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->tmsNowSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_tmsNowSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_tmsNowSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_tmsNowSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->tmsNowSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_storeHardProcessCandidates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_storeHardProcessCandidates",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_storeHardProcessCandidates" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_storeHardProcessCandidates" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_storeHardProcessCandidates" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  (arg1)->storeHardProcessCandidates((Pythia8::Event const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_setLHEInputFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_setLHEInputFile",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_setLHEInputFile" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MergingHooks_setLHEInputFile" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->setLHEInputFile(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_AlphaS_FSR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::AlphaStrong *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_AlphaS_FSR",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_AlphaS_FSR" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (Pythia8::AlphaStrong *)(arg1)->AlphaS_FSR();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_AlphaS_ISR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::AlphaStrong *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_AlphaS_ISR",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_AlphaS_ISR" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (Pythia8::AlphaStrong *)(arg1)->AlphaS_ISR();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_AlphaEM_FSR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::AlphaEM *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_AlphaEM_FSR",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_AlphaEM_FSR" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (Pythia8::AlphaEM *)(arg1)->AlphaEM_FSR();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_AlphaEM_ISR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::AlphaEM *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_AlphaEM_ISR",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_AlphaEM_ISR" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (Pythia8::AlphaEM *)(arg1)->AlphaEM_ISR();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_includeMassive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_includeMassive",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_includeMassive" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->includeMassive();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_enforceStrongOrdering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_enforceStrongOrdering",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_enforceStrongOrdering" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->enforceStrongOrdering();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_orderInRapidity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_orderInRapidity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_orderInRapidity" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->orderInRapidity();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_pickByFull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_pickByFull",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_pickByFull" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->pickByFull();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_pickByPoPT2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_pickByPoPT2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_pickByPoPT2" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->pickByPoPT2();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_includeRedundant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_includeRedundant",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_includeRedundant" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->includeRedundant();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_pickBySumPT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_pickBySumPT",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_pickBySumPT" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->pickBySumPT();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_unorderedScalePrescip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_unorderedScalePrescip",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_unorderedScalePrescip" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int)(arg1)->unorderedScalePrescip();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_unorderedASscalePrescip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_unorderedASscalePrescip",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_unorderedASscalePrescip" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int)(arg1)->unorderedASscalePrescip();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_unorderedPDFscalePrescip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_unorderedPDFscalePrescip",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_unorderedPDFscalePrescip" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int)(arg1)->unorderedPDFscalePrescip();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_incompleteScalePrescip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_incompleteScalePrescip",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_incompleteScalePrescip" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int)(arg1)->incompleteScalePrescip();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_allowColourShuffling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_allowColourShuffling",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_allowColourShuffling" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->allowColourShuffling();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_resetHardQRen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_resetHardQRen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_resetHardQRen" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->resetHardQRen();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_resetHardQFac(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_resetHardQFac",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_resetHardQFac" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->resetHardQFac();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_scaleSeparationFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_scaleSeparationFactor",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_scaleSeparationFactor" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double)(arg1)->scaleSeparationFactor();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nonJoinedNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_nonJoinedNorm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nonJoinedNorm" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double)(arg1)->nonJoinedNorm();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_fsrInRecNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_fsrInRecNorm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_fsrInRecNorm" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double)(arg1)->fsrInRecNorm();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_herwigAcollFSR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_herwigAcollFSR",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_herwigAcollFSR" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double)(arg1)->herwigAcollFSR();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_herwigAcollISR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_herwigAcollISR",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_herwigAcollISR" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double)(arg1)->herwigAcollISR();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_pT0ISR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_pT0ISR",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_pT0ISR" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double)(arg1)->pT0ISR();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_pTcut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_pTcut",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_pTcut" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double)(arg1)->pTcut();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_muMI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_muMI",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_muMI" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_muMI" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->muMI(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_muMI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_muMI",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_muMI" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double)(arg1)->muMI();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_muMI(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MergingHooks, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MergingHooks_muMI__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MergingHooks, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MergingHooks_muMI__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MergingHooks_muMI'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::MergingHooks::muMI(double)\n"
    "    Pythia8::MergingHooks::muMI()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MergingHooks_kFactor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_kFactor",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_kFactor" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_kFactor" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->kFactor(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_kFactor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_kFactor",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_kFactor" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double)(arg1)->kFactor();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_kFactor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MergingHooks, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MergingHooks_kFactor__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MergingHooks, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MergingHooks_kFactor__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MergingHooks_kFactor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::MergingHooks::kFactor(int)\n"
    "    Pythia8::MergingHooks::kFactor()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MergingHooks_k1Factor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_k1Factor",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_k1Factor" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_k1Factor" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->k1Factor(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_k1Factor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_k1Factor",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_k1Factor" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double)(arg1)->k1Factor();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_k1Factor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MergingHooks, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MergingHooks_k1Factor__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MergingHooks, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MergingHooks_k1Factor__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MergingHooks_k1Factor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::MergingHooks::k1Factor(int)\n"
    "    Pythia8::MergingHooks::k1Factor()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MergingHooks_getOrderHistories(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_getOrderHistories",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_getOrderHistories" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->orderHistories();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_getAllowCutOnRecState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_getAllowCutOnRecState",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_getAllowCutOnRecState" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->allowCutOnRecState();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_getDoWeakClustering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_getDoWeakClustering",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_getDoWeakClustering" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->doWeakClustering();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doSQCDClustering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_doSQCDClustering",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doSQCDClustering" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (bool)(arg1)->doSQCDClustering();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_muF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_muF",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_muF" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double)(arg1)->muF();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_muR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_muR",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_muR" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double)(arg1)->muR();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_muFinME(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_muFinME",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_muFinME" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double)(arg1)->muFinME();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_muRinME(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_muRinME",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_muRinME" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double)(arg1)->muRinME();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doIgnoreStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_doIgnoreStep",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doIgnoreStep" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_doIgnoreStep" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->doIgnoreStep(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_canVetoStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_canVetoStep",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_canVetoStep" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::MergingHooks::canVetoStep();
    } else {
      result = (bool)(arg1)->canVetoStep();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_storeWeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_storeWeights",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_storeWeights" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_storeWeights" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->storeWeights(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doVetoStep__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  Pythia8::Event *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:MergingHooks_doVetoStep",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doVetoStep" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_doVetoStep" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_doVetoStep" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MergingHooks_doVetoStep" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_doVetoStep" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MergingHooks_doVetoStep" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::MergingHooks::doVetoStep((Pythia8::Event const &)*arg2,(Pythia8::Event const &)*arg3,arg4);
    } else {
      result = (bool)(arg1)->doVetoStep((Pythia8::Event const &)*arg2,(Pythia8::Event const &)*arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doVetoStep__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MergingHooks_doVetoStep",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_doVetoStep" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_doVetoStep" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_doVetoStep" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MergingHooks_doVetoStep" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_doVetoStep" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::MergingHooks::doVetoStep((Pythia8::Event const &)*arg2,(Pythia8::Event const &)*arg3);
    } else {
      result = (bool)(arg1)->doVetoStep((Pythia8::Event const &)*arg2,(Pythia8::Event const &)*arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_doVetoStep(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MergingHooks, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Event, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MergingHooks_doVetoStep__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MergingHooks, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Event, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_MergingHooks_doVetoStep__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MergingHooks_doVetoStep'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::MergingHooks::doVetoStep(Pythia8::Event const &,Pythia8::Event const &,bool)\n"
    "    Pythia8::MergingHooks::doVetoStep(Pythia8::Event const &,Pythia8::Event const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MergingHooks_setShowerStartingScales(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  bool arg2 ;
  bool arg3 ;
  double *arg4 = 0 ;
  Pythia8::Event *arg5 = 0 ;
  double *arg6 = 0 ;
  bool *arg7 = 0 ;
  double *arg8 = 0 ;
  bool *arg9 = 0 ;
  double *arg10 = 0 ;
  bool *arg11 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:MergingHooks_setShowerStartingScales",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_setShowerStartingScales" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_setShowerStartingScales" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MergingHooks_setShowerStartingScales" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MergingHooks_setShowerStartingScales" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_setShowerStartingScales" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MergingHooks_setShowerStartingScales" "', argument " "5"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_setShowerStartingScales" "', argument " "5"" of type '" "Pythia8::Event const &""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Event * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "MergingHooks_setShowerStartingScales" "', argument " "6"" of type '" "double &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_setShowerStartingScales" "', argument " "6"" of type '" "double &""'"); 
  }
  arg6 = reinterpret_cast< double * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "MergingHooks_setShowerStartingScales" "', argument " "7"" of type '" "bool &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_setShowerStartingScales" "', argument " "7"" of type '" "bool &""'"); 
  }
  arg7 = reinterpret_cast< bool * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "MergingHooks_setShowerStartingScales" "', argument " "8"" of type '" "double &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_setShowerStartingScales" "', argument " "8"" of type '" "double &""'"); 
  }
  arg8 = reinterpret_cast< double * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "MergingHooks_setShowerStartingScales" "', argument " "9"" of type '" "bool &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_setShowerStartingScales" "', argument " "9"" of type '" "bool &""'"); 
  }
  arg9 = reinterpret_cast< bool * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "MergingHooks_setShowerStartingScales" "', argument " "10"" of type '" "double &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_setShowerStartingScales" "', argument " "10"" of type '" "double &""'"); 
  }
  arg10 = reinterpret_cast< double * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "MergingHooks_setShowerStartingScales" "', argument " "11"" of type '" "bool &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_setShowerStartingScales" "', argument " "11"" of type '" "bool &""'"); 
  }
  arg11 = reinterpret_cast< bool * >(argp11);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::MergingHooks::setShowerStartingScales(arg2,arg3,*arg4,(Pythia8::Event const &)*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11);
    } else {
      result = (bool)(arg1)->setShowerStartingScales(arg2,arg3,*arg4,(Pythia8::Event const &)*arg5,*arg6,*arg7,*arg8,*arg9,*arg10,*arg11);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_stopScaleSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_stopScaleSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_stopScaleSave_set" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_stopScaleSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->stopScaleSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_stopScaleSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_stopScaleSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_stopScaleSave_get" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double) ((arg1)->stopScaleSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_setShowerStoppingScale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_setShowerStoppingScale",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_setShowerStoppingScale" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_setShowerStoppingScale" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setShowerStoppingScale(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_setShowerStoppingScale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_setShowerStoppingScale",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_setShowerStoppingScale" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  (arg1)->setShowerStoppingScale();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_setShowerStoppingScale(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MergingHooks, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MergingHooks_setShowerStoppingScale__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MergingHooks, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MergingHooks_setShowerStoppingScale__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MergingHooks_setShowerStoppingScale'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::MergingHooks::setShowerStoppingScale(double)\n"
    "    Pythia8::MergingHooks::setShowerStoppingScale()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MergingHooks_getShowerStoppingScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_getShowerStoppingScale",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_getShowerStoppingScale" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double)(arg1)->getShowerStoppingScale();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nMinMPI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_nMinMPI",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nMinMPI" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_nMinMPI" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->nMinMPI(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nMinMPI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_nMinMPI",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_nMinMPI" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (int)(arg1)->nMinMPI();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_nMinMPI(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MergingHooks, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MergingHooks_nMinMPI__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MergingHooks, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MergingHooks_nMinMPI__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MergingHooks_nMinMPI'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::MergingHooks::nMinMPI(int)\n"
    "    Pythia8::MergingHooks::nMinMPI()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MergingHooks_kTdurham(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Particle *arg2 = 0 ;
  Pythia8::Particle *arg3 = 0 ;
  int arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:MergingHooks_kTdurham",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_kTdurham" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Particle,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_kTdurham" "', argument " "2"" of type '" "Pythia8::Particle const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_kTdurham" "', argument " "2"" of type '" "Pythia8::Particle const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Particle * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Particle,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MergingHooks_kTdurham" "', argument " "3"" of type '" "Pythia8::Particle const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_kTdurham" "', argument " "3"" of type '" "Pythia8::Particle const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Particle * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MergingHooks_kTdurham" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MergingHooks_kTdurham" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (double)(arg1)->kTdurham((Pythia8::Particle const &)*arg2,(Pythia8::Particle const &)*arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_rhoPythia(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:MergingHooks_rhoPythia",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_rhoPythia" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_rhoPythia" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_rhoPythia" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MergingHooks_rhoPythia" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MergingHooks_rhoPythia" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MergingHooks_rhoPythia" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MergingHooks_rhoPythia" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (double)(arg1)->rhoPythia((Pythia8::Event const &)*arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_findColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  Pythia8::Event *arg5 = 0 ;
  int arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:MergingHooks_findColour",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_findColour" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_findColour" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MergingHooks_findColour" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MergingHooks_findColour" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MergingHooks_findColour" "', argument " "5"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_findColour" "', argument " "5"" of type '" "Pythia8::Event const &""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Event * >(argp5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MergingHooks_findColour" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "MergingHooks_findColour" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  result = (int)(arg1)->findColour(arg2,arg3,arg4,(Pythia8::Event const &)*arg5,arg6,arg7);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_deltaRij(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::Vec4 arg2 ;
  Pythia8::Vec4 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MergingHooks_deltaRij",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_deltaRij" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MergingHooks_deltaRij" "', argument " "2"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_deltaRij" "', argument " "2"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MergingHooks_deltaRij" "', argument " "3"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MergingHooks_deltaRij" "', argument " "3"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = (double)(arg1)->deltaRij(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_getWeightNLO(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_getWeightNLO",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_getWeightNLO" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double)(arg1)->getWeightNLO();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_getWeightCKKWL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_getWeightCKKWL",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_getWeightCKKWL" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double)(arg1)->getWeightCKKWL();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_getWeightFIRST(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MergingHooks_getWeightFIRST",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_getWeightFIRST" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  result = (double)(arg1)->getWeightFIRST();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_setWeightCKKWL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_setWeightCKKWL",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_setWeightCKKWL" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_setWeightCKKWL" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setWeightCKKWL(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_setWeightFIRST(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MergingHooks_setWeightFIRST",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_setWeightFIRST" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_setWeightFIRST" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setWeightFIRST(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_setEventVetoInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MergingHooks_setEventVetoInfo",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_setEventVetoInfo" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_setEventVetoInfo" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MergingHooks_setEventVetoInfo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->setEventVetoInfo(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MergingHooks_setHardProcessInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MergingHooks_setHardProcessInfo",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MergingHooks_setHardProcessInfo" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MergingHooks_setHardProcessInfo" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MergingHooks_setHardProcessInfo" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->setHardProcessInfo(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_MergingHooks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MergingHooks *arg1 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:disown_MergingHooks",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_MergingHooks" "', argument " "1"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MergingHooks * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MergingHooks_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__MergingHooks, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_InBeam__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::InBeam *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_InBeam",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InBeam" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::InBeam *)new Pythia8::InBeam(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__InBeam, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InBeam__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::InBeam *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_InBeam")) SWIG_fail;
  result = (Pythia8::InBeam *)new Pythia8::InBeam();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__InBeam, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InBeam(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_InBeam__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_InBeam__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_InBeam'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::InBeam::InBeam(int)\n"
    "    Pythia8::InBeam::InBeam()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InBeam_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::InBeam *arg1 = (Pythia8::InBeam *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:InBeam_id_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__InBeam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InBeam_id_set" "', argument " "1"" of type '" "Pythia8::InBeam *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::InBeam * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InBeam_id_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->id = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InBeam_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::InBeam *arg1 = (Pythia8::InBeam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:InBeam_id_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__InBeam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InBeam_id_get" "', argument " "1"" of type '" "Pythia8::InBeam *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::InBeam * >(argp1);
  result = (int) ((arg1)->id);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InBeam_pdf_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::InBeam *arg1 = (Pythia8::InBeam *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:InBeam_pdf_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__InBeam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InBeam_pdf_set" "', argument " "1"" of type '" "Pythia8::InBeam *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::InBeam * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InBeam_pdf_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pdf = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InBeam_pdf_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::InBeam *arg1 = (Pythia8::InBeam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:InBeam_pdf_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__InBeam, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InBeam_pdf_get" "', argument " "1"" of type '" "Pythia8::InBeam *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::InBeam * >(argp1);
  result = (double) ((arg1)->pdf);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InBeam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::InBeam *arg1 = (Pythia8::InBeam *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_InBeam",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__InBeam, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InBeam" "', argument " "1"" of type '" "Pythia8::InBeam *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::InBeam * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InBeam_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__InBeam, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_InPair__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::InPair *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_InPair",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InPair" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_InPair" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::InPair *)new Pythia8::InPair(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__InPair, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InPair__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::InPair *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_InPair",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InPair" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::InPair *)new Pythia8::InPair(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__InPair, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InPair__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::InPair *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_InPair")) SWIG_fail;
  result = (Pythia8::InPair *)new Pythia8::InPair();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__InPair, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_InPair(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_InPair__SWIG_2(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_InPair__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_InPair__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_InPair'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::InPair::InPair(int,int)\n"
    "    Pythia8::InPair::InPair(int)\n"
    "    Pythia8::InPair::InPair()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_InPair_idA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::InPair *arg1 = (Pythia8::InPair *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:InPair_idA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__InPair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InPair_idA_set" "', argument " "1"" of type '" "Pythia8::InPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::InPair * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InPair_idA_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->idA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InPair_idA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::InPair *arg1 = (Pythia8::InPair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:InPair_idA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__InPair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InPair_idA_get" "', argument " "1"" of type '" "Pythia8::InPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::InPair * >(argp1);
  result = (int) ((arg1)->idA);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InPair_idB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::InPair *arg1 = (Pythia8::InPair *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:InPair_idB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__InPair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InPair_idB_set" "', argument " "1"" of type '" "Pythia8::InPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::InPair * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InPair_idB_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->idB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InPair_idB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::InPair *arg1 = (Pythia8::InPair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:InPair_idB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__InPair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InPair_idB_get" "', argument " "1"" of type '" "Pythia8::InPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::InPair * >(argp1);
  result = (int) ((arg1)->idB);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InPair_pdfA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::InPair *arg1 = (Pythia8::InPair *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:InPair_pdfA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__InPair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InPair_pdfA_set" "', argument " "1"" of type '" "Pythia8::InPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::InPair * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InPair_pdfA_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pdfA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InPair_pdfA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::InPair *arg1 = (Pythia8::InPair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:InPair_pdfA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__InPair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InPair_pdfA_get" "', argument " "1"" of type '" "Pythia8::InPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::InPair * >(argp1);
  result = (double) ((arg1)->pdfA);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InPair_pdfB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::InPair *arg1 = (Pythia8::InPair *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:InPair_pdfB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__InPair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InPair_pdfB_set" "', argument " "1"" of type '" "Pythia8::InPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::InPair * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InPair_pdfB_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pdfB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InPair_pdfB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::InPair *arg1 = (Pythia8::InPair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:InPair_pdfB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__InPair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InPair_pdfB_get" "', argument " "1"" of type '" "Pythia8::InPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::InPair * >(argp1);
  result = (double) ((arg1)->pdfB);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InPair_pdfSigma_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::InPair *arg1 = (Pythia8::InPair *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:InPair_pdfSigma_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__InPair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InPair_pdfSigma_set" "', argument " "1"" of type '" "Pythia8::InPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::InPair * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InPair_pdfSigma_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pdfSigma = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_InPair_pdfSigma_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::InPair *arg1 = (Pythia8::InPair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:InPair_pdfSigma_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__InPair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InPair_pdfSigma_get" "', argument " "1"" of type '" "Pythia8::InPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::InPair * >(argp1);
  result = (double) ((arg1)->pdfSigma);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_InPair(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::InPair *arg1 = (Pythia8::InPair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_InPair",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__InPair, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InPair" "', argument " "1"" of type '" "Pythia8::InPair *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::InPair * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *InPair_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__InPair, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_SigmaProcess(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SigmaProcess",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SigmaProcess" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_init__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = (Pythia8::Settings *) 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  Pythia8::BeamParticle *arg6 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg7 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::Couplings *arg8 = (Pythia8::Couplings *) 0 ;
  Pythia8::SigmaTotal *arg9 = (Pythia8::SigmaTotal *) 0 ;
  Pythia8::SLHAinterface *arg10 = (Pythia8::SLHAinterface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:SigmaProcess_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_init" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SigmaProcess_init" "', argument " "3"" of type '" "Pythia8::Settings *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SigmaProcess_init" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SigmaProcess_init" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SigmaProcess_init" "', argument " "6"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::BeamParticle * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SigmaProcess_init" "', argument " "7"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::BeamParticle * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "SigmaProcess_init" "', argument " "8"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::Couplings * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "SigmaProcess_init" "', argument " "9"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::SigmaTotal * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_Pythia8__SLHAinterface, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "SigmaProcess_init" "', argument " "10"" of type '" "Pythia8::SLHAinterface *""'"); 
  }
  arg10 = reinterpret_cast< Pythia8::SLHAinterface * >(argp10);
  (arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_init__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = (Pythia8::Settings *) 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  Pythia8::BeamParticle *arg6 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg7 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::Couplings *arg8 = (Pythia8::Couplings *) 0 ;
  Pythia8::SigmaTotal *arg9 = (Pythia8::SigmaTotal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:SigmaProcess_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_init" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SigmaProcess_init" "', argument " "3"" of type '" "Pythia8::Settings *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SigmaProcess_init" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SigmaProcess_init" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SigmaProcess_init" "', argument " "6"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::BeamParticle * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SigmaProcess_init" "', argument " "7"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::BeamParticle * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "SigmaProcess_init" "', argument " "8"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::Couplings * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "SigmaProcess_init" "', argument " "9"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::SigmaTotal * >(argp9);
  (arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_init__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = (Pythia8::Settings *) 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  Pythia8::BeamParticle *arg6 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg7 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::Couplings *arg8 = (Pythia8::Couplings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:SigmaProcess_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_init" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SigmaProcess_init" "', argument " "3"" of type '" "Pythia8::Settings *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SigmaProcess_init" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SigmaProcess_init" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SigmaProcess_init" "', argument " "6"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::BeamParticle * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SigmaProcess_init" "', argument " "7"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::BeamParticle * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "SigmaProcess_init" "', argument " "8"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::Couplings * >(argp8);
  (arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_init(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 10) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__Rndm, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Pythia8__Couplings, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_SigmaProcess_init__SWIG_2(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__Rndm, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Pythia8__Couplings, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_Pythia8__SigmaTotal, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_SigmaProcess_init__SWIG_1(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__Rndm, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Pythia8__Couplings, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_Pythia8__SigmaTotal, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_Pythia8__SLHAinterface, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_SigmaProcess_init__SWIG_0(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaProcess_init'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaProcess::init(Pythia8::Info *,Pythia8::Settings *,Pythia8::ParticleData *,Pythia8::Rndm *,Pythia8::BeamParticle *,Pythia8::BeamParticle *,Pythia8::Couplings *,Pythia8::SigmaTotal *,Pythia8::SLHAinterface *)\n"
    "    Pythia8::SigmaProcess::init(Pythia8::Info *,Pythia8::Settings *,Pythia8::ParticleData *,Pythia8::Rndm *,Pythia8::BeamParticle *,Pythia8::BeamParticle *,Pythia8::Couplings *,Pythia8::SigmaTotal *)\n"
    "    Pythia8::SigmaProcess::init(Pythia8::Info *,Pythia8::Settings *,Pythia8::ParticleData *,Pythia8::Rndm *,Pythia8::BeamParticle *,Pythia8::BeamParticle *,Pythia8::Couplings *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_setLHAPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::LHAup *arg2 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_setLHAPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_setLHAPtr" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_setLHAPtr" "', argument " "2"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHAup * >(argp2);
  (arg1)->setLHAPtr(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_initProc" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::SigmaProcess::initProc();
    } else {
      (arg1)->initProc();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_initFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_initFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_initFlux" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::SigmaProcess::initFlux();
    } else {
      result = (bool)(arg1)->initFlux();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_set1Kin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaProcess_set1Kin",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_set1Kin" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_set1Kin" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_set1Kin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaProcess_set1Kin" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::SigmaProcess::set1Kin(arg2,arg3,arg4);
    } else {
      (arg1)->set1Kin(arg2,arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_set2Kin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:SigmaProcess_set2Kin",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_set2Kin" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_set2Kin" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_set2Kin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaProcess_set2Kin" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaProcess_set2Kin" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaProcess_set2Kin" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SigmaProcess_set2Kin" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SigmaProcess_set2Kin" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SigmaProcess_set2Kin" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::SigmaProcess::set2Kin(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } else {
      (arg1)->set2Kin(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_set2KinMPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  double arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:SigmaProcess_set2KinMPI",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_set2KinMPI" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_set2KinMPI" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_set2KinMPI" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaProcess_set2KinMPI" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaProcess_set2KinMPI" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaProcess_set2KinMPI" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SigmaProcess_set2KinMPI" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SigmaProcess_set2KinMPI" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SigmaProcess_set2KinMPI" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "SigmaProcess_set2KinMPI" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "SigmaProcess_set2KinMPI" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::SigmaProcess::set2KinMPI(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
    } else {
      (arg1)->set2KinMPI(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_set3Kin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  Pythia8::Vec4 arg5 ;
  Pythia8::Vec4 arg6 ;
  Pythia8::Vec4 arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:SigmaProcess_set3Kin",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_set3Kin" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_set3Kin" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_set3Kin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaProcess_set3Kin" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SigmaProcess_set3Kin" "', argument " "5"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaProcess_set3Kin" "', argument " "5"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SigmaProcess_set3Kin" "', argument " "6"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaProcess_set3Kin" "', argument " "6"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SigmaProcess_set3Kin" "', argument " "7"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaProcess_set3Kin" "', argument " "7"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SigmaProcess_set3Kin" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SigmaProcess_set3Kin" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "SigmaProcess_set3Kin" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "SigmaProcess_set3Kin" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "SigmaProcess_set3Kin" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "SigmaProcess_set3Kin" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::SigmaProcess::set3Kin(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
    } else {
      (arg1)->set3Kin(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sigmaKin" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::SigmaProcess::sigmaKin();
    } else {
      (arg1)->sigmaKin();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sigmaHat" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::SigmaProcess::sigmaHat();
    } else {
      result = (double)(arg1)->sigmaHat();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sigmaHatWrap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaProcess_sigmaHatWrap",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sigmaHatWrap" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_sigmaHatWrap" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_sigmaHatWrap" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::SigmaProcess::sigmaHatWrap(arg2,arg3);
    } else {
      result = (double)(arg1)->sigmaHatWrap(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sigmaHatWrap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_sigmaHatWrap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sigmaHatWrap" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_sigmaHatWrap" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::SigmaProcess::sigmaHatWrap(arg2);
    } else {
      result = (double)(arg1)->sigmaHatWrap(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sigmaHatWrap__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_sigmaHatWrap",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sigmaHatWrap" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::SigmaProcess::sigmaHatWrap();
    } else {
      result = (double)(arg1)->sigmaHatWrap();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sigmaHatWrap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SigmaProcess_sigmaHatWrap__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SigmaProcess_sigmaHatWrap__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SigmaProcess_sigmaHatWrap__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaProcess_sigmaHatWrap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaProcess::sigmaHatWrap(int,int)\n"
    "    Pythia8::SigmaProcess::sigmaHatWrap(int)\n"
    "    Pythia8::SigmaProcess::sigmaHatWrap()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sigmaPDF__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SigmaProcess_sigmaPDF",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sigmaPDF" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_sigmaPDF" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_sigmaPDF" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaProcess_sigmaPDF" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaProcess_sigmaPDF" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaProcess_sigmaPDF" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::SigmaProcess::sigmaPDF(arg2,arg3,arg4,arg5,arg6);
    } else {
      result = (double)(arg1)->sigmaPDF(arg2,arg3,arg4,arg5,arg6);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sigmaPDF__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaProcess_sigmaPDF",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sigmaPDF" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_sigmaPDF" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_sigmaPDF" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaProcess_sigmaPDF" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaProcess_sigmaPDF" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::SigmaProcess::sigmaPDF(arg2,arg3,arg4,arg5);
    } else {
      result = (double)(arg1)->sigmaPDF(arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sigmaPDF__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaProcess_sigmaPDF",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sigmaPDF" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_sigmaPDF" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_sigmaPDF" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaProcess_sigmaPDF" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::SigmaProcess::sigmaPDF(arg2,arg3,arg4);
    } else {
      result = (double)(arg1)->sigmaPDF(arg2,arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sigmaPDF__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaProcess_sigmaPDF",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sigmaPDF" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_sigmaPDF" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_sigmaPDF" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::SigmaProcess::sigmaPDF(arg2,arg3);
    } else {
      result = (double)(arg1)->sigmaPDF(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sigmaPDF__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_sigmaPDF",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sigmaPDF" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_sigmaPDF" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::SigmaProcess::sigmaPDF(arg2);
    } else {
      result = (double)(arg1)->sigmaPDF(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sigmaPDF__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_sigmaPDF",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sigmaPDF" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::SigmaProcess::sigmaPDF();
    } else {
      result = (double)(arg1)->sigmaPDF();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sigmaPDF(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SigmaProcess_sigmaPDF__SWIG_5(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SigmaProcess_sigmaPDF__SWIG_4(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SigmaProcess_sigmaPDF__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SigmaProcess_sigmaPDF__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SigmaProcess_sigmaPDF__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SigmaProcess_sigmaPDF__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaProcess_sigmaPDF'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaProcess::sigmaPDF(bool,bool,bool,double,double)\n"
    "    Pythia8::SigmaProcess::sigmaPDF(bool,bool,bool,double)\n"
    "    Pythia8::SigmaProcess::sigmaPDF(bool,bool,bool)\n"
    "    Pythia8::SigmaProcess::sigmaPDF(bool,bool)\n"
    "    Pythia8::SigmaProcess::sigmaPDF(bool)\n"
    "    Pythia8::SigmaProcess::sigmaPDF()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_pickInState__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaProcess_pickInState",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_pickInState" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_pickInState" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_pickInState" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->pickInState(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_pickInState__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_pickInState",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_pickInState" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_pickInState" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->pickInState(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_pickInState__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_pickInState",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_pickInState" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  (arg1)->pickInState();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_pickInState(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SigmaProcess_pickInState__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SigmaProcess_pickInState__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SigmaProcess_pickInState__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaProcess_pickInState'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaProcess::pickInState(int,int)\n"
    "    Pythia8::SigmaProcess::pickInState(int)\n"
    "    Pythia8::SigmaProcess::pickInState()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_setIdColAcol" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::SigmaProcess::setIdColAcol();
    } else {
      (arg1)->setIdColAcol();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_final2KinMPI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  int arg3 ;
  Pythia8::Vec4 arg4 ;
  Pythia8::Vec4 arg5 ;
  double arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:SigmaProcess_final2KinMPI",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_final2KinMPI" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_final2KinMPI" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_final2KinMPI" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SigmaProcess_final2KinMPI" "', argument " "4"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaProcess_final2KinMPI" "', argument " "4"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SigmaProcess_final2KinMPI" "', argument " "5"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaProcess_final2KinMPI" "', argument " "5"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaProcess_final2KinMPI" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SigmaProcess_final2KinMPI" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::SigmaProcess::final2KinMPI(arg2,arg3,arg4,arg5,arg6,arg7);
    } else {
      result = (bool)(arg1)->final2KinMPI(arg2,arg3,arg4,arg5,arg6,arg7);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_final2KinMPI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  int arg3 ;
  Pythia8::Vec4 arg4 ;
  Pythia8::Vec4 arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SigmaProcess_final2KinMPI",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_final2KinMPI" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_final2KinMPI" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_final2KinMPI" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SigmaProcess_final2KinMPI" "', argument " "4"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaProcess_final2KinMPI" "', argument " "4"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SigmaProcess_final2KinMPI" "', argument " "5"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaProcess_final2KinMPI" "', argument " "5"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaProcess_final2KinMPI" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::SigmaProcess::final2KinMPI(arg2,arg3,arg4,arg5,arg6);
    } else {
      result = (bool)(arg1)->final2KinMPI(arg2,arg3,arg4,arg5,arg6);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_final2KinMPI__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  int arg3 ;
  Pythia8::Vec4 arg4 ;
  Pythia8::Vec4 arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaProcess_final2KinMPI",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_final2KinMPI" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_final2KinMPI" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_final2KinMPI" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SigmaProcess_final2KinMPI" "', argument " "4"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaProcess_final2KinMPI" "', argument " "4"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SigmaProcess_final2KinMPI" "', argument " "5"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaProcess_final2KinMPI" "', argument " "5"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::SigmaProcess::final2KinMPI(arg2,arg3,arg4,arg5);
    } else {
      result = (bool)(arg1)->final2KinMPI(arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_final2KinMPI__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  int arg3 ;
  Pythia8::Vec4 arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaProcess_final2KinMPI",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_final2KinMPI" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_final2KinMPI" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_final2KinMPI" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SigmaProcess_final2KinMPI" "', argument " "4"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaProcess_final2KinMPI" "', argument " "4"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::SigmaProcess::final2KinMPI(arg2,arg3,arg4);
    } else {
      result = (bool)(arg1)->final2KinMPI(arg2,arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_final2KinMPI__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaProcess_final2KinMPI",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_final2KinMPI" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_final2KinMPI" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_final2KinMPI" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::SigmaProcess::final2KinMPI(arg2,arg3);
    } else {
      result = (bool)(arg1)->final2KinMPI(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_final2KinMPI__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_final2KinMPI",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_final2KinMPI" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_final2KinMPI" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::SigmaProcess::final2KinMPI(arg2);
    } else {
      result = (bool)(arg1)->final2KinMPI(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_final2KinMPI__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_final2KinMPI",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_final2KinMPI" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::SigmaProcess::final2KinMPI();
    } else {
      result = (bool)(arg1)->final2KinMPI();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_final2KinMPI(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SigmaProcess_final2KinMPI__SWIG_6(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SigmaProcess_final2KinMPI__SWIG_5(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SigmaProcess_final2KinMPI__SWIG_4(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SigmaProcess_final2KinMPI__SWIG_3(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SigmaProcess_final2KinMPI__SWIG_2(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SigmaProcess_final2KinMPI__SWIG_1(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SigmaProcess_final2KinMPI__SWIG_0(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaProcess_final2KinMPI'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaProcess::final2KinMPI(int,int,Pythia8::Vec4,Pythia8::Vec4,double,double)\n"
    "    Pythia8::SigmaProcess::final2KinMPI(int,int,Pythia8::Vec4,Pythia8::Vec4,double)\n"
    "    Pythia8::SigmaProcess::final2KinMPI(int,int,Pythia8::Vec4,Pythia8::Vec4)\n"
    "    Pythia8::SigmaProcess::final2KinMPI(int,int,Pythia8::Vec4)\n"
    "    Pythia8::SigmaProcess::final2KinMPI(int,int)\n"
    "    Pythia8::SigmaProcess::final2KinMPI(int)\n"
    "    Pythia8::SigmaProcess::final2KinMPI()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_weightDecayFlav(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_weightDecayFlav",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_weightDecayFlav" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_weightDecayFlav" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaProcess_weightDecayFlav" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::SigmaProcess::weightDecayFlav(*arg2);
    } else {
      result = (double)(arg1)->weightDecayFlav(*arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaProcess_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_weightDecay" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaProcess_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaProcess_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::SigmaProcess::weightDecay(*arg2,arg3,arg4);
    } else {
      result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_setScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_setScale",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_setScale" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::SigmaProcess::setScale();
    } else {
      (arg1)->setScale();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_name" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = ((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::name();
    } else {
      result = ((Pythia8::SigmaProcess const *)arg1)->name();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_code" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::code();
    } else {
      result = (int)((Pythia8::SigmaProcess const *)arg1)->code();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_nFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_nFinal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_nFinal" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::nFinal();
    } else {
      result = (int)((Pythia8::SigmaProcess const *)arg1)->nFinal();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_inFlux" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = ((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::inFlux();
    } else {
      result = ((Pythia8::SigmaProcess const *)arg1)->inFlux();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_convert2mb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_convert2mb",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_convert2mb" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::convert2mb();
    } else {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->convert2mb();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_convertM2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_convertM2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_convertM2" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::convertM2();
    } else {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->convertM2();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_isLHA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_isLHA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_isLHA" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::isLHA();
    } else {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->isLHA();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_isNonDiff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_isNonDiff",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_isNonDiff" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::isNonDiff();
    } else {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->isNonDiff();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_isResolved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_isResolved",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_isResolved" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::isResolved();
    } else {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->isResolved();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_isDiffA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_isDiffA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_isDiffA" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::isDiffA();
    } else {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->isDiffA();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_isDiffB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_isDiffB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_isDiffB" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::isDiffB();
    } else {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->isDiffB();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_isDiffC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_isDiffC",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_isDiffC" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::isDiffC();
    } else {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->isDiffC();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_isSUSY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_isSUSY",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_isSUSY" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::isSUSY();
    } else {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->isSUSY();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_allowNegativeSigma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_allowNegativeSigma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_allowNegativeSigma" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::allowNegativeSigma();
    } else {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->allowNegativeSigma();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_id3Mass" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::id3Mass();
    } else {
      result = (int)((Pythia8::SigmaProcess const *)arg1)->id3Mass();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_id4Mass" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::id4Mass();
    } else {
      result = (int)((Pythia8::SigmaProcess const *)arg1)->id4Mass();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_id5Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_id5Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_id5Mass" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::id5Mass();
    } else {
      result = (int)((Pythia8::SigmaProcess const *)arg1)->id5Mass();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_resonanceA" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::resonanceA();
    } else {
      result = (int)((Pythia8::SigmaProcess const *)arg1)->resonanceA();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_resonanceB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_resonanceB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_resonanceB" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::resonanceB();
    } else {
      result = (int)((Pythia8::SigmaProcess const *)arg1)->resonanceB();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_isSChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_isSChannel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_isSChannel" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::isSChannel();
    } else {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->isSChannel();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_idSChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_idSChannel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_idSChannel" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::idSChannel();
    } else {
      result = (int)((Pythia8::SigmaProcess const *)arg1)->idSChannel();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_isQCD3body(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_isQCD3body",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_isQCD3body" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::isQCD3body();
    } else {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->isQCD3body();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_idTchan1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_idTchan1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_idTchan1" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::idTchan1();
    } else {
      result = (int)((Pythia8::SigmaProcess const *)arg1)->idTchan1();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_idTchan2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_idTchan2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_idTchan2" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::idTchan2();
    } else {
      result = (int)((Pythia8::SigmaProcess const *)arg1)->idTchan2();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_tChanFracPow1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_tChanFracPow1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_tChanFracPow1" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::tChanFracPow1();
    } else {
      result = (double)((Pythia8::SigmaProcess const *)arg1)->tChanFracPow1();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_tChanFracPow2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_tChanFracPow2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_tChanFracPow2" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::tChanFracPow2();
    } else {
      result = (double)((Pythia8::SigmaProcess const *)arg1)->tChanFracPow2();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_useMirrorWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_useMirrorWeight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_useMirrorWeight" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::useMirrorWeight();
    } else {
      result = (bool)((Pythia8::SigmaProcess const *)arg1)->useMirrorWeight();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_gmZmode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_gmZmode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_gmZmode" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)((Pythia8::SigmaProcess const *)arg1)->Pythia8::SigmaProcess::gmZmode();
    } else {
      result = (int)((Pythia8::SigmaProcess const *)arg1)->gmZmode();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_swappedTU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_swappedTU",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_swappedTU" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  result = (bool)((Pythia8::SigmaProcess const *)arg1)->swappedTU();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_id",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_id" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_id" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::SigmaProcess const *)arg1)->id(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_col(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_col",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_col" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_col" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::SigmaProcess const *)arg1)->col(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_acol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_acol",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_acol" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_acol" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::SigmaProcess const *)arg1)->acol(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_m(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_m",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_m" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_m" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::SigmaProcess const *)arg1)->m(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_getParton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Particle result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_getParton",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_getParton" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_getParton" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((Pythia8::SigmaProcess const *)arg1)->getParton(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Particle(static_cast< const Pythia8::Particle& >(result))), SWIGTYPE_p_Pythia8__Particle, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_Q2Ren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_Q2Ren",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_Q2Ren" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  result = (double)((Pythia8::SigmaProcess const *)arg1)->Q2Ren();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_alphaEMRen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_alphaEMRen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_alphaEMRen" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  result = (double)((Pythia8::SigmaProcess const *)arg1)->alphaEMRen();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_alphaSRen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_alphaSRen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_alphaSRen" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  result = (double)((Pythia8::SigmaProcess const *)arg1)->alphaSRen();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_Q2Fac(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_Q2Fac",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_Q2Fac" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  result = (double)((Pythia8::SigmaProcess const *)arg1)->Q2Fac();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_pdf1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_pdf1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_pdf1" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  result = (double)((Pythia8::SigmaProcess const *)arg1)->pdf1();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_pdf2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_pdf2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_pdf2" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  result = (double)((Pythia8::SigmaProcess const *)arg1)->pdf2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_thetaMPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_thetaMPI",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_thetaMPI" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  result = (double)((Pythia8::SigmaProcess const *)arg1)->thetaMPI();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_phiMPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_phiMPI",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_phiMPI" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  result = (double)((Pythia8::SigmaProcess const *)arg1)->phiMPI();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sHBetaMPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_sHBetaMPI",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sHBetaMPI" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  result = (double)((Pythia8::SigmaProcess const *)arg1)->sHBetaMPI();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_pT2MPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_pT2MPI",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_pT2MPI" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  result = (double)((Pythia8::SigmaProcess const *)arg1)->pT2MPI();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_pTMPIFin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_pTMPIFin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_pTMPIFin" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  result = (double)((Pythia8::SigmaProcess const *)arg1)->pTMPIFin();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_saveKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_saveKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_saveKin" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  (arg1)->saveKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_loadKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_loadKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_loadKin" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  (arg1)->loadKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_swapKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_swapKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_swapKin" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  (arg1)->swapKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SigmaProcess(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::SigmaProcess *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SigmaProcess",&obj0)) SWIG_fail;
  arg1 = obj0;
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (Pythia8::SigmaProcess *)new SwigDirector_SigmaProcess(arg1); 
  } else {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
    SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SigmaProcess, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int Swig_var_SigmaProcess_CONVERT2MB_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SigmaProcess_CONVERT2MB is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SigmaProcess_CONVERT2MB_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(SwigDirector_SigmaProcess::CONVERT2MB));
  return pyobj;
}


SWIGINTERN int Swig_var_SigmaProcess_MASSMARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SigmaProcess_MASSMARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SigmaProcess_MASSMARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(SwigDirector_SigmaProcess::MASSMARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_SigmaProcess_COMPRELERR_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SigmaProcess_COMPRELERR is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SigmaProcess_COMPRELERR_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(SwigDirector_SigmaProcess::COMPRELERR));
  return pyobj;
}


SWIGINTERN int Swig_var_SigmaProcess_NCOMPSTEP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable SigmaProcess_NCOMPSTEP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_SigmaProcess_NCOMPSTEP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(SwigDirector_SigmaProcess::NCOMPSTEP));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_infoPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_infoPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_infoPtr_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_infoPtr_set" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->infoPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_infoPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  Pythia8::Info *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_infoPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_infoPtr_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (Pythia8::Info *) (darg->infoPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_settingsPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::Settings *arg2 = (Pythia8::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_settingsPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_settingsPtr_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Settings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_settingsPtr_set" "', argument " "2"" of type '" "Pythia8::Settings *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->settingsPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_settingsPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  Pythia8::Settings *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_settingsPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_settingsPtr_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (Pythia8::Settings *) (darg->settingsPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_particleDataPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::ParticleData *arg2 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_particleDataPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_particleDataPtr_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ParticleData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_particleDataPtr_set" "', argument " "2"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ParticleData * >(argp2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->particleDataPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_particleDataPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  Pythia8::ParticleData *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_particleDataPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_particleDataPtr_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (Pythia8::ParticleData *) (darg->particleDataPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_rndmPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::Rndm *arg2 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_rndmPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_rndmPtr_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Rndm, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_rndmPtr_set" "', argument " "2"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Rndm * >(argp2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->rndmPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_rndmPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  Pythia8::Rndm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_rndmPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_rndmPtr_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (Pythia8::Rndm *) (darg->rndmPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_beamAPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::BeamParticle *arg2 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_beamAPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_beamAPtr_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__BeamParticle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_beamAPtr_set" "', argument " "2"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::BeamParticle * >(argp2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->beamAPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_beamAPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  Pythia8::BeamParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_beamAPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_beamAPtr_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (Pythia8::BeamParticle *) (darg->beamAPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_beamBPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::BeamParticle *arg2 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_beamBPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_beamBPtr_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__BeamParticle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_beamBPtr_set" "', argument " "2"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::BeamParticle * >(argp2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->beamBPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_beamBPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  Pythia8::BeamParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_beamBPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_beamBPtr_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (Pythia8::BeamParticle *) (darg->beamBPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_couplingsPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::Couplings *arg2 = (Pythia8::Couplings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_couplingsPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_couplingsPtr_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Couplings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_couplingsPtr_set" "', argument " "2"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Couplings * >(argp2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->couplingsPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_couplingsPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  Pythia8::Couplings *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_couplingsPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_couplingsPtr_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (Pythia8::Couplings *) (darg->couplingsPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sigmaTotPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::SigmaTotal *arg2 = (Pythia8::SigmaTotal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_sigmaTotPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sigmaTotPtr_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__SigmaTotal, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_sigmaTotPtr_set" "', argument " "2"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::SigmaTotal * >(argp2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->sigmaTotPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sigmaTotPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  Pythia8::SigmaTotal *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_sigmaTotPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sigmaTotPtr_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (Pythia8::SigmaTotal *) (darg->sigmaTotPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_slhaPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::SusyLesHouches *arg2 = (Pythia8::SusyLesHouches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_slhaPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_slhaPtr_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__SusyLesHouches, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_slhaPtr_set" "', argument " "2"" of type '" "Pythia8::SusyLesHouches *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::SusyLesHouches * >(argp2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->slhaPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_slhaPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  Pythia8::SusyLesHouches *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_slhaPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_slhaPtr_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (Pythia8::SusyLesHouches *) (darg->slhaPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SusyLesHouches, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_lhaUpPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::LHAup *arg2 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_lhaUpPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_lhaUpPtr_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHAup, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_lhaUpPtr_set" "', argument " "2"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHAup * >(argp2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->lhaUpPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_lhaUpPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  Pythia8::LHAup *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_lhaUpPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_lhaUpPtr_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (Pythia8::LHAup *) (darg->lhaUpPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_nQuarkIn_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_nQuarkIn_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_nQuarkIn_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_nQuarkIn_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->nQuarkIn = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_nQuarkIn_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_nQuarkIn_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_nQuarkIn_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (int) (darg->nQuarkIn);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_renormScale1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_renormScale1_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_renormScale1_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_renormScale1_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->renormScale1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_renormScale1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_renormScale1_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_renormScale1_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (int) (darg->renormScale1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_renormScale2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_renormScale2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_renormScale2_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_renormScale2_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->renormScale2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_renormScale2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_renormScale2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_renormScale2_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (int) (darg->renormScale2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_renormScale3_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_renormScale3_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_renormScale3_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_renormScale3_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->renormScale3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_renormScale3_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_renormScale3_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_renormScale3_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (int) (darg->renormScale3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_renormScale3VV_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_renormScale3VV_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_renormScale3VV_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_renormScale3VV_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->renormScale3VV = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_renormScale3VV_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_renormScale3VV_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_renormScale3VV_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (int) (darg->renormScale3VV);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_factorScale1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_factorScale1_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_factorScale1_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_factorScale1_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->factorScale1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_factorScale1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_factorScale1_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_factorScale1_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (int) (darg->factorScale1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_factorScale2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_factorScale2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_factorScale2_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_factorScale2_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->factorScale2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_factorScale2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_factorScale2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_factorScale2_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (int) (darg->factorScale2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_factorScale3_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_factorScale3_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_factorScale3_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_factorScale3_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->factorScale3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_factorScale3_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_factorScale3_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_factorScale3_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (int) (darg->factorScale3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_factorScale3VV_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_factorScale3VV_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_factorScale3VV_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_factorScale3VV_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->factorScale3VV = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_factorScale3VV_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_factorScale3VV_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_factorScale3VV_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (int) (darg->factorScale3VV);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_Kfactor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_Kfactor_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_Kfactor_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_Kfactor_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->Kfactor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_Kfactor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_Kfactor_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_Kfactor_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->Kfactor);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_mcME_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_mcME_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_mcME_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_mcME_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->mcME = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_mcME_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_mcME_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_mcME_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->mcME);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_mbME_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_mbME_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_mbME_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_mbME_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->mbME = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_mbME_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_mbME_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_mbME_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->mbME);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_mmuME_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_mmuME_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_mmuME_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_mmuME_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->mmuME = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_mmuME_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_mmuME_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_mmuME_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->mmuME);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_mtauME_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_mtauME_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_mtauME_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_mtauME_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->mtauME = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_mtauME_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_mtauME_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_mtauME_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->mtauME);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_renormMultFac_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_renormMultFac_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_renormMultFac_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_renormMultFac_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->renormMultFac = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_renormMultFac_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_renormMultFac_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_renormMultFac_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->renormMultFac);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_renormFixScale_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_renormFixScale_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_renormFixScale_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_renormFixScale_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->renormFixScale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_renormFixScale_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_renormFixScale_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_renormFixScale_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->renormFixScale);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_factorMultFac_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_factorMultFac_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_factorMultFac_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_factorMultFac_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->factorMultFac = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_factorMultFac_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_factorMultFac_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_factorMultFac_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->factorMultFac);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_factorFixScale_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_factorFixScale_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_factorFixScale_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_factorFixScale_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->factorFixScale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_factorFixScale_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_factorFixScale_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_factorFixScale_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->factorFixScale);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_higgsH1parity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_higgsH1parity_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_higgsH1parity_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_higgsH1parity_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->higgsH1parity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_higgsH1parity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_higgsH1parity_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_higgsH1parity_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (int) (darg->higgsH1parity);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_higgsH2parity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_higgsH2parity_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_higgsH2parity_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_higgsH2parity_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->higgsH2parity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_higgsH2parity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_higgsH2parity_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_higgsH2parity_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (int) (darg->higgsH2parity);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_higgsA3parity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_higgsA3parity_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_higgsA3parity_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_higgsA3parity_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->higgsA3parity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_higgsA3parity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_higgsA3parity_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_higgsA3parity_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (int) (darg->higgsA3parity);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_higgsH1eta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_higgsH1eta_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_higgsH1eta_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_higgsH1eta_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->higgsH1eta = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_higgsH1eta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_higgsH1eta_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_higgsH1eta_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->higgsH1eta);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_higgsH2eta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_higgsH2eta_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_higgsH2eta_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_higgsH2eta_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->higgsH2eta = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_higgsH2eta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_higgsH2eta_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_higgsH2eta_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->higgsH2eta);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_higgsA3eta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_higgsA3eta_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_higgsA3eta_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_higgsA3eta_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->higgsA3eta = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_higgsA3eta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_higgsA3eta_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_higgsA3eta_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->higgsA3eta);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_higgsH1phi_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_higgsH1phi_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_higgsH1phi_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_higgsH1phi_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->higgsH1phi = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_higgsH1phi_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_higgsH1phi_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_higgsH1phi_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->higgsH1phi);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_higgsH2phi_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_higgsH2phi_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_higgsH2phi_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_higgsH2phi_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->higgsH2phi = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_higgsH2phi_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_higgsH2phi_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_higgsH2phi_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->higgsH2phi);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_higgsA3phi_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_higgsA3phi_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_higgsA3phi_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_higgsA3phi_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->higgsA3phi = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_higgsA3phi_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_higgsA3phi_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_higgsA3phi_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->higgsA3phi);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_idA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_idA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_idA_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_idA_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->idA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_idA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_idA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_idA_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (int) (darg->idA);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_idB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_idB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_idB_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_idB_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->idB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_idB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_idB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_idB_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (int) (darg->idB);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_mA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_mA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_mA_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_mA_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->mA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_mA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_mA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_mA_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->mA);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_mB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_mB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_mB_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_mB_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->mB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_mB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_mB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_mB_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->mB);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_isLeptonA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_isLeptonA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_isLeptonA_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_isLeptonA_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->isLeptonA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_isLeptonA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_isLeptonA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_isLeptonA_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (bool) (darg->isLeptonA);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_isLeptonB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_isLeptonB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_isLeptonB_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_isLeptonB_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->isLeptonB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_isLeptonB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_isLeptonB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_isLeptonB_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (bool) (darg->isLeptonB);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_hasLeptonBeams_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_hasLeptonBeams_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_hasLeptonBeams_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_hasLeptonBeams_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->hasLeptonBeams = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_hasLeptonBeams_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_hasLeptonBeams_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_hasLeptonBeams_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (bool) (darg->hasLeptonBeams);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_lepton2gammaA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_lepton2gammaA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_lepton2gammaA_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_lepton2gammaA_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->lepton2gammaA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_lepton2gammaA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_lepton2gammaA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_lepton2gammaA_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (bool) (darg->lepton2gammaA);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_lepton2gammaB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_lepton2gammaB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_lepton2gammaB_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_lepton2gammaB_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->lepton2gammaB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_lepton2gammaB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_lepton2gammaB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_lepton2gammaB_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (bool) (darg->lepton2gammaB);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_inBeamA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  std::vector< Pythia8::InBeam,std::allocator< Pythia8::InBeam > > *arg2 = (std::vector< Pythia8::InBeam,std::allocator< Pythia8::InBeam > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_inBeamA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_inBeamA_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_Pythia8__InBeam_std__allocatorT_Pythia8__InBeam_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_inBeamA_set" "', argument " "2"" of type '" "std::vector< Pythia8::InBeam,std::allocator< Pythia8::InBeam > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::InBeam,std::allocator< Pythia8::InBeam > > * >(argp2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->inBeamA = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_inBeamA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  std::vector< Pythia8::InBeam,std::allocator< Pythia8::InBeam > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_inBeamA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_inBeamA_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (std::vector< Pythia8::InBeam,std::allocator< Pythia8::InBeam > > *)& (darg->inBeamA);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__InBeam_std__allocatorT_Pythia8__InBeam_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_inBeamB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  std::vector< Pythia8::InBeam,std::allocator< Pythia8::InBeam > > *arg2 = (std::vector< Pythia8::InBeam,std::allocator< Pythia8::InBeam > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_inBeamB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_inBeamB_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_Pythia8__InBeam_std__allocatorT_Pythia8__InBeam_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_inBeamB_set" "', argument " "2"" of type '" "std::vector< Pythia8::InBeam,std::allocator< Pythia8::InBeam > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::InBeam,std::allocator< Pythia8::InBeam > > * >(argp2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->inBeamB = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_inBeamB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  std::vector< Pythia8::InBeam,std::allocator< Pythia8::InBeam > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_inBeamB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_inBeamB_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (std::vector< Pythia8::InBeam,std::allocator< Pythia8::InBeam > > *)& (darg->inBeamB);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__InBeam_std__allocatorT_Pythia8__InBeam_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_addBeamA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_addBeamA",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_addBeamA" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_addBeamA" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  (darg)->addBeamA(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_addBeamB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_addBeamB",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_addBeamB" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_addBeamB" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  (darg)->addBeamB(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sizeBeamA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_sizeBeamA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sizeBeamA" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (int)((SwigDirector_SigmaProcess const *)darg)->sizeBeamA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sizeBeamB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_sizeBeamB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sizeBeamB" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (int)((SwigDirector_SigmaProcess const *)darg)->sizeBeamB();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_inPair_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  std::vector< Pythia8::InPair,std::allocator< Pythia8::InPair > > *arg2 = (std::vector< Pythia8::InPair,std::allocator< Pythia8::InPair > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_inPair_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_inPair_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_Pythia8__InPair_std__allocatorT_Pythia8__InPair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_inPair_set" "', argument " "2"" of type '" "std::vector< Pythia8::InPair,std::allocator< Pythia8::InPair > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::InPair,std::allocator< Pythia8::InPair > > * >(argp2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->inPair = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_inPair_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  std::vector< Pythia8::InPair,std::allocator< Pythia8::InPair > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_inPair_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_inPair_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (std::vector< Pythia8::InPair,std::allocator< Pythia8::InPair > > *)& (darg->inPair);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__InPair_std__allocatorT_Pythia8__InPair_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_addPair(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaProcess_addPair",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_addPair" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_addPair" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_addPair" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  (darg)->addPair(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sizePair(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_sizePair",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sizePair" "', argument " "1"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (int)((SwigDirector_SigmaProcess const *)darg)->sizePair();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_mH_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_mH_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_mH_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_mH_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->mH = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_mH_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_mH_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_mH_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->mH);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sH_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_sH_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sH_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_sH_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->sH = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sH_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_sH_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sH_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->sH);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sH2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_sH2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sH2_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_sH2_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->sH2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sH2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_sH2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sH2_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->sH2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_Q2RenSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_Q2RenSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_Q2RenSave_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_Q2RenSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->Q2RenSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_Q2RenSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_Q2RenSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_Q2RenSave_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->Q2RenSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_alpEM_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_alpEM_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_alpEM_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_alpEM_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->alpEM = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_alpEM_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_alpEM_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_alpEM_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->alpEM);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_alpS_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_alpS_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_alpS_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_alpS_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->alpS = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_alpS_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_alpS_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_alpS_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->alpS);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_Q2FacSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_Q2FacSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_Q2FacSave_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_Q2FacSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->Q2FacSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_Q2FacSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_Q2FacSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_Q2FacSave_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->Q2FacSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_x1Save_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_x1Save_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_x1Save_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_x1Save_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->x1Save = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_x1Save_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_x1Save_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_x1Save_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->x1Save);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_x2Save_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_x2Save_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_x2Save_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_x2Save_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->x2Save = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_x2Save_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_x2Save_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_x2Save_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->x2Save);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_pdf1Save_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_pdf1Save_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_pdf1Save_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_pdf1Save_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->pdf1Save = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_pdf1Save_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_pdf1Save_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_pdf1Save_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->pdf1Save);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_pdf2Save_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_pdf2Save_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_pdf2Save_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_pdf2Save_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->pdf2Save = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_pdf2Save_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_pdf2Save_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_pdf2Save_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->pdf2Save);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sigmaSumSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_sigmaSumSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sigmaSumSave_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_sigmaSumSave_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->sigmaSumSave = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sigmaSumSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_sigmaSumSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sigmaSumSave_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->sigmaSumSave);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_id1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_id1_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_id1_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_id1_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->id1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_id1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_id1_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_id1_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (int) (darg->id1);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_id2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_id2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_id2_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_id2_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->id2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_id2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_id2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_id2_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (int) (darg->id2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_id3_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_id3_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_id3_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_id3_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->id3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_id3_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_id3_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_id3_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (int) (darg->id3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_id4_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_id4_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_id4_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_id4_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->id4 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_id4_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_id4_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_id4_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (int) (darg->id4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_id5_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_id5_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_id5_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_id5_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->id5 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_id5_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_id5_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_id5_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (int) (darg->id5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_idSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_idSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_idSave_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_idSave_set" "', argument " "2"" of type '" "int [12]""'"); 
  } 
  arg2 = reinterpret_cast< int * >(argp2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)12; ++ii) *(int *)&darg->idSave[ii] = *((int *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""idSave""' of type '""int [12]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_idSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  int *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_idSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_idSave_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (int *)(int *) (darg->idSave);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_colSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_colSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_colSave_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_colSave_set" "', argument " "2"" of type '" "int [12]""'"); 
  } 
  arg2 = reinterpret_cast< int * >(argp2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)12; ++ii) *(int *)&darg->colSave[ii] = *((int *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""colSave""' of type '""int [12]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_colSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  int *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_colSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_colSave_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (int *)(int *) (darg->colSave);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_acolSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_acolSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_acolSave_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_acolSave_set" "', argument " "2"" of type '" "int [12]""'"); 
  } 
  arg2 = reinterpret_cast< int * >(argp2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)12; ++ii) *(int *)&darg->acolSave[ii] = *((int *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""acolSave""' of type '""int [12]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_acolSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  int *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_acolSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_acolSave_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (int *)(int *) (darg->acolSave);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_mSave_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_mSave_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_mSave_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_mSave_set" "', argument " "2"" of type '" "double [12]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)12; ++ii) *(double *)&darg->mSave[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""mSave""' of type '""double [12]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_mSave_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_mSave_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_mSave_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double *)(double *) (darg->mSave);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_cosTheta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_cosTheta_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_cosTheta_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_cosTheta_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->cosTheta = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_cosTheta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_cosTheta_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_cosTheta_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->cosTheta);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sinTheta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_sinTheta_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sinTheta_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_sinTheta_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->sinTheta = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sinTheta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_sinTheta_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sinTheta_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->sinTheta);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_phi_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_phi_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_phi_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_phi_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->phi = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_phi_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_phi_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_phi_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->phi);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sHMass_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_sHMass_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sHMass_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_sHMass_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->sHMass = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sHMass_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_sHMass_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sHMass_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->sHMass);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sHBeta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_sHBeta_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sHBeta_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_sHBeta_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->sHBeta = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sHBeta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_sHBeta_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sHBeta_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->sHBeta);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_pT2Mass_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_pT2Mass_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_pT2Mass_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_pT2Mass_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->pT2Mass = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_pT2Mass_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_pT2Mass_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_pT2Mass_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->pT2Mass);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_pTFin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_pTFin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_pTFin_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_pTFin_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->pTFin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_pTFin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_pTFin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_pTFin_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->pTFin);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_parton_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::Particle *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_parton_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_parton_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_parton_set" "', argument " "2"" of type '" "Pythia8::Particle [12]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::Particle * >(argp2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)12; ++ii) *(Pythia8::Particle *)&darg->parton[ii] = *((Pythia8::Particle *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""parton""' of type '""Pythia8::Particle [12]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_parton_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_parton_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_parton_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (Pythia8::Particle *)(Pythia8::Particle *) (darg->parton);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_partonT_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::Particle *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_partonT_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_partonT_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_partonT_set" "', argument " "2"" of type '" "Pythia8::Particle [12]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::Particle * >(argp2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)12; ++ii) *(Pythia8::Particle *)&darg->partonT[ii] = *((Pythia8::Particle *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""partonT""' of type '""Pythia8::Particle [12]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_partonT_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  Pythia8::Particle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_partonT_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_partonT_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (Pythia8::Particle *)(Pythia8::Particle *) (darg->partonT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_mSaveT_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_mSaveT_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_mSaveT_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_mSaveT_set" "', argument " "2"" of type '" "double [12]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)12; ++ii) *(double *)&darg->mSaveT[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""mSaveT""' of type '""double [12]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_mSaveT_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_mSaveT_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_mSaveT_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double *)(double *) (darg->mSaveT);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_pTFinT_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_pTFinT_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_pTFinT_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_pTFinT_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->pTFinT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_pTFinT_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_pTFinT_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_pTFinT_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->pTFinT);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_cosThetaT_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_cosThetaT_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_cosThetaT_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_cosThetaT_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->cosThetaT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_cosThetaT_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_cosThetaT_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_cosThetaT_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->cosThetaT);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sinThetaT_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_sinThetaT_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sinThetaT_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_sinThetaT_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->sinThetaT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_sinThetaT_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_sinThetaT_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_sinThetaT_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->sinThetaT);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_phiT_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_phiT_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_phiT_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_phiT_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->phiT = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_phiT_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_phiT_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_phiT_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double) (darg->phiT);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_setupForME(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigDirector_SigmaProcess *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_setupForME",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_setupForME" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  if (!director || !(director->swig_get_inner("setupForME"))) {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member setupForME");
    SWIG_fail;
  }
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
    if (upcall) {
      result = (bool)(darg)->setupForMESwigPublic();
    } else {
      result = (bool)(darg)->setupForME();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_setupForMEin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_setupForMEin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_setupForMEin" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (bool)(darg)->setupForMEin();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_mME_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_mME_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_mME_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_mME_set" "', argument " "2"" of type '" "double [12]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)12; ++ii) *(double *)&darg->mME[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""mME""' of type '""double [12]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_mME_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_mME_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_mME_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double *)(double *) (darg->mME);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_pME_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::Vec4 *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_pME_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_pME_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_pME_set" "', argument " "2"" of type '" "Pythia8::Vec4 [12]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)12; ++ii) *(Pythia8::Vec4 *)&darg->pME[ii] = *((Pythia8::Vec4 *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""pME""' of type '""Pythia8::Vec4 [12]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_pME_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_pME_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_pME_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (Pythia8::Vec4 *)(Pythia8::Vec4 *) (darg->pME);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_swapTU_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_swapTU_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_swapTU_set" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_swapTU_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  if (arg1) darg->swapTU = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_swapTU_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_swapTU_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_swapTU_get" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (bool) (darg->swapTU);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_setId__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SigmaProcess_setId",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_setId" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_setId" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_setId" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaProcess_setId" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaProcess_setId" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaProcess_setId" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  (darg)->setId(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_setId__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaProcess_setId",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_setId" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_setId" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_setId" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaProcess_setId" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaProcess_setId" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  (darg)->setId(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_setId__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaProcess_setId",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_setId" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_setId" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_setId" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaProcess_setId" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  (darg)->setId(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_setId__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaProcess_setId",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_setId" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_setId" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_setId" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  (darg)->setId(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_setId__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_setId",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_setId" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_setId" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  (darg)->setId(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_setId__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_setId",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_setId" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  (darg)->setId();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_setId(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SigmaProcess_setId__SWIG_5(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SigmaProcess_setId__SWIG_4(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SigmaProcess_setId__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SigmaProcess_setId__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SigmaProcess_setId__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SigmaProcess_setId__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaProcess_setId'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaProcess::setId(int,int,int,int,int)\n"
    "    Pythia8::SigmaProcess::setId(int,int,int,int)\n"
    "    Pythia8::SigmaProcess::setId(int,int,int)\n"
    "    Pythia8::SigmaProcess::setId(int,int)\n"
    "    Pythia8::SigmaProcess::setId(int)\n"
    "    Pythia8::SigmaProcess::setId()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_setColAcol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int arg10 ;
  int arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:SigmaProcess_setColAcol",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_setColAcol" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_setColAcol" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_setColAcol" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaProcess_setColAcol" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaProcess_setColAcol" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaProcess_setColAcol" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SigmaProcess_setColAcol" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SigmaProcess_setColAcol" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SigmaProcess_setColAcol" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "SigmaProcess_setColAcol" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "SigmaProcess_setColAcol" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  (darg)->setColAcol(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_setColAcol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:SigmaProcess_setColAcol",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_setColAcol" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_setColAcol" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_setColAcol" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaProcess_setColAcol" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaProcess_setColAcol" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaProcess_setColAcol" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SigmaProcess_setColAcol" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SigmaProcess_setColAcol" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SigmaProcess_setColAcol" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "SigmaProcess_setColAcol" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  (darg)->setColAcol(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_setColAcol__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:SigmaProcess_setColAcol",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_setColAcol" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_setColAcol" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_setColAcol" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaProcess_setColAcol" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaProcess_setColAcol" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaProcess_setColAcol" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SigmaProcess_setColAcol" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SigmaProcess_setColAcol" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SigmaProcess_setColAcol" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  (darg)->setColAcol(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_setColAcol__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:SigmaProcess_setColAcol",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_setColAcol" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_setColAcol" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_setColAcol" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaProcess_setColAcol" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaProcess_setColAcol" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaProcess_setColAcol" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SigmaProcess_setColAcol" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SigmaProcess_setColAcol" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  (darg)->setColAcol(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_setColAcol__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:SigmaProcess_setColAcol",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_setColAcol" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_setColAcol" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_setColAcol" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaProcess_setColAcol" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaProcess_setColAcol" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaProcess_setColAcol" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SigmaProcess_setColAcol" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  (darg)->setColAcol(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_setColAcol__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SigmaProcess_setColAcol",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_setColAcol" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_setColAcol" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_setColAcol" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaProcess_setColAcol" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaProcess_setColAcol" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaProcess_setColAcol" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  (darg)->setColAcol(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_setColAcol__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SigmaProcess_setColAcol",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_setColAcol" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_setColAcol" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_setColAcol" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaProcess_setColAcol" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaProcess_setColAcol" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  (darg)->setColAcol(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_setColAcol__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaProcess_setColAcol",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_setColAcol" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_setColAcol" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_setColAcol" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaProcess_setColAcol" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  (darg)->setColAcol(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_setColAcol__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaProcess_setColAcol",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_setColAcol" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_setColAcol" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_setColAcol" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  (darg)->setColAcol(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_setColAcol__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaProcess_setColAcol",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_setColAcol" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaProcess_setColAcol" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  (darg)->setColAcol(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_setColAcol__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_setColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_setColAcol" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  (darg)->setColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_setColAcol(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[12] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 11) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SigmaProcess_setColAcol__SWIG_10(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SigmaProcess_setColAcol__SWIG_9(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SigmaProcess_setColAcol__SWIG_8(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SigmaProcess_setColAcol__SWIG_7(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SigmaProcess_setColAcol__SWIG_6(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SigmaProcess_setColAcol__SWIG_5(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SigmaProcess_setColAcol__SWIG_4(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_SigmaProcess_setColAcol__SWIG_3(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_SigmaProcess_setColAcol__SWIG_2(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_SigmaProcess_setColAcol__SWIG_1(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_SigmaProcess_setColAcol__SWIG_0(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaProcess_setColAcol'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaProcess::setColAcol(int,int,int,int,int,int,int,int,int,int)\n"
    "    Pythia8::SigmaProcess::setColAcol(int,int,int,int,int,int,int,int,int)\n"
    "    Pythia8::SigmaProcess::setColAcol(int,int,int,int,int,int,int,int)\n"
    "    Pythia8::SigmaProcess::setColAcol(int,int,int,int,int,int,int)\n"
    "    Pythia8::SigmaProcess::setColAcol(int,int,int,int,int,int)\n"
    "    Pythia8::SigmaProcess::setColAcol(int,int,int,int,int)\n"
    "    Pythia8::SigmaProcess::setColAcol(int,int,int,int)\n"
    "    Pythia8::SigmaProcess::setColAcol(int,int,int)\n"
    "    Pythia8::SigmaProcess::setColAcol(int,int)\n"
    "    Pythia8::SigmaProcess::setColAcol(int)\n"
    "    Pythia8::SigmaProcess::setColAcol()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_swapColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_swapColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_swapColAcol" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  (darg)->swapColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_swapCol1234(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_swapCol1234",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_swapCol1234" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  (darg)->swapCol1234();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_swapCol12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_swapCol12",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_swapCol12" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  (darg)->swapCol12();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_swapCol34(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaProcess_swapCol34",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_swapCol34" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  (darg)->swapCol34();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_weightTopDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaProcess_weightTopDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_weightTopDecay" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_weightTopDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaProcess_weightTopDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_weightTopDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaProcess_weightTopDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double)(darg)->weightTopDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaProcess_weightHiggsDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  SwigDirector_SigmaProcess *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaProcess_weightHiggsDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaProcess_weightHiggsDecay" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaProcess_weightHiggsDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaProcess_weightHiggsDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaProcess_weightHiggsDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaProcess_weightHiggsDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  darg = dynamic_cast<SwigDirector_SigmaProcess *>(arg1);
  result = (double)(darg)->weightHiggsDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_SigmaProcess(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:disown_SigmaProcess",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_SigmaProcess" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SigmaProcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SigmaProcess, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_Sigma0Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0Process *arg1 = (Pythia8::Sigma0Process *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma0Process",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0Process, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma0Process" "', argument " "1"" of type '" "Pythia8::Sigma0Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0Process * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0Process_nFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0Process *arg1 = (Pythia8::Sigma0Process *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0Process_nFinal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0Process_nFinal" "', argument " "1"" of type '" "Pythia8::Sigma0Process const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0Process * >(argp1);
  result = (int)((Pythia8::Sigma0Process const *)arg1)->nFinal();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0Process_initFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0Process *arg1 = (Pythia8::Sigma0Process *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0Process_initFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0Process_initFlux" "', argument " "1"" of type '" "Pythia8::Sigma0Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0Process * >(argp1);
  result = (bool)(arg1)->initFlux();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0Process_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0Process *arg1 = (Pythia8::Sigma0Process *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0Process_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0Process_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma0Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0Process * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0Process_sigmaPDF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0Process *arg1 = (Pythia8::Sigma0Process *) 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Sigma0Process_sigmaPDF",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0Process_sigmaPDF" "', argument " "1"" of type '" "Pythia8::Sigma0Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0Process * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sigma0Process_sigmaPDF" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma0Process_sigmaPDF" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma0Process_sigmaPDF" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sigma0Process_sigmaPDF" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sigma0Process_sigmaPDF" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)(arg1)->sigmaPDF(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0Process_convert2mb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0Process *arg1 = (Pythia8::Sigma0Process *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0Process_convert2mb",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0Process_convert2mb" "', argument " "1"" of type '" "Pythia8::Sigma0Process const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0Process * >(argp1);
  result = (bool)((Pythia8::Sigma0Process const *)arg1)->convert2mb();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma0Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma0Process, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_Sigma1Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1Process *arg1 = (Pythia8::Sigma1Process *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma1Process",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1Process, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma1Process" "', argument " "1"" of type '" "Pythia8::Sigma1Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1Process * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1Process_nFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1Process *arg1 = (Pythia8::Sigma1Process *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1Process_nFinal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1Process_nFinal" "', argument " "1"" of type '" "Pythia8::Sigma1Process const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1Process * >(argp1);
  result = (int)((Pythia8::Sigma1Process const *)arg1)->nFinal();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1Process_set1Kin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1Process *arg1 = (Pythia8::Sigma1Process *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma1Process_set1Kin",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1Process_set1Kin" "', argument " "1"" of type '" "Pythia8::Sigma1Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1Process * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sigma1Process_set1Kin" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma1Process_set1Kin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma1Process_set1Kin" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->set1Kin(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1Process_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1Process *arg1 = (Pythia8::Sigma1Process *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1Process_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1Process_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma1Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1Process * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1Process_sigmaHatWrap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1Process *arg1 = (Pythia8::Sigma1Process *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Sigma1Process_sigmaHatWrap",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1Process_sigmaHatWrap" "', argument " "1"" of type '" "Pythia8::Sigma1Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1Process * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sigma1Process_sigmaHatWrap" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma1Process_sigmaHatWrap" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)(arg1)->sigmaHatWrap(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1Process_sigmaHatWrap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1Process *arg1 = (Pythia8::Sigma1Process *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Sigma1Process_sigmaHatWrap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1Process_sigmaHatWrap" "', argument " "1"" of type '" "Pythia8::Sigma1Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1Process * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sigma1Process_sigmaHatWrap" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->sigmaHatWrap(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1Process_sigmaHatWrap__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1Process *arg1 = (Pythia8::Sigma1Process *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1Process_sigmaHatWrap",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1Process_sigmaHatWrap" "', argument " "1"" of type '" "Pythia8::Sigma1Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1Process * >(argp1);
  result = (double)(arg1)->sigmaHatWrap();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1Process_sigmaHatWrap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Sigma1Process, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Sigma1Process_sigmaHatWrap__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Sigma1Process, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Sigma1Process_sigmaHatWrap__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Sigma1Process, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Sigma1Process_sigmaHatWrap__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Sigma1Process_sigmaHatWrap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Sigma1Process::sigmaHatWrap(int,int)\n"
    "    Pythia8::Sigma1Process::sigmaHatWrap(int)\n"
    "    Pythia8::Sigma1Process::sigmaHatWrap()\n");
  return 0;
}


SWIGINTERN PyObject *Sigma1Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma1Process, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_Sigma2Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2Process *arg1 = (Pythia8::Sigma2Process *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2Process",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2Process, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2Process" "', argument " "1"" of type '" "Pythia8::Sigma2Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2Process * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2Process_nFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2Process *arg1 = (Pythia8::Sigma2Process *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2Process_nFinal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2Process_nFinal" "', argument " "1"" of type '" "Pythia8::Sigma2Process const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2Process * >(argp1);
  result = (int)((Pythia8::Sigma2Process const *)arg1)->nFinal();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2Process_set2Kin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2Process *arg1 = (Pythia8::Sigma2Process *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Sigma2Process_set2Kin",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2Process_set2Kin" "', argument " "1"" of type '" "Pythia8::Sigma2Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2Process * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sigma2Process_set2Kin" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2Process_set2Kin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2Process_set2Kin" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sigma2Process_set2Kin" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sigma2Process_set2Kin" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Sigma2Process_set2Kin" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Sigma2Process_set2Kin" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Sigma2Process_set2Kin" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  (arg1)->set2Kin(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2Process_set2KinMPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2Process *arg1 = (Pythia8::Sigma2Process *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  bool arg9 ;
  double arg10 ;
  double arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Sigma2Process_set2KinMPI",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2Process_set2KinMPI" "', argument " "1"" of type '" "Pythia8::Sigma2Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2Process * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sigma2Process_set2KinMPI" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2Process_set2KinMPI" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2Process_set2KinMPI" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sigma2Process_set2KinMPI" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sigma2Process_set2KinMPI" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Sigma2Process_set2KinMPI" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Sigma2Process_set2KinMPI" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Sigma2Process_set2KinMPI" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Sigma2Process_set2KinMPI" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Sigma2Process_set2KinMPI" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  (arg1)->set2KinMPI(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2Process_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2Process *arg1 = (Pythia8::Sigma2Process *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2Process_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2Process_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2Process * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2Process_sigmaHatWrap__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2Process *arg1 = (Pythia8::Sigma2Process *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Sigma2Process_sigmaHatWrap",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2Process_sigmaHatWrap" "', argument " "1"" of type '" "Pythia8::Sigma2Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2Process * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sigma2Process_sigmaHatWrap" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2Process_sigmaHatWrap" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)(arg1)->sigmaHatWrap(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2Process_sigmaHatWrap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2Process *arg1 = (Pythia8::Sigma2Process *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Sigma2Process_sigmaHatWrap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2Process_sigmaHatWrap" "', argument " "1"" of type '" "Pythia8::Sigma2Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2Process * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sigma2Process_sigmaHatWrap" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->sigmaHatWrap(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2Process_sigmaHatWrap__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2Process *arg1 = (Pythia8::Sigma2Process *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2Process_sigmaHatWrap",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2Process_sigmaHatWrap" "', argument " "1"" of type '" "Pythia8::Sigma2Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2Process * >(argp1);
  result = (double)(arg1)->sigmaHatWrap();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2Process_sigmaHatWrap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Sigma2Process, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Sigma2Process_sigmaHatWrap__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Sigma2Process, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Sigma2Process_sigmaHatWrap__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Sigma2Process, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Sigma2Process_sigmaHatWrap__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Sigma2Process_sigmaHatWrap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Sigma2Process::sigmaHatWrap(int,int)\n"
    "    Pythia8::Sigma2Process::sigmaHatWrap(int)\n"
    "    Pythia8::Sigma2Process::sigmaHatWrap()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Sigma2Process_final2KinMPI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2Process *arg1 = (Pythia8::Sigma2Process *) 0 ;
  int arg2 ;
  int arg3 ;
  Pythia8::Vec4 arg4 ;
  Pythia8::Vec4 arg5 ;
  double arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Sigma2Process_final2KinMPI",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2Process_final2KinMPI" "', argument " "1"" of type '" "Pythia8::Sigma2Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2Process * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sigma2Process_final2KinMPI" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2Process_final2KinMPI" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Sigma2Process_final2KinMPI" "', argument " "4"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2Process_final2KinMPI" "', argument " "4"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Sigma2Process_final2KinMPI" "', argument " "5"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2Process_final2KinMPI" "', argument " "5"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sigma2Process_final2KinMPI" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Sigma2Process_final2KinMPI" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (bool)(arg1)->final2KinMPI(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2Process_final2KinMPI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2Process *arg1 = (Pythia8::Sigma2Process *) 0 ;
  int arg2 ;
  int arg3 ;
  Pythia8::Vec4 arg4 ;
  Pythia8::Vec4 arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Sigma2Process_final2KinMPI",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2Process_final2KinMPI" "', argument " "1"" of type '" "Pythia8::Sigma2Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2Process * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sigma2Process_final2KinMPI" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2Process_final2KinMPI" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Sigma2Process_final2KinMPI" "', argument " "4"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2Process_final2KinMPI" "', argument " "4"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Sigma2Process_final2KinMPI" "', argument " "5"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2Process_final2KinMPI" "', argument " "5"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sigma2Process_final2KinMPI" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (bool)(arg1)->final2KinMPI(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2Process_final2KinMPI__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2Process *arg1 = (Pythia8::Sigma2Process *) 0 ;
  int arg2 ;
  int arg3 ;
  Pythia8::Vec4 arg4 ;
  Pythia8::Vec4 arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Sigma2Process_final2KinMPI",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2Process_final2KinMPI" "', argument " "1"" of type '" "Pythia8::Sigma2Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2Process * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sigma2Process_final2KinMPI" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2Process_final2KinMPI" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Sigma2Process_final2KinMPI" "', argument " "4"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2Process_final2KinMPI" "', argument " "4"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Sigma2Process_final2KinMPI" "', argument " "5"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2Process_final2KinMPI" "', argument " "5"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  result = (bool)(arg1)->final2KinMPI(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2Process_final2KinMPI__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2Process *arg1 = (Pythia8::Sigma2Process *) 0 ;
  int arg2 ;
  int arg3 ;
  Pythia8::Vec4 arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2Process_final2KinMPI",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2Process_final2KinMPI" "', argument " "1"" of type '" "Pythia8::Sigma2Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2Process * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sigma2Process_final2KinMPI" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2Process_final2KinMPI" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Sigma2Process_final2KinMPI" "', argument " "4"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2Process_final2KinMPI" "', argument " "4"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  result = (bool)(arg1)->final2KinMPI(arg2,arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2Process_final2KinMPI__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2Process *arg1 = (Pythia8::Sigma2Process *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Sigma2Process_final2KinMPI",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2Process_final2KinMPI" "', argument " "1"" of type '" "Pythia8::Sigma2Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2Process * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sigma2Process_final2KinMPI" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2Process_final2KinMPI" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (bool)(arg1)->final2KinMPI(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2Process_final2KinMPI__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2Process *arg1 = (Pythia8::Sigma2Process *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Sigma2Process_final2KinMPI",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2Process_final2KinMPI" "', argument " "1"" of type '" "Pythia8::Sigma2Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2Process * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sigma2Process_final2KinMPI" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->final2KinMPI(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2Process_final2KinMPI__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2Process *arg1 = (Pythia8::Sigma2Process *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2Process_final2KinMPI",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2Process_final2KinMPI" "', argument " "1"" of type '" "Pythia8::Sigma2Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2Process * >(argp1);
  result = (bool)(arg1)->final2KinMPI();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2Process_final2KinMPI(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Sigma2Process, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Sigma2Process_final2KinMPI__SWIG_6(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Sigma2Process, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Sigma2Process_final2KinMPI__SWIG_5(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Sigma2Process, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Sigma2Process_final2KinMPI__SWIG_4(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Sigma2Process, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Sigma2Process_final2KinMPI__SWIG_3(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Sigma2Process, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Sigma2Process_final2KinMPI__SWIG_2(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Sigma2Process, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Sigma2Process_final2KinMPI__SWIG_1(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Sigma2Process, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Sigma2Process_final2KinMPI__SWIG_0(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Sigma2Process_final2KinMPI'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Sigma2Process::final2KinMPI(int,int,Pythia8::Vec4,Pythia8::Vec4,double,double)\n"
    "    Pythia8::Sigma2Process::final2KinMPI(int,int,Pythia8::Vec4,Pythia8::Vec4,double)\n"
    "    Pythia8::Sigma2Process::final2KinMPI(int,int,Pythia8::Vec4,Pythia8::Vec4)\n"
    "    Pythia8::Sigma2Process::final2KinMPI(int,int,Pythia8::Vec4)\n"
    "    Pythia8::Sigma2Process::final2KinMPI(int,int)\n"
    "    Pythia8::Sigma2Process::final2KinMPI(int)\n"
    "    Pythia8::Sigma2Process::final2KinMPI()\n");
  return 0;
}


SWIGINTERN PyObject *Sigma2Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2Process, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_Sigma3Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3Process *arg1 = (Pythia8::Sigma3Process *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma3Process",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3Process, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma3Process" "', argument " "1"" of type '" "Pythia8::Sigma3Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3Process * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3Process_nFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3Process *arg1 = (Pythia8::Sigma3Process *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3Process_nFinal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3Process_nFinal" "', argument " "1"" of type '" "Pythia8::Sigma3Process const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3Process * >(argp1);
  result = (int)((Pythia8::Sigma3Process const *)arg1)->nFinal();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3Process_set3Kin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3Process *arg1 = (Pythia8::Sigma3Process *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  Pythia8::Vec4 arg5 ;
  Pythia8::Vec4 arg6 ;
  Pythia8::Vec4 arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Sigma3Process_set3Kin",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3Process_set3Kin" "', argument " "1"" of type '" "Pythia8::Sigma3Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3Process * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sigma3Process_set3Kin" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma3Process_set3Kin" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma3Process_set3Kin" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Sigma3Process_set3Kin" "', argument " "5"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma3Process_set3Kin" "', argument " "5"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Sigma3Process_set3Kin" "', argument " "6"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma3Process_set3Kin" "', argument " "6"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Sigma3Process_set3Kin" "', argument " "7"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma3Process_set3Kin" "', argument " "7"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Sigma3Process_set3Kin" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Sigma3Process_set3Kin" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Sigma3Process_set3Kin" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Sigma3Process_set3Kin" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Sigma3Process_set3Kin" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "Sigma3Process_set3Kin" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  (arg1)->set3Kin(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3Process_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3Process *arg1 = (Pythia8::Sigma3Process *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3Process_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3Process, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3Process_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma3Process *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3Process * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma3Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma3Process, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SigmaLHAProcess(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaLHAProcess *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SigmaLHAProcess")) SWIG_fail;
  result = (Pythia8::SigmaLHAProcess *)new Pythia8::SigmaLHAProcess();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SigmaLHAProcess, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SigmaLHAProcess(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaLHAProcess *arg1 = (Pythia8::SigmaLHAProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SigmaLHAProcess",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaLHAProcess, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SigmaLHAProcess" "', argument " "1"" of type '" "Pythia8::SigmaLHAProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaLHAProcess * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaLHAProcess_initFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaLHAProcess *arg1 = (Pythia8::SigmaLHAProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaLHAProcess_initFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaLHAProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaLHAProcess_initFlux" "', argument " "1"" of type '" "Pythia8::SigmaLHAProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaLHAProcess * >(argp1);
  result = (bool)(arg1)->initFlux();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaLHAProcess_sigmaPDF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaLHAProcess *arg1 = (Pythia8::SigmaLHAProcess *) 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SigmaLHAProcess_sigmaPDF",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaLHAProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaLHAProcess_sigmaPDF" "', argument " "1"" of type '" "Pythia8::SigmaLHAProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaLHAProcess * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaLHAProcess_sigmaPDF" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaLHAProcess_sigmaPDF" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaLHAProcess_sigmaPDF" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaLHAProcess_sigmaPDF" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaLHAProcess_sigmaPDF" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (double)(arg1)->sigmaPDF(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaLHAProcess_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaLHAProcess *arg1 = (Pythia8::SigmaLHAProcess *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SigmaLHAProcess_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaLHAProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaLHAProcess_weightDecay" "', argument " "1"" of type '" "Pythia8::SigmaLHAProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaLHAProcess * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaLHAProcess_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaLHAProcess_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaLHAProcess_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaLHAProcess_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaLHAProcess_setScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaLHAProcess *arg1 = (Pythia8::SigmaLHAProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaLHAProcess_setScale",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaLHAProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaLHAProcess_setScale" "', argument " "1"" of type '" "Pythia8::SigmaLHAProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaLHAProcess * >(argp1);
  (arg1)->setScale();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaLHAProcess_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaLHAProcess *arg1 = (Pythia8::SigmaLHAProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaLHAProcess_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaLHAProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaLHAProcess_name" "', argument " "1"" of type '" "Pythia8::SigmaLHAProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaLHAProcess * >(argp1);
  result = ((Pythia8::SigmaLHAProcess const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaLHAProcess_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaLHAProcess *arg1 = (Pythia8::SigmaLHAProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaLHAProcess_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaLHAProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaLHAProcess_code" "', argument " "1"" of type '" "Pythia8::SigmaLHAProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaLHAProcess * >(argp1);
  result = (int)((Pythia8::SigmaLHAProcess const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaLHAProcess_nFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaLHAProcess *arg1 = (Pythia8::SigmaLHAProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaLHAProcess_nFinal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaLHAProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaLHAProcess_nFinal" "', argument " "1"" of type '" "Pythia8::SigmaLHAProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaLHAProcess * >(argp1);
  result = (int)((Pythia8::SigmaLHAProcess const *)arg1)->nFinal();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaLHAProcess_convert2mb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaLHAProcess *arg1 = (Pythia8::SigmaLHAProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaLHAProcess_convert2mb",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaLHAProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaLHAProcess_convert2mb" "', argument " "1"" of type '" "Pythia8::SigmaLHAProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaLHAProcess * >(argp1);
  result = (bool)((Pythia8::SigmaLHAProcess const *)arg1)->convert2mb();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaLHAProcess_isLHA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaLHAProcess *arg1 = (Pythia8::SigmaLHAProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaLHAProcess_isLHA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaLHAProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaLHAProcess_isLHA" "', argument " "1"" of type '" "Pythia8::SigmaLHAProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaLHAProcess * >(argp1);
  result = (bool)((Pythia8::SigmaLHAProcess const *)arg1)->isLHA();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaLHAProcess_allowNegativeSigma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaLHAProcess *arg1 = (Pythia8::SigmaLHAProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaLHAProcess_allowNegativeSigma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaLHAProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaLHAProcess_allowNegativeSigma" "', argument " "1"" of type '" "Pythia8::SigmaLHAProcess const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaLHAProcess * >(argp1);
  result = (bool)((Pythia8::SigmaLHAProcess const *)arg1)->allowNegativeSigma();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SigmaLHAProcess_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SigmaLHAProcess, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma0nonDiffractive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0nonDiffractive *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma0nonDiffractive")) SWIG_fail;
  result = (Pythia8::Sigma0nonDiffractive *)new Pythia8::Sigma0nonDiffractive();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma0nonDiffractive, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0nonDiffractive_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0nonDiffractive *arg1 = (Pythia8::Sigma0nonDiffractive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0nonDiffractive_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0nonDiffractive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0nonDiffractive_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma0nonDiffractive *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0nonDiffractive * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0nonDiffractive_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0nonDiffractive *arg1 = (Pythia8::Sigma0nonDiffractive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0nonDiffractive_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0nonDiffractive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0nonDiffractive_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma0nonDiffractive *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0nonDiffractive * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0nonDiffractive_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0nonDiffractive *arg1 = (Pythia8::Sigma0nonDiffractive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0nonDiffractive_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0nonDiffractive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0nonDiffractive_name" "', argument " "1"" of type '" "Pythia8::Sigma0nonDiffractive const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0nonDiffractive * >(argp1);
  result = ((Pythia8::Sigma0nonDiffractive const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0nonDiffractive_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0nonDiffractive *arg1 = (Pythia8::Sigma0nonDiffractive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0nonDiffractive_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0nonDiffractive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0nonDiffractive_code" "', argument " "1"" of type '" "Pythia8::Sigma0nonDiffractive const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0nonDiffractive * >(argp1);
  result = (int)((Pythia8::Sigma0nonDiffractive const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0nonDiffractive_isNonDiff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0nonDiffractive *arg1 = (Pythia8::Sigma0nonDiffractive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0nonDiffractive_isNonDiff",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0nonDiffractive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0nonDiffractive_isNonDiff" "', argument " "1"" of type '" "Pythia8::Sigma0nonDiffractive const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0nonDiffractive * >(argp1);
  result = (bool)((Pythia8::Sigma0nonDiffractive const *)arg1)->isNonDiff();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma0nonDiffractive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0nonDiffractive *arg1 = (Pythia8::Sigma0nonDiffractive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma0nonDiffractive",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0nonDiffractive, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma0nonDiffractive" "', argument " "1"" of type '" "Pythia8::Sigma0nonDiffractive *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0nonDiffractive * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma0nonDiffractive_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma0nonDiffractive, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma0AB2AB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2AB *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma0AB2AB")) SWIG_fail;
  result = (Pythia8::Sigma0AB2AB *)new Pythia8::Sigma0AB2AB();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma0AB2AB, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2AB_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2AB *arg1 = (Pythia8::Sigma0AB2AB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2AB_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2AB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2AB_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma0AB2AB *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2AB * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2AB_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2AB *arg1 = (Pythia8::Sigma0AB2AB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2AB_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2AB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2AB_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma0AB2AB *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2AB * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2AB_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2AB *arg1 = (Pythia8::Sigma0AB2AB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2AB_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2AB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2AB_name" "', argument " "1"" of type '" "Pythia8::Sigma0AB2AB const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2AB * >(argp1);
  result = ((Pythia8::Sigma0AB2AB const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2AB_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2AB *arg1 = (Pythia8::Sigma0AB2AB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2AB_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2AB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2AB_code" "', argument " "1"" of type '" "Pythia8::Sigma0AB2AB const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2AB * >(argp1);
  result = (int)((Pythia8::Sigma0AB2AB const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2AB_isResolved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2AB *arg1 = (Pythia8::Sigma0AB2AB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2AB_isResolved",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2AB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2AB_isResolved" "', argument " "1"" of type '" "Pythia8::Sigma0AB2AB const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2AB * >(argp1);
  result = (bool)((Pythia8::Sigma0AB2AB const *)arg1)->isResolved();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma0AB2AB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2AB *arg1 = (Pythia8::Sigma0AB2AB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma0AB2AB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2AB, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma0AB2AB" "', argument " "1"" of type '" "Pythia8::Sigma0AB2AB *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2AB * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma0AB2AB_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma0AB2AB, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma0AB2XB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2XB *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma0AB2XB")) SWIG_fail;
  result = (Pythia8::Sigma0AB2XB *)new Pythia8::Sigma0AB2XB();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma0AB2XB, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2XB_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2XB *arg1 = (Pythia8::Sigma0AB2XB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2XB_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2XB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2XB_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma0AB2XB *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2XB * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2XB_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2XB *arg1 = (Pythia8::Sigma0AB2XB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2XB_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2XB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2XB_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma0AB2XB *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2XB * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2XB_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2XB *arg1 = (Pythia8::Sigma0AB2XB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2XB_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2XB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2XB_name" "', argument " "1"" of type '" "Pythia8::Sigma0AB2XB const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2XB * >(argp1);
  result = ((Pythia8::Sigma0AB2XB const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2XB_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2XB *arg1 = (Pythia8::Sigma0AB2XB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2XB_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2XB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2XB_code" "', argument " "1"" of type '" "Pythia8::Sigma0AB2XB const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2XB * >(argp1);
  result = (int)((Pythia8::Sigma0AB2XB const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2XB_isResolved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2XB *arg1 = (Pythia8::Sigma0AB2XB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2XB_isResolved",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2XB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2XB_isResolved" "', argument " "1"" of type '" "Pythia8::Sigma0AB2XB const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2XB * >(argp1);
  result = (bool)((Pythia8::Sigma0AB2XB const *)arg1)->isResolved();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2XB_isDiffA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2XB *arg1 = (Pythia8::Sigma0AB2XB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2XB_isDiffA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2XB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2XB_isDiffA" "', argument " "1"" of type '" "Pythia8::Sigma0AB2XB const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2XB * >(argp1);
  result = (bool)((Pythia8::Sigma0AB2XB const *)arg1)->isDiffA();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma0AB2XB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2XB *arg1 = (Pythia8::Sigma0AB2XB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma0AB2XB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2XB, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma0AB2XB" "', argument " "1"" of type '" "Pythia8::Sigma0AB2XB *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2XB * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma0AB2XB_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma0AB2XB, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma0AB2AX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2AX *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma0AB2AX")) SWIG_fail;
  result = (Pythia8::Sigma0AB2AX *)new Pythia8::Sigma0AB2AX();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma0AB2AX, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2AX_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2AX *arg1 = (Pythia8::Sigma0AB2AX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2AX_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2AX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2AX_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma0AB2AX *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2AX * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2AX_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2AX *arg1 = (Pythia8::Sigma0AB2AX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2AX_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2AX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2AX_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma0AB2AX *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2AX * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2AX_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2AX *arg1 = (Pythia8::Sigma0AB2AX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2AX_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2AX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2AX_name" "', argument " "1"" of type '" "Pythia8::Sigma0AB2AX const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2AX * >(argp1);
  result = ((Pythia8::Sigma0AB2AX const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2AX_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2AX *arg1 = (Pythia8::Sigma0AB2AX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2AX_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2AX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2AX_code" "', argument " "1"" of type '" "Pythia8::Sigma0AB2AX const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2AX * >(argp1);
  result = (int)((Pythia8::Sigma0AB2AX const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2AX_isResolved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2AX *arg1 = (Pythia8::Sigma0AB2AX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2AX_isResolved",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2AX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2AX_isResolved" "', argument " "1"" of type '" "Pythia8::Sigma0AB2AX const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2AX * >(argp1);
  result = (bool)((Pythia8::Sigma0AB2AX const *)arg1)->isResolved();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2AX_isDiffB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2AX *arg1 = (Pythia8::Sigma0AB2AX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2AX_isDiffB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2AX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2AX_isDiffB" "', argument " "1"" of type '" "Pythia8::Sigma0AB2AX const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2AX * >(argp1);
  result = (bool)((Pythia8::Sigma0AB2AX const *)arg1)->isDiffB();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma0AB2AX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2AX *arg1 = (Pythia8::Sigma0AB2AX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma0AB2AX",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2AX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma0AB2AX" "', argument " "1"" of type '" "Pythia8::Sigma0AB2AX *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2AX * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma0AB2AX_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma0AB2AX, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma0AB2XX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2XX *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma0AB2XX")) SWIG_fail;
  result = (Pythia8::Sigma0AB2XX *)new Pythia8::Sigma0AB2XX();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma0AB2XX, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2XX_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2XX *arg1 = (Pythia8::Sigma0AB2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2XX_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2XX_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma0AB2XX *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2XX * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2XX_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2XX *arg1 = (Pythia8::Sigma0AB2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2XX_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2XX_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma0AB2XX *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2XX * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2XX_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2XX *arg1 = (Pythia8::Sigma0AB2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2XX_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2XX_name" "', argument " "1"" of type '" "Pythia8::Sigma0AB2XX const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2XX * >(argp1);
  result = ((Pythia8::Sigma0AB2XX const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2XX_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2XX *arg1 = (Pythia8::Sigma0AB2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2XX_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2XX_code" "', argument " "1"" of type '" "Pythia8::Sigma0AB2XX const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2XX * >(argp1);
  result = (int)((Pythia8::Sigma0AB2XX const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2XX_isResolved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2XX *arg1 = (Pythia8::Sigma0AB2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2XX_isResolved",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2XX_isResolved" "', argument " "1"" of type '" "Pythia8::Sigma0AB2XX const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2XX * >(argp1);
  result = (bool)((Pythia8::Sigma0AB2XX const *)arg1)->isResolved();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2XX_isDiffA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2XX *arg1 = (Pythia8::Sigma0AB2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2XX_isDiffA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2XX_isDiffA" "', argument " "1"" of type '" "Pythia8::Sigma0AB2XX const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2XX * >(argp1);
  result = (bool)((Pythia8::Sigma0AB2XX const *)arg1)->isDiffA();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2XX_isDiffB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2XX *arg1 = (Pythia8::Sigma0AB2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2XX_isDiffB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2XX_isDiffB" "', argument " "1"" of type '" "Pythia8::Sigma0AB2XX const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2XX * >(argp1);
  result = (bool)((Pythia8::Sigma0AB2XX const *)arg1)->isDiffB();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma0AB2XX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2XX *arg1 = (Pythia8::Sigma0AB2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma0AB2XX",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2XX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma0AB2XX" "', argument " "1"" of type '" "Pythia8::Sigma0AB2XX *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2XX * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma0AB2XX_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma0AB2XX, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma0AB2AXB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2AXB *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma0AB2AXB")) SWIG_fail;
  result = (Pythia8::Sigma0AB2AXB *)new Pythia8::Sigma0AB2AXB();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma0AB2AXB, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2AXB_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2AXB *arg1 = (Pythia8::Sigma0AB2AXB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2AXB_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2AXB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2AXB_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma0AB2AXB *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2AXB * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2AXB_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2AXB *arg1 = (Pythia8::Sigma0AB2AXB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2AXB_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2AXB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2AXB_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma0AB2AXB *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2AXB * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2AXB_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2AXB *arg1 = (Pythia8::Sigma0AB2AXB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2AXB_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2AXB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2AXB_name" "', argument " "1"" of type '" "Pythia8::Sigma0AB2AXB const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2AXB * >(argp1);
  result = ((Pythia8::Sigma0AB2AXB const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2AXB_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2AXB *arg1 = (Pythia8::Sigma0AB2AXB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2AXB_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2AXB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2AXB_code" "', argument " "1"" of type '" "Pythia8::Sigma0AB2AXB const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2AXB * >(argp1);
  result = (int)((Pythia8::Sigma0AB2AXB const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2AXB_nFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2AXB *arg1 = (Pythia8::Sigma0AB2AXB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2AXB_nFinal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2AXB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2AXB_nFinal" "', argument " "1"" of type '" "Pythia8::Sigma0AB2AXB const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2AXB * >(argp1);
  result = (int)((Pythia8::Sigma0AB2AXB const *)arg1)->nFinal();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2AXB_isResolved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2AXB *arg1 = (Pythia8::Sigma0AB2AXB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2AXB_isResolved",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2AXB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2AXB_isResolved" "', argument " "1"" of type '" "Pythia8::Sigma0AB2AXB const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2AXB * >(argp1);
  result = (bool)((Pythia8::Sigma0AB2AXB const *)arg1)->isResolved();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma0AB2AXB_isDiffC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2AXB *arg1 = (Pythia8::Sigma0AB2AXB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma0AB2AXB_isDiffC",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2AXB, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma0AB2AXB_isDiffC" "', argument " "1"" of type '" "Pythia8::Sigma0AB2AXB const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2AXB * >(argp1);
  result = (bool)((Pythia8::Sigma0AB2AXB const *)arg1)->isDiffC();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma0AB2AXB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma0AB2AXB *arg1 = (Pythia8::Sigma0AB2AXB *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma0AB2AXB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma0AB2AXB, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma0AB2AXB" "', argument " "1"" of type '" "Pythia8::Sigma0AB2AXB *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma0AB2AXB * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma0AB2AXB_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma0AB2AXB, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2gg2gg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gg *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2gg2gg")) SWIG_fail;
  result = (Pythia8::Sigma2gg2gg *)new Pythia8::Sigma2gg2gg();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gg2gg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2gg_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gg *arg1 = (Pythia8::Sigma2gg2gg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2gg_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2gg_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gg * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2gg_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gg *arg1 = (Pythia8::Sigma2gg2gg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2gg_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2gg_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gg * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2gg_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gg *arg1 = (Pythia8::Sigma2gg2gg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2gg_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2gg_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gg * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2gg_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gg *arg1 = (Pythia8::Sigma2gg2gg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2gg_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2gg_name" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gg * >(argp1);
  result = ((Pythia8::Sigma2gg2gg const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2gg_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gg *arg1 = (Pythia8::Sigma2gg2gg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2gg_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2gg_code" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gg * >(argp1);
  result = (int)((Pythia8::Sigma2gg2gg const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2gg_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gg *arg1 = (Pythia8::Sigma2gg2gg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2gg_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2gg_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gg * >(argp1);
  result = ((Pythia8::Sigma2gg2gg const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2gg2gg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gg *arg1 = (Pythia8::Sigma2gg2gg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2gg2gg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2gg2gg" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gg * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2gg2gg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2gg2gg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2gg2qqbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2qqbar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2gg2qqbar")) SWIG_fail;
  result = (Pythia8::Sigma2gg2qqbar *)new Pythia8::Sigma2gg2qqbar();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gg2qqbar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2qqbar_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2qqbar *arg1 = (Pythia8::Sigma2gg2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2qqbar_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2qqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2qqbar_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2gg2qqbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2qqbar * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2qqbar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2qqbar *arg1 = (Pythia8::Sigma2gg2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2qqbar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2qqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2qqbar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2gg2qqbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2qqbar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2qqbar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2qqbar *arg1 = (Pythia8::Sigma2gg2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2qqbar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2qqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2qqbar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2gg2qqbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2qqbar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2qqbar_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2qqbar *arg1 = (Pythia8::Sigma2gg2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2qqbar_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2qqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2qqbar_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2gg2qqbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2qqbar * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2qqbar_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2qqbar *arg1 = (Pythia8::Sigma2gg2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2qqbar_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2qqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2qqbar_name" "', argument " "1"" of type '" "Pythia8::Sigma2gg2qqbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2qqbar * >(argp1);
  result = ((Pythia8::Sigma2gg2qqbar const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2qqbar_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2qqbar *arg1 = (Pythia8::Sigma2gg2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2qqbar_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2qqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2qqbar_code" "', argument " "1"" of type '" "Pythia8::Sigma2gg2qqbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2qqbar * >(argp1);
  result = (int)((Pythia8::Sigma2gg2qqbar const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2qqbar_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2qqbar *arg1 = (Pythia8::Sigma2gg2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2qqbar_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2qqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2qqbar_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2gg2qqbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2qqbar * >(argp1);
  result = ((Pythia8::Sigma2gg2qqbar const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2gg2qqbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2qqbar *arg1 = (Pythia8::Sigma2gg2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2gg2qqbar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2qqbar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2gg2qqbar" "', argument " "1"" of type '" "Pythia8::Sigma2gg2qqbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2qqbar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2gg2qqbar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2gg2qqbar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qg2qg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2qg *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qg2qg")) SWIG_fail;
  result = (Pythia8::Sigma2qg2qg *)new Pythia8::Sigma2qg2qg();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qg2qg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2qg_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2qg *arg1 = (Pythia8::Sigma2qg2qg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2qg_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2qg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2qg_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qg2qg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2qg * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2qg_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2qg *arg1 = (Pythia8::Sigma2qg2qg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2qg_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2qg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2qg_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qg2qg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2qg * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2qg_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2qg *arg1 = (Pythia8::Sigma2qg2qg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2qg_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2qg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2qg_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qg2qg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2qg * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2qg_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2qg *arg1 = (Pythia8::Sigma2qg2qg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2qg_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2qg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2qg_name" "', argument " "1"" of type '" "Pythia8::Sigma2qg2qg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2qg * >(argp1);
  result = ((Pythia8::Sigma2qg2qg const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2qg_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2qg *arg1 = (Pythia8::Sigma2qg2qg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2qg_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2qg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2qg_code" "', argument " "1"" of type '" "Pythia8::Sigma2qg2qg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2qg * >(argp1);
  result = (int)((Pythia8::Sigma2qg2qg const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2qg_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2qg *arg1 = (Pythia8::Sigma2qg2qg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2qg_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2qg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2qg_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qg2qg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2qg * >(argp1);
  result = ((Pythia8::Sigma2qg2qg const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qg2qg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2qg *arg1 = (Pythia8::Sigma2qg2qg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qg2qg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2qg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qg2qg" "', argument " "1"" of type '" "Pythia8::Sigma2qg2qg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2qg * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qg2qg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qg2qg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qq2qq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2qq *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qq2qq")) SWIG_fail;
  result = (Pythia8::Sigma2qq2qq *)new Pythia8::Sigma2qq2qq();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qq2qq, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2qq_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2qq *arg1 = (Pythia8::Sigma2qq2qq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2qq_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2qq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2qq_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qq2qq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2qq * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2qq_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2qq *arg1 = (Pythia8::Sigma2qq2qq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2qq_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2qq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2qq_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qq2qq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2qq * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2qq_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2qq *arg1 = (Pythia8::Sigma2qq2qq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2qq_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2qq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2qq_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qq2qq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2qq * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2qq_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2qq *arg1 = (Pythia8::Sigma2qq2qq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2qq_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2qq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2qq_name" "', argument " "1"" of type '" "Pythia8::Sigma2qq2qq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2qq * >(argp1);
  result = ((Pythia8::Sigma2qq2qq const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2qq_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2qq *arg1 = (Pythia8::Sigma2qq2qq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2qq_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2qq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2qq_code" "', argument " "1"" of type '" "Pythia8::Sigma2qq2qq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2qq * >(argp1);
  result = (int)((Pythia8::Sigma2qq2qq const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2qq_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2qq *arg1 = (Pythia8::Sigma2qq2qq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2qq_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2qq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2qq_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qq2qq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2qq * >(argp1);
  result = ((Pythia8::Sigma2qq2qq const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qq2qq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2qq *arg1 = (Pythia8::Sigma2qq2qq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qq2qq",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2qq, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qq2qq" "', argument " "1"" of type '" "Pythia8::Sigma2qq2qq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2qq * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qq2qq_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qq2qq, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2gg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gg *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qqbar2gg")) SWIG_fail;
  result = (Pythia8::Sigma2qqbar2gg *)new Pythia8::Sigma2qqbar2gg();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2gg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2gg_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gg *arg1 = (Pythia8::Sigma2qqbar2gg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2gg_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2gg_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gg * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2gg_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gg *arg1 = (Pythia8::Sigma2qqbar2gg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2gg_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2gg_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gg * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2gg_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gg *arg1 = (Pythia8::Sigma2qqbar2gg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2gg_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2gg_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gg * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2gg_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gg *arg1 = (Pythia8::Sigma2qqbar2gg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2gg_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2gg_name" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gg * >(argp1);
  result = ((Pythia8::Sigma2qqbar2gg const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2gg_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gg *arg1 = (Pythia8::Sigma2qqbar2gg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2gg_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2gg_code" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gg * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2gg const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2gg_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gg *arg1 = (Pythia8::Sigma2qqbar2gg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2gg_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2gg_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gg * >(argp1);
  result = ((Pythia8::Sigma2qqbar2gg const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2gg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gg *arg1 = (Pythia8::Sigma2qqbar2gg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2gg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2gg" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gg * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2gg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2gg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2qqbarNew(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2qqbarNew *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qqbar2qqbarNew")) SWIG_fail;
  result = (Pythia8::Sigma2qqbar2qqbarNew *)new Pythia8::Sigma2qqbar2qqbarNew();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2qqbarNew, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2qqbarNew_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2qqbarNew *arg1 = (Pythia8::Sigma2qqbar2qqbarNew *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2qqbarNew_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2qqbarNew, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2qqbarNew_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2qqbarNew *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2qqbarNew * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2qqbarNew_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2qqbarNew *arg1 = (Pythia8::Sigma2qqbar2qqbarNew *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2qqbarNew_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2qqbarNew, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2qqbarNew_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2qqbarNew *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2qqbarNew * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2qqbarNew_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2qqbarNew *arg1 = (Pythia8::Sigma2qqbar2qqbarNew *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2qqbarNew_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2qqbarNew, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2qqbarNew_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2qqbarNew *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2qqbarNew * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2qqbarNew_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2qqbarNew *arg1 = (Pythia8::Sigma2qqbar2qqbarNew *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2qqbarNew_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2qqbarNew, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2qqbarNew_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2qqbarNew *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2qqbarNew * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2qqbarNew_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2qqbarNew *arg1 = (Pythia8::Sigma2qqbar2qqbarNew *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2qqbarNew_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2qqbarNew, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2qqbarNew_name" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2qqbarNew const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2qqbarNew * >(argp1);
  result = ((Pythia8::Sigma2qqbar2qqbarNew const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2qqbarNew_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2qqbarNew *arg1 = (Pythia8::Sigma2qqbar2qqbarNew *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2qqbarNew_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2qqbarNew, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2qqbarNew_code" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2qqbarNew const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2qqbarNew * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2qqbarNew const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2qqbarNew_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2qqbarNew *arg1 = (Pythia8::Sigma2qqbar2qqbarNew *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2qqbarNew_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2qqbarNew, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2qqbarNew_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2qqbarNew const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2qqbarNew * >(argp1);
  result = ((Pythia8::Sigma2qqbar2qqbarNew const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2qqbarNew(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2qqbarNew *arg1 = (Pythia8::Sigma2qqbar2qqbarNew *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2qqbarNew",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2qqbarNew, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2qqbarNew" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2qqbarNew *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2qqbarNew * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2qqbarNew_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2qqbarNew, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2gg2QQbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Sigma2gg2QQbar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Sigma2gg2QQbar",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2gg2QQbar" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2gg2QQbar" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::Sigma2gg2QQbar *)new Pythia8::Sigma2gg2QQbar(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gg2QQbar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar *arg1 = (Pythia8::Sigma2gg2QQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar *arg1 = (Pythia8::Sigma2gg2QQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar *arg1 = (Pythia8::Sigma2gg2QQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar *arg1 = (Pythia8::Sigma2gg2QQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar *arg1 = (Pythia8::Sigma2gg2QQbar *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2gg2QQbar_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2gg2QQbar_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2gg2QQbar_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2gg2QQbar_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2gg2QQbar_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar *arg1 = (Pythia8::Sigma2gg2QQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar_name" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar * >(argp1);
  result = ((Pythia8::Sigma2gg2QQbar const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar *arg1 = (Pythia8::Sigma2gg2QQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar_code" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar * >(argp1);
  result = (int)((Pythia8::Sigma2gg2QQbar const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar *arg1 = (Pythia8::Sigma2gg2QQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar * >(argp1);
  result = ((Pythia8::Sigma2gg2QQbar const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar *arg1 = (Pythia8::Sigma2gg2QQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar * >(argp1);
  result = (int)((Pythia8::Sigma2gg2QQbar const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar *arg1 = (Pythia8::Sigma2gg2QQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar * >(argp1);
  result = (int)((Pythia8::Sigma2gg2QQbar const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2gg2QQbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar *arg1 = (Pythia8::Sigma2gg2QQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2gg2QQbar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2gg2QQbar" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2gg2QQbar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2gg2QQbar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2QQbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Sigma2qqbar2QQbar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Sigma2qqbar2QQbar",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qqbar2QQbar" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2qqbar2QQbar" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::Sigma2qqbar2QQbar *)new Pythia8::Sigma2qqbar2QQbar(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2QQbar_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbar *arg1 = (Pythia8::Sigma2qqbar2QQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2QQbar_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2QQbar_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbar * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2QQbar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbar *arg1 = (Pythia8::Sigma2qqbar2QQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2QQbar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2QQbar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2QQbar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbar *arg1 = (Pythia8::Sigma2qqbar2QQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2QQbar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2QQbar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2QQbar_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbar *arg1 = (Pythia8::Sigma2qqbar2QQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2QQbar_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2QQbar_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbar * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2QQbar_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbar *arg1 = (Pythia8::Sigma2qqbar2QQbar *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2qqbar2QQbar_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2QQbar_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbar * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2qqbar2QQbar_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2qqbar2QQbar_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2qqbar2QQbar_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2qqbar2QQbar_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2QQbar_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbar *arg1 = (Pythia8::Sigma2qqbar2QQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2QQbar_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2QQbar_name" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbar * >(argp1);
  result = ((Pythia8::Sigma2qqbar2QQbar const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2QQbar_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbar *arg1 = (Pythia8::Sigma2qqbar2QQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2QQbar_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2QQbar_code" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbar * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2QQbar const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2QQbar_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbar *arg1 = (Pythia8::Sigma2qqbar2QQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2QQbar_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2QQbar_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbar * >(argp1);
  result = ((Pythia8::Sigma2qqbar2QQbar const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2QQbar_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbar *arg1 = (Pythia8::Sigma2qqbar2QQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2QQbar_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2QQbar_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbar * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2QQbar const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2QQbar_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbar *arg1 = (Pythia8::Sigma2qqbar2QQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2QQbar_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2QQbar_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbar * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2QQbar const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2QQbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbar *arg1 = (Pythia8::Sigma2qqbar2QQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2QQbar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2QQbar" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2QQbar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma3gg2ggg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2ggg *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma3gg2ggg")) SWIG_fail;
  result = (Pythia8::Sigma3gg2ggg *)new Pythia8::Sigma3gg2ggg();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma3gg2ggg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2ggg_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2ggg *arg1 = (Pythia8::Sigma3gg2ggg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2ggg_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2ggg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2ggg_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma3gg2ggg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2ggg * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2ggg_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2ggg *arg1 = (Pythia8::Sigma3gg2ggg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2ggg_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2ggg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2ggg_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma3gg2ggg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2ggg * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2ggg_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2ggg *arg1 = (Pythia8::Sigma3gg2ggg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2ggg_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2ggg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2ggg_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma3gg2ggg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2ggg * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2ggg_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2ggg *arg1 = (Pythia8::Sigma3gg2ggg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2ggg_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2ggg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2ggg_name" "', argument " "1"" of type '" "Pythia8::Sigma3gg2ggg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2ggg * >(argp1);
  result = ((Pythia8::Sigma3gg2ggg const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2ggg_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2ggg *arg1 = (Pythia8::Sigma3gg2ggg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2ggg_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2ggg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2ggg_code" "', argument " "1"" of type '" "Pythia8::Sigma3gg2ggg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2ggg * >(argp1);
  result = (int)((Pythia8::Sigma3gg2ggg const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2ggg_nFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2ggg *arg1 = (Pythia8::Sigma3gg2ggg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2ggg_nFinal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2ggg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2ggg_nFinal" "', argument " "1"" of type '" "Pythia8::Sigma3gg2ggg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2ggg * >(argp1);
  result = (int)((Pythia8::Sigma3gg2ggg const *)arg1)->nFinal();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2ggg_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2ggg *arg1 = (Pythia8::Sigma3gg2ggg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2ggg_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2ggg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2ggg_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma3gg2ggg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2ggg * >(argp1);
  result = ((Pythia8::Sigma3gg2ggg const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2ggg_isQCD3body(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2ggg *arg1 = (Pythia8::Sigma3gg2ggg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2ggg_isQCD3body",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2ggg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2ggg_isQCD3body" "', argument " "1"" of type '" "Pythia8::Sigma3gg2ggg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2ggg * >(argp1);
  result = (bool)((Pythia8::Sigma3gg2ggg const *)arg1)->isQCD3body();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma3gg2ggg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2ggg *arg1 = (Pythia8::Sigma3gg2ggg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma3gg2ggg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2ggg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma3gg2ggg" "', argument " "1"" of type '" "Pythia8::Sigma3gg2ggg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2ggg * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma3gg2ggg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma3gg2ggg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma3qqbar2ggg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2ggg *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma3qqbar2ggg")) SWIG_fail;
  result = (Pythia8::Sigma3qqbar2ggg *)new Pythia8::Sigma3qqbar2ggg();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma3qqbar2ggg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2ggg_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2ggg *arg1 = (Pythia8::Sigma3qqbar2ggg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2ggg_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2ggg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2ggg_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2ggg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2ggg * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2ggg_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2ggg *arg1 = (Pythia8::Sigma3qqbar2ggg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2ggg_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2ggg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2ggg_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2ggg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2ggg * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2ggg_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2ggg *arg1 = (Pythia8::Sigma3qqbar2ggg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2ggg_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2ggg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2ggg_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2ggg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2ggg * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2ggg_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2ggg *arg1 = (Pythia8::Sigma3qqbar2ggg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2ggg_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2ggg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2ggg_name" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2ggg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2ggg * >(argp1);
  result = ((Pythia8::Sigma3qqbar2ggg const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2ggg_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2ggg *arg1 = (Pythia8::Sigma3qqbar2ggg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2ggg_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2ggg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2ggg_code" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2ggg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2ggg * >(argp1);
  result = (int)((Pythia8::Sigma3qqbar2ggg const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2ggg_nFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2ggg *arg1 = (Pythia8::Sigma3qqbar2ggg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2ggg_nFinal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2ggg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2ggg_nFinal" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2ggg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2ggg * >(argp1);
  result = (int)((Pythia8::Sigma3qqbar2ggg const *)arg1)->nFinal();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2ggg_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2ggg *arg1 = (Pythia8::Sigma3qqbar2ggg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2ggg_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2ggg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2ggg_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2ggg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2ggg * >(argp1);
  result = ((Pythia8::Sigma3qqbar2ggg const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2ggg_isQCD3body(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2ggg *arg1 = (Pythia8::Sigma3qqbar2ggg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2ggg_isQCD3body",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2ggg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2ggg_isQCD3body" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2ggg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2ggg * >(argp1);
  result = (bool)((Pythia8::Sigma3qqbar2ggg const *)arg1)->isQCD3body();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma3qqbar2ggg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2ggg *arg1 = (Pythia8::Sigma3qqbar2ggg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma3qqbar2ggg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2ggg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma3qqbar2ggg" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2ggg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2ggg * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma3qqbar2ggg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma3qqbar2ggg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma3qg2qgg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qgg *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma3qg2qgg")) SWIG_fail;
  result = (Pythia8::Sigma3qg2qgg *)new Pythia8::Sigma3qg2qgg();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma3qg2qgg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qg2qgg_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qgg *arg1 = (Pythia8::Sigma3qg2qgg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qg2qgg_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qgg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qg2qgg_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qgg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qgg * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qg2qgg_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qgg *arg1 = (Pythia8::Sigma3qg2qgg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qg2qgg_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qgg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qg2qgg_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qgg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qgg * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qg2qgg_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qgg *arg1 = (Pythia8::Sigma3qg2qgg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qg2qgg_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qgg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qg2qgg_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qgg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qgg * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qg2qgg_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qgg *arg1 = (Pythia8::Sigma3qg2qgg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qg2qgg_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qgg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qg2qgg_name" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qgg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qgg * >(argp1);
  result = ((Pythia8::Sigma3qg2qgg const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qg2qgg_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qgg *arg1 = (Pythia8::Sigma3qg2qgg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qg2qgg_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qgg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qg2qgg_code" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qgg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qgg * >(argp1);
  result = (int)((Pythia8::Sigma3qg2qgg const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qg2qgg_nFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qgg *arg1 = (Pythia8::Sigma3qg2qgg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qg2qgg_nFinal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qgg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qg2qgg_nFinal" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qgg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qgg * >(argp1);
  result = (int)((Pythia8::Sigma3qg2qgg const *)arg1)->nFinal();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qg2qgg_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qgg *arg1 = (Pythia8::Sigma3qg2qgg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qg2qgg_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qgg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qg2qgg_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qgg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qgg * >(argp1);
  result = ((Pythia8::Sigma3qg2qgg const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qg2qgg_isQCD3body(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qgg *arg1 = (Pythia8::Sigma3qg2qgg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qg2qgg_isQCD3body",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qgg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qg2qgg_isQCD3body" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qgg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qgg * >(argp1);
  result = (bool)((Pythia8::Sigma3qg2qgg const *)arg1)->isQCD3body();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma3qg2qgg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qgg *arg1 = (Pythia8::Sigma3qg2qgg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma3qg2qgg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qgg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma3qg2qgg" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qgg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qgg * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma3qg2qgg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma3qg2qgg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma3gg2qqbarg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2qqbarg *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma3gg2qqbarg")) SWIG_fail;
  result = (Pythia8::Sigma3gg2qqbarg *)new Pythia8::Sigma3gg2qqbarg();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma3gg2qqbarg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2qqbarg_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2qqbarg *arg1 = (Pythia8::Sigma3gg2qqbarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2qqbarg_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2qqbarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2qqbarg_initProc" "', argument " "1"" of type '" "Pythia8::Sigma3gg2qqbarg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2qqbarg * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2qqbarg_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2qqbarg *arg1 = (Pythia8::Sigma3gg2qqbarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2qqbarg_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2qqbarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2qqbarg_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma3gg2qqbarg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2qqbarg * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2qqbarg_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2qqbarg *arg1 = (Pythia8::Sigma3gg2qqbarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2qqbarg_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2qqbarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2qqbarg_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma3gg2qqbarg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2qqbarg * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2qqbarg_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2qqbarg *arg1 = (Pythia8::Sigma3gg2qqbarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2qqbarg_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2qqbarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2qqbarg_name" "', argument " "1"" of type '" "Pythia8::Sigma3gg2qqbarg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2qqbarg * >(argp1);
  result = ((Pythia8::Sigma3gg2qqbarg const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2qqbarg_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2qqbarg *arg1 = (Pythia8::Sigma3gg2qqbarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2qqbarg_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2qqbarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2qqbarg_code" "', argument " "1"" of type '" "Pythia8::Sigma3gg2qqbarg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2qqbarg * >(argp1);
  result = (int)((Pythia8::Sigma3gg2qqbarg const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2qqbarg_nFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2qqbarg *arg1 = (Pythia8::Sigma3gg2qqbarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2qqbarg_nFinal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2qqbarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2qqbarg_nFinal" "', argument " "1"" of type '" "Pythia8::Sigma3gg2qqbarg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2qqbarg * >(argp1);
  result = (int)((Pythia8::Sigma3gg2qqbarg const *)arg1)->nFinal();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2qqbarg_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2qqbarg *arg1 = (Pythia8::Sigma3gg2qqbarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2qqbarg_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2qqbarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2qqbarg_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma3gg2qqbarg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2qqbarg * >(argp1);
  result = ((Pythia8::Sigma3gg2qqbarg const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2qqbarg_isQCD3body(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2qqbarg *arg1 = (Pythia8::Sigma3gg2qqbarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2qqbarg_isQCD3body",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2qqbarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2qqbarg_isQCD3body" "', argument " "1"" of type '" "Pythia8::Sigma3gg2qqbarg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2qqbarg * >(argp1);
  result = (bool)((Pythia8::Sigma3gg2qqbarg const *)arg1)->isQCD3body();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma3gg2qqbarg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2qqbarg *arg1 = (Pythia8::Sigma3gg2qqbarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma3gg2qqbarg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2qqbarg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma3gg2qqbarg" "', argument " "1"" of type '" "Pythia8::Sigma3gg2qqbarg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2qqbarg * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma3gg2qqbarg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma3gg2qqbarg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma3qq2qqgDiff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qq2qqgDiff *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma3qq2qqgDiff")) SWIG_fail;
  result = (Pythia8::Sigma3qq2qqgDiff *)new Pythia8::Sigma3qq2qqgDiff();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma3qq2qqgDiff, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qq2qqgDiff_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qq2qqgDiff *arg1 = (Pythia8::Sigma3qq2qqgDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qq2qqgDiff_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qq2qqgDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qq2qqgDiff_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma3qq2qqgDiff *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qq2qqgDiff * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qq2qqgDiff_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qq2qqgDiff *arg1 = (Pythia8::Sigma3qq2qqgDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qq2qqgDiff_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qq2qqgDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qq2qqgDiff_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma3qq2qqgDiff *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qq2qqgDiff * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qq2qqgDiff_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qq2qqgDiff *arg1 = (Pythia8::Sigma3qq2qqgDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qq2qqgDiff_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qq2qqgDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qq2qqgDiff_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma3qq2qqgDiff *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qq2qqgDiff * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qq2qqgDiff_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qq2qqgDiff *arg1 = (Pythia8::Sigma3qq2qqgDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qq2qqgDiff_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qq2qqgDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qq2qqgDiff_name" "', argument " "1"" of type '" "Pythia8::Sigma3qq2qqgDiff const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qq2qqgDiff * >(argp1);
  result = ((Pythia8::Sigma3qq2qqgDiff const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qq2qqgDiff_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qq2qqgDiff *arg1 = (Pythia8::Sigma3qq2qqgDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qq2qqgDiff_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qq2qqgDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qq2qqgDiff_code" "', argument " "1"" of type '" "Pythia8::Sigma3qq2qqgDiff const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qq2qqgDiff * >(argp1);
  result = (int)((Pythia8::Sigma3qq2qqgDiff const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qq2qqgDiff_nFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qq2qqgDiff *arg1 = (Pythia8::Sigma3qq2qqgDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qq2qqgDiff_nFinal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qq2qqgDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qq2qqgDiff_nFinal" "', argument " "1"" of type '" "Pythia8::Sigma3qq2qqgDiff const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qq2qqgDiff * >(argp1);
  result = (int)((Pythia8::Sigma3qq2qqgDiff const *)arg1)->nFinal();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qq2qqgDiff_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qq2qqgDiff *arg1 = (Pythia8::Sigma3qq2qqgDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qq2qqgDiff_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qq2qqgDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qq2qqgDiff_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma3qq2qqgDiff const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qq2qqgDiff * >(argp1);
  result = ((Pythia8::Sigma3qq2qqgDiff const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qq2qqgDiff_isQCD3body(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qq2qqgDiff *arg1 = (Pythia8::Sigma3qq2qqgDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qq2qqgDiff_isQCD3body",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qq2qqgDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qq2qqgDiff_isQCD3body" "', argument " "1"" of type '" "Pythia8::Sigma3qq2qqgDiff const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qq2qqgDiff * >(argp1);
  result = (bool)((Pythia8::Sigma3qq2qqgDiff const *)arg1)->isQCD3body();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma3qq2qqgDiff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qq2qqgDiff *arg1 = (Pythia8::Sigma3qq2qqgDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma3qq2qqgDiff",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qq2qqgDiff, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma3qq2qqgDiff" "', argument " "1"" of type '" "Pythia8::Sigma3qq2qqgDiff *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qq2qqgDiff * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma3qq2qqgDiff_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma3qq2qqgDiff, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma3qqbar2qqbargDiff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2qqbargDiff *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma3qqbar2qqbargDiff")) SWIG_fail;
  result = (Pythia8::Sigma3qqbar2qqbargDiff *)new Pythia8::Sigma3qqbar2qqbargDiff();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargDiff, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2qqbargDiff_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2qqbargDiff *arg1 = (Pythia8::Sigma3qqbar2qqbargDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2qqbargDiff_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2qqbargDiff_initProc" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2qqbargDiff *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2qqbargDiff * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2qqbargDiff_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2qqbargDiff *arg1 = (Pythia8::Sigma3qqbar2qqbargDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2qqbargDiff_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2qqbargDiff_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2qqbargDiff *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2qqbargDiff * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2qqbargDiff_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2qqbargDiff *arg1 = (Pythia8::Sigma3qqbar2qqbargDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2qqbargDiff_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2qqbargDiff_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2qqbargDiff *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2qqbargDiff * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2qqbargDiff_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2qqbargDiff *arg1 = (Pythia8::Sigma3qqbar2qqbargDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2qqbargDiff_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2qqbargDiff_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2qqbargDiff *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2qqbargDiff * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2qqbargDiff_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2qqbargDiff *arg1 = (Pythia8::Sigma3qqbar2qqbargDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2qqbargDiff_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2qqbargDiff_name" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2qqbargDiff const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2qqbargDiff * >(argp1);
  result = ((Pythia8::Sigma3qqbar2qqbargDiff const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2qqbargDiff_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2qqbargDiff *arg1 = (Pythia8::Sigma3qqbar2qqbargDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2qqbargDiff_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2qqbargDiff_code" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2qqbargDiff const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2qqbargDiff * >(argp1);
  result = (int)((Pythia8::Sigma3qqbar2qqbargDiff const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2qqbargDiff_nFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2qqbargDiff *arg1 = (Pythia8::Sigma3qqbar2qqbargDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2qqbargDiff_nFinal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2qqbargDiff_nFinal" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2qqbargDiff const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2qqbargDiff * >(argp1);
  result = (int)((Pythia8::Sigma3qqbar2qqbargDiff const *)arg1)->nFinal();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2qqbargDiff_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2qqbargDiff *arg1 = (Pythia8::Sigma3qqbar2qqbargDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2qqbargDiff_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2qqbargDiff_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2qqbargDiff const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2qqbargDiff * >(argp1);
  result = ((Pythia8::Sigma3qqbar2qqbargDiff const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2qqbargDiff_isQCD3body(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2qqbargDiff *arg1 = (Pythia8::Sigma3qqbar2qqbargDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2qqbargDiff_isQCD3body",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2qqbargDiff_isQCD3body" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2qqbargDiff const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2qqbargDiff * >(argp1);
  result = (bool)((Pythia8::Sigma3qqbar2qqbargDiff const *)arg1)->isQCD3body();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma3qqbar2qqbargDiff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2qqbargDiff *arg1 = (Pythia8::Sigma3qqbar2qqbargDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma3qqbar2qqbargDiff",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargDiff, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma3qqbar2qqbargDiff" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2qqbargDiff *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2qqbargDiff * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma3qqbar2qqbargDiff_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargDiff, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma3qg2qqqbarDiff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qqqbarDiff *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma3qg2qqqbarDiff")) SWIG_fail;
  result = (Pythia8::Sigma3qg2qqqbarDiff *)new Pythia8::Sigma3qg2qqqbarDiff();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarDiff, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qg2qqqbarDiff_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qqqbarDiff *arg1 = (Pythia8::Sigma3qg2qqqbarDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qg2qqqbarDiff_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qg2qqqbarDiff_initProc" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qqqbarDiff *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qqqbarDiff * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qg2qqqbarDiff_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qqqbarDiff *arg1 = (Pythia8::Sigma3qg2qqqbarDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qg2qqqbarDiff_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qg2qqqbarDiff_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qqqbarDiff *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qqqbarDiff * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qg2qqqbarDiff_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qqqbarDiff *arg1 = (Pythia8::Sigma3qg2qqqbarDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qg2qqqbarDiff_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qg2qqqbarDiff_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qqqbarDiff *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qqqbarDiff * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qg2qqqbarDiff_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qqqbarDiff *arg1 = (Pythia8::Sigma3qg2qqqbarDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qg2qqqbarDiff_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qg2qqqbarDiff_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qqqbarDiff *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qqqbarDiff * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qg2qqqbarDiff_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qqqbarDiff *arg1 = (Pythia8::Sigma3qg2qqqbarDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qg2qqqbarDiff_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qg2qqqbarDiff_name" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qqqbarDiff const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qqqbarDiff * >(argp1);
  result = ((Pythia8::Sigma3qg2qqqbarDiff const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qg2qqqbarDiff_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qqqbarDiff *arg1 = (Pythia8::Sigma3qg2qqqbarDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qg2qqqbarDiff_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qg2qqqbarDiff_code" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qqqbarDiff const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qqqbarDiff * >(argp1);
  result = (int)((Pythia8::Sigma3qg2qqqbarDiff const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qg2qqqbarDiff_nFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qqqbarDiff *arg1 = (Pythia8::Sigma3qg2qqqbarDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qg2qqqbarDiff_nFinal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qg2qqqbarDiff_nFinal" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qqqbarDiff const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qqqbarDiff * >(argp1);
  result = (int)((Pythia8::Sigma3qg2qqqbarDiff const *)arg1)->nFinal();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qg2qqqbarDiff_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qqqbarDiff *arg1 = (Pythia8::Sigma3qg2qqqbarDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qg2qqqbarDiff_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qg2qqqbarDiff_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qqqbarDiff const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qqqbarDiff * >(argp1);
  result = ((Pythia8::Sigma3qg2qqqbarDiff const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qg2qqqbarDiff_isQCD3body(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qqqbarDiff *arg1 = (Pythia8::Sigma3qg2qqqbarDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qg2qqqbarDiff_isQCD3body",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarDiff, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qg2qqqbarDiff_isQCD3body" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qqqbarDiff const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qqqbarDiff * >(argp1);
  result = (bool)((Pythia8::Sigma3qg2qqqbarDiff const *)arg1)->isQCD3body();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma3qg2qqqbarDiff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qqqbarDiff *arg1 = (Pythia8::Sigma3qg2qqqbarDiff *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma3qg2qqqbarDiff",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarDiff, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma3qg2qqqbarDiff" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qqqbarDiff *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qqqbarDiff * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma3qg2qqqbarDiff_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarDiff, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma3qq2qqgSame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qq2qqgSame *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma3qq2qqgSame")) SWIG_fail;
  result = (Pythia8::Sigma3qq2qqgSame *)new Pythia8::Sigma3qq2qqgSame();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma3qq2qqgSame, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qq2qqgSame_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qq2qqgSame *arg1 = (Pythia8::Sigma3qq2qqgSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qq2qqgSame_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qq2qqgSame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qq2qqgSame_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma3qq2qqgSame *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qq2qqgSame * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qq2qqgSame_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qq2qqgSame *arg1 = (Pythia8::Sigma3qq2qqgSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qq2qqgSame_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qq2qqgSame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qq2qqgSame_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma3qq2qqgSame *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qq2qqgSame * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qq2qqgSame_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qq2qqgSame *arg1 = (Pythia8::Sigma3qq2qqgSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qq2qqgSame_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qq2qqgSame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qq2qqgSame_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma3qq2qqgSame *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qq2qqgSame * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qq2qqgSame_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qq2qqgSame *arg1 = (Pythia8::Sigma3qq2qqgSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qq2qqgSame_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qq2qqgSame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qq2qqgSame_name" "', argument " "1"" of type '" "Pythia8::Sigma3qq2qqgSame const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qq2qqgSame * >(argp1);
  result = ((Pythia8::Sigma3qq2qqgSame const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qq2qqgSame_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qq2qqgSame *arg1 = (Pythia8::Sigma3qq2qqgSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qq2qqgSame_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qq2qqgSame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qq2qqgSame_code" "', argument " "1"" of type '" "Pythia8::Sigma3qq2qqgSame const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qq2qqgSame * >(argp1);
  result = (int)((Pythia8::Sigma3qq2qqgSame const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qq2qqgSame_nFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qq2qqgSame *arg1 = (Pythia8::Sigma3qq2qqgSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qq2qqgSame_nFinal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qq2qqgSame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qq2qqgSame_nFinal" "', argument " "1"" of type '" "Pythia8::Sigma3qq2qqgSame const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qq2qqgSame * >(argp1);
  result = (int)((Pythia8::Sigma3qq2qqgSame const *)arg1)->nFinal();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qq2qqgSame_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qq2qqgSame *arg1 = (Pythia8::Sigma3qq2qqgSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qq2qqgSame_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qq2qqgSame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qq2qqgSame_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma3qq2qqgSame const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qq2qqgSame * >(argp1);
  result = ((Pythia8::Sigma3qq2qqgSame const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qq2qqgSame_isQCD3body(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qq2qqgSame *arg1 = (Pythia8::Sigma3qq2qqgSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qq2qqgSame_isQCD3body",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qq2qqgSame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qq2qqgSame_isQCD3body" "', argument " "1"" of type '" "Pythia8::Sigma3qq2qqgSame const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qq2qqgSame * >(argp1);
  result = (bool)((Pythia8::Sigma3qq2qqgSame const *)arg1)->isQCD3body();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma3qq2qqgSame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qq2qqgSame *arg1 = (Pythia8::Sigma3qq2qqgSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma3qq2qqgSame",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qq2qqgSame, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma3qq2qqgSame" "', argument " "1"" of type '" "Pythia8::Sigma3qq2qqgSame *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qq2qqgSame * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma3qq2qqgSame_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma3qq2qqgSame, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma3qqbar2qqbargSame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2qqbargSame *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma3qqbar2qqbargSame")) SWIG_fail;
  result = (Pythia8::Sigma3qqbar2qqbargSame *)new Pythia8::Sigma3qqbar2qqbargSame();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargSame, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2qqbargSame_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2qqbargSame *arg1 = (Pythia8::Sigma3qqbar2qqbargSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2qqbargSame_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargSame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2qqbargSame_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2qqbargSame *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2qqbargSame * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2qqbargSame_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2qqbargSame *arg1 = (Pythia8::Sigma3qqbar2qqbargSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2qqbargSame_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargSame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2qqbargSame_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2qqbargSame *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2qqbargSame * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2qqbargSame_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2qqbargSame *arg1 = (Pythia8::Sigma3qqbar2qqbargSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2qqbargSame_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargSame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2qqbargSame_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2qqbargSame *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2qqbargSame * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2qqbargSame_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2qqbargSame *arg1 = (Pythia8::Sigma3qqbar2qqbargSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2qqbargSame_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargSame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2qqbargSame_name" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2qqbargSame const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2qqbargSame * >(argp1);
  result = ((Pythia8::Sigma3qqbar2qqbargSame const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2qqbargSame_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2qqbargSame *arg1 = (Pythia8::Sigma3qqbar2qqbargSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2qqbargSame_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargSame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2qqbargSame_code" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2qqbargSame const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2qqbargSame * >(argp1);
  result = (int)((Pythia8::Sigma3qqbar2qqbargSame const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2qqbargSame_nFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2qqbargSame *arg1 = (Pythia8::Sigma3qqbar2qqbargSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2qqbargSame_nFinal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargSame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2qqbargSame_nFinal" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2qqbargSame const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2qqbargSame * >(argp1);
  result = (int)((Pythia8::Sigma3qqbar2qqbargSame const *)arg1)->nFinal();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2qqbargSame_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2qqbargSame *arg1 = (Pythia8::Sigma3qqbar2qqbargSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2qqbargSame_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargSame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2qqbargSame_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2qqbargSame const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2qqbargSame * >(argp1);
  result = ((Pythia8::Sigma3qqbar2qqbargSame const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2qqbargSame_isQCD3body(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2qqbargSame *arg1 = (Pythia8::Sigma3qqbar2qqbargSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2qqbargSame_isQCD3body",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargSame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2qqbargSame_isQCD3body" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2qqbargSame const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2qqbargSame * >(argp1);
  result = (bool)((Pythia8::Sigma3qqbar2qqbargSame const *)arg1)->isQCD3body();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma3qqbar2qqbargSame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2qqbargSame *arg1 = (Pythia8::Sigma3qqbar2qqbargSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma3qqbar2qqbargSame",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargSame, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma3qqbar2qqbargSame" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2qqbargSame *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2qqbargSame * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma3qqbar2qqbargSame_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma3qqbar2qqbargSame, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma3qg2qqqbarSame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qqqbarSame *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma3qg2qqqbarSame")) SWIG_fail;
  result = (Pythia8::Sigma3qg2qqqbarSame *)new Pythia8::Sigma3qg2qqqbarSame();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarSame, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qg2qqqbarSame_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qqqbarSame *arg1 = (Pythia8::Sigma3qg2qqqbarSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qg2qqqbarSame_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarSame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qg2qqqbarSame_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qqqbarSame *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qqqbarSame * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qg2qqqbarSame_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qqqbarSame *arg1 = (Pythia8::Sigma3qg2qqqbarSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qg2qqqbarSame_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarSame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qg2qqqbarSame_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qqqbarSame *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qqqbarSame * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qg2qqqbarSame_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qqqbarSame *arg1 = (Pythia8::Sigma3qg2qqqbarSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qg2qqqbarSame_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarSame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qg2qqqbarSame_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qqqbarSame *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qqqbarSame * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qg2qqqbarSame_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qqqbarSame *arg1 = (Pythia8::Sigma3qg2qqqbarSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qg2qqqbarSame_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarSame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qg2qqqbarSame_name" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qqqbarSame const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qqqbarSame * >(argp1);
  result = ((Pythia8::Sigma3qg2qqqbarSame const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qg2qqqbarSame_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qqqbarSame *arg1 = (Pythia8::Sigma3qg2qqqbarSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qg2qqqbarSame_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarSame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qg2qqqbarSame_code" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qqqbarSame const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qqqbarSame * >(argp1);
  result = (int)((Pythia8::Sigma3qg2qqqbarSame const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qg2qqqbarSame_nFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qqqbarSame *arg1 = (Pythia8::Sigma3qg2qqqbarSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qg2qqqbarSame_nFinal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarSame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qg2qqqbarSame_nFinal" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qqqbarSame const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qqqbarSame * >(argp1);
  result = (int)((Pythia8::Sigma3qg2qqqbarSame const *)arg1)->nFinal();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qg2qqqbarSame_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qqqbarSame *arg1 = (Pythia8::Sigma3qg2qqqbarSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qg2qqqbarSame_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarSame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qg2qqqbarSame_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qqqbarSame const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qqqbarSame * >(argp1);
  result = ((Pythia8::Sigma3qg2qqqbarSame const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qg2qqqbarSame_isQCD3body(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qqqbarSame *arg1 = (Pythia8::Sigma3qg2qqqbarSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qg2qqqbarSame_isQCD3body",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarSame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qg2qqqbarSame_isQCD3body" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qqqbarSame const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qqqbarSame * >(argp1);
  result = (bool)((Pythia8::Sigma3qg2qqqbarSame const *)arg1)->isQCD3body();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma3qg2qqqbarSame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qg2qqqbarSame *arg1 = (Pythia8::Sigma3qg2qqqbarSame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma3qg2qqqbarSame",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarSame, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma3qg2qqqbarSame" "', argument " "1"" of type '" "Pythia8::Sigma3qg2qqqbarSame *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qg2qqqbarSame * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma3qg2qqqbarSame_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma3qg2qqqbarSame, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_UserHooks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UserHooks",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UserHooks" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_initPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = (Pythia8::Settings *) 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  Pythia8::BeamParticle *arg6 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg7 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg8 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg9 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::CoupSM *arg10 = (Pythia8::CoupSM *) 0 ;
  Pythia8::PartonSystems *arg11 = (Pythia8::PartonSystems *) 0 ;
  Pythia8::SigmaTotal *arg12 = (Pythia8::SigmaTotal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:UserHooks_initPtr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_initPtr" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooks_initPtr" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UserHooks_initPtr" "', argument " "3"" of type '" "Pythia8::Settings *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "UserHooks_initPtr" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "UserHooks_initPtr" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "UserHooks_initPtr" "', argument " "6"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::BeamParticle * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "UserHooks_initPtr" "', argument " "7"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::BeamParticle * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "UserHooks_initPtr" "', argument " "8"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::BeamParticle * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "UserHooks_initPtr" "', argument " "9"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::BeamParticle * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "UserHooks_initPtr" "', argument " "10"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg10 = reinterpret_cast< Pythia8::CoupSM * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "UserHooks_initPtr" "', argument " "11"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg11 = reinterpret_cast< Pythia8::PartonSystems * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "UserHooks_initPtr" "', argument " "12"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg12 = reinterpret_cast< Pythia8::SigmaTotal * >(argp12);
  (arg1)->initPtr(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_initAfterBeams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_initAfterBeams",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_initAfterBeams" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::initAfterBeams();
    } else {
      result = (bool)(arg1)->initAfterBeams();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_canModifySigma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_canModifySigma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_canModifySigma" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::canModifySigma();
    } else {
      result = (bool)(arg1)->canModifySigma();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_multiplySigmaBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  Pythia8::SigmaProcess *arg2 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::PhaseSpace *arg3 = (Pythia8::PhaseSpace *) 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:UserHooks_multiplySigmaBy",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_multiplySigmaBy" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooks_multiplySigmaBy" "', argument " "2"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::SigmaProcess * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UserHooks_multiplySigmaBy" "', argument " "3"" of type '" "Pythia8::PhaseSpace const *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PhaseSpace * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "UserHooks_multiplySigmaBy" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::UserHooks::multiplySigmaBy((Pythia8::SigmaProcess const *)arg2,(Pythia8::PhaseSpace const *)arg3,arg4);
    } else {
      result = (double)(arg1)->multiplySigmaBy((Pythia8::SigmaProcess const *)arg2,(Pythia8::PhaseSpace const *)arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_canBiasSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_canBiasSelection",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_canBiasSelection" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::canBiasSelection();
    } else {
      result = (bool)(arg1)->canBiasSelection();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_biasSelectionBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  Pythia8::SigmaProcess *arg2 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::PhaseSpace *arg3 = (Pythia8::PhaseSpace *) 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:UserHooks_biasSelectionBy",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_biasSelectionBy" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooks_biasSelectionBy" "', argument " "2"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::SigmaProcess * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UserHooks_biasSelectionBy" "', argument " "3"" of type '" "Pythia8::PhaseSpace const *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PhaseSpace * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "UserHooks_biasSelectionBy" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::UserHooks::biasSelectionBy((Pythia8::SigmaProcess const *)arg2,(Pythia8::PhaseSpace const *)arg3,arg4);
    } else {
      result = (double)(arg1)->biasSelectionBy((Pythia8::SigmaProcess const *)arg2,(Pythia8::PhaseSpace const *)arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_biasedSelectionWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_biasedSelectionWeight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_biasedSelectionWeight" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::UserHooks::biasedSelectionWeight();
    } else {
      result = (double)(arg1)->biasedSelectionWeight();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_canVetoProcessLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_canVetoProcessLevel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_canVetoProcessLevel" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::canVetoProcessLevel();
    } else {
      result = (bool)(arg1)->canVetoProcessLevel();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_doVetoProcessLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_doVetoProcessLevel",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_doVetoProcessLevel" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooks_doVetoProcessLevel" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooks_doVetoProcessLevel" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::doVetoProcessLevel(*arg2);
    } else {
      result = (bool)(arg1)->doVetoProcessLevel(*arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_canVetoResonanceDecays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_canVetoResonanceDecays",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_canVetoResonanceDecays" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::canVetoResonanceDecays();
    } else {
      result = (bool)(arg1)->canVetoResonanceDecays();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_doVetoResonanceDecays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_doVetoResonanceDecays",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_doVetoResonanceDecays" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooks_doVetoResonanceDecays" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooks_doVetoResonanceDecays" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::doVetoResonanceDecays(*arg2);
    } else {
      result = (bool)(arg1)->doVetoResonanceDecays(*arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_canVetoPT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_canVetoPT",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_canVetoPT" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::canVetoPT();
    } else {
      result = (bool)(arg1)->canVetoPT();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_scaleVetoPT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_scaleVetoPT",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_scaleVetoPT" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::UserHooks::scaleVetoPT();
    } else {
      result = (double)(arg1)->scaleVetoPT();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_doVetoPT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:UserHooks_doVetoPT",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_doVetoPT" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UserHooks_doVetoPT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UserHooks_doVetoPT" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooks_doVetoPT" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::doVetoPT(arg2,(Pythia8::Event const &)*arg3);
    } else {
      result = (bool)(arg1)->doVetoPT(arg2,(Pythia8::Event const &)*arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_canVetoStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_canVetoStep",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_canVetoStep" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::canVetoStep();
    } else {
      result = (bool)(arg1)->canVetoStep();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_numberVetoStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_numberVetoStep",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_numberVetoStep" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Pythia8::UserHooks::numberVetoStep();
    } else {
      result = (int)(arg1)->numberVetoStep();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_doVetoStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  Pythia8::Event *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:UserHooks_doVetoStep",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_doVetoStep" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UserHooks_doVetoStep" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UserHooks_doVetoStep" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "UserHooks_doVetoStep" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "UserHooks_doVetoStep" "', argument " "5"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooks_doVetoStep" "', argument " "5"" of type '" "Pythia8::Event const &""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Event * >(argp5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::doVetoStep(arg2,arg3,arg4,(Pythia8::Event const &)*arg5);
    } else {
      result = (bool)(arg1)->doVetoStep(arg2,arg3,arg4,(Pythia8::Event const &)*arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_canVetoMPIStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_canVetoMPIStep",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_canVetoMPIStep" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::canVetoMPIStep();
    } else {
      result = (bool)(arg1)->canVetoMPIStep();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_numberVetoMPIStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_numberVetoMPIStep",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_numberVetoMPIStep" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Pythia8::UserHooks::numberVetoMPIStep();
    } else {
      result = (int)(arg1)->numberVetoMPIStep();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_doVetoMPIStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:UserHooks_doVetoMPIStep",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_doVetoMPIStep" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UserHooks_doVetoMPIStep" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UserHooks_doVetoMPIStep" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooks_doVetoMPIStep" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::doVetoMPIStep(arg2,(Pythia8::Event const &)*arg3);
    } else {
      result = (bool)(arg1)->doVetoMPIStep(arg2,(Pythia8::Event const &)*arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_canVetoPartonLevelEarly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_canVetoPartonLevelEarly",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_canVetoPartonLevelEarly" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::canVetoPartonLevelEarly();
    } else {
      result = (bool)(arg1)->canVetoPartonLevelEarly();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_doVetoPartonLevelEarly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_doVetoPartonLevelEarly",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_doVetoPartonLevelEarly" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooks_doVetoPartonLevelEarly" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooks_doVetoPartonLevelEarly" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::doVetoPartonLevelEarly((Pythia8::Event const &)*arg2);
    } else {
      result = (bool)(arg1)->doVetoPartonLevelEarly((Pythia8::Event const &)*arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_retryPartonLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_retryPartonLevel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_retryPartonLevel" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::retryPartonLevel();
    } else {
      result = (bool)(arg1)->retryPartonLevel();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_canVetoPartonLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_canVetoPartonLevel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_canVetoPartonLevel" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::canVetoPartonLevel();
    } else {
      result = (bool)(arg1)->canVetoPartonLevel();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_doVetoPartonLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_doVetoPartonLevel",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_doVetoPartonLevel" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooks_doVetoPartonLevel" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooks_doVetoPartonLevel" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::doVetoPartonLevel((Pythia8::Event const &)*arg2);
    } else {
      result = (bool)(arg1)->doVetoPartonLevel((Pythia8::Event const &)*arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_canSetResonanceScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_canSetResonanceScale",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_canSetResonanceScale" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::canSetResonanceScale();
    } else {
      result = (bool)(arg1)->canSetResonanceScale();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_scaleResonance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:UserHooks_scaleResonance",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_scaleResonance" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UserHooks_scaleResonance" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UserHooks_scaleResonance" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooks_scaleResonance" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::UserHooks::scaleResonance(arg2,(Pythia8::Event const &)*arg3);
    } else {
      result = (double)(arg1)->scaleResonance(arg2,(Pythia8::Event const &)*arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_canVetoISREmission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_canVetoISREmission",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_canVetoISREmission" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::canVetoISREmission();
    } else {
      result = (bool)(arg1)->canVetoISREmission();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_doVetoISREmission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:UserHooks_doVetoISREmission",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_doVetoISREmission" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UserHooks_doVetoISREmission" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UserHooks_doVetoISREmission" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooks_doVetoISREmission" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "UserHooks_doVetoISREmission" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::doVetoISREmission(arg2,(Pythia8::Event const &)*arg3,arg4);
    } else {
      result = (bool)(arg1)->doVetoISREmission(arg2,(Pythia8::Event const &)*arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_canVetoFSREmission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_canVetoFSREmission",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_canVetoFSREmission" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::canVetoFSREmission();
    } else {
      result = (bool)(arg1)->canVetoFSREmission();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_doVetoFSREmission__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  int arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:UserHooks_doVetoFSREmission",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_doVetoFSREmission" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UserHooks_doVetoFSREmission" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UserHooks_doVetoFSREmission" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooks_doVetoFSREmission" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "UserHooks_doVetoFSREmission" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "UserHooks_doVetoFSREmission" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::doVetoFSREmission(arg2,(Pythia8::Event const &)*arg3,arg4,arg5);
    } else {
      result = (bool)(arg1)->doVetoFSREmission(arg2,(Pythia8::Event const &)*arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_doVetoFSREmission__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:UserHooks_doVetoFSREmission",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_doVetoFSREmission" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UserHooks_doVetoFSREmission" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UserHooks_doVetoFSREmission" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooks_doVetoFSREmission" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "UserHooks_doVetoFSREmission" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::doVetoFSREmission(arg2,(Pythia8::Event const &)*arg3,arg4);
    } else {
      result = (bool)(arg1)->doVetoFSREmission(arg2,(Pythia8::Event const &)*arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_doVetoFSREmission(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__UserHooks, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Event, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_UserHooks_doVetoFSREmission__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__UserHooks, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Event, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_UserHooks_doVetoFSREmission__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'UserHooks_doVetoFSREmission'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::UserHooks::doVetoFSREmission(int,Pythia8::Event const &,int,bool)\n"
    "    Pythia8::UserHooks::doVetoFSREmission(int,Pythia8::Event const &,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UserHooks_canVetoMPIEmission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_canVetoMPIEmission",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_canVetoMPIEmission" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::canVetoMPIEmission();
    } else {
      result = (bool)(arg1)->canVetoMPIEmission();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_doVetoMPIEmission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:UserHooks_doVetoMPIEmission",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_doVetoMPIEmission" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UserHooks_doVetoMPIEmission" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UserHooks_doVetoMPIEmission" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooks_doVetoMPIEmission" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::doVetoMPIEmission(arg2,(Pythia8::Event const &)*arg3);
    } else {
      result = (bool)(arg1)->doVetoMPIEmission(arg2,(Pythia8::Event const &)*arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_canReconnectResonanceSystems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_canReconnectResonanceSystems",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_canReconnectResonanceSystems" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::canReconnectResonanceSystems();
    } else {
      result = (bool)(arg1)->canReconnectResonanceSystems();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_doReconnectResonanceSystems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:UserHooks_doReconnectResonanceSystems",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_doReconnectResonanceSystems" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UserHooks_doReconnectResonanceSystems" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UserHooks_doReconnectResonanceSystems" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooks_doReconnectResonanceSystems" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::doReconnectResonanceSystems(arg2,*arg3);
    } else {
      result = (bool)(arg1)->doReconnectResonanceSystems(arg2,*arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_canEnhanceEmission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_canEnhanceEmission",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_canEnhanceEmission" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::canEnhanceEmission();
    } else {
      result = (bool)(arg1)->canEnhanceEmission();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_enhanceFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_enhanceFactor",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_enhanceFactor" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "UserHooks_enhanceFactor" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::UserHooks::enhanceFactor(arg2);
    } else {
      result = (double)(arg1)->enhanceFactor(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_vetoProbability(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_vetoProbability",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_vetoProbability" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "UserHooks_vetoProbability" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::UserHooks::vetoProbability(arg2);
    } else {
      result = (double)(arg1)->vetoProbability(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_setEnhancedEventWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_setEnhancedEventWeight",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_setEnhancedEventWeight" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UserHooks_setEnhancedEventWeight" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setEnhancedEventWeight(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_getEnhancedEventWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_getEnhancedEventWeight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_getEnhancedEventWeight" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  result = (double)(arg1)->getEnhancedEventWeight();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_canEnhanceTrial(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_canEnhanceTrial",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_canEnhanceTrial" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::canEnhanceTrial();
    } else {
      result = (bool)(arg1)->canEnhanceTrial();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_setEnhancedTrial(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:UserHooks_setEnhancedTrial",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_setEnhancedTrial" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UserHooks_setEnhancedTrial" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UserHooks_setEnhancedTrial" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->setEnhancedTrial(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_getEnhancedTrialPT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_getEnhancedTrialPT",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_getEnhancedTrialPT" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  result = (double)(arg1)->getEnhancedTrialPT();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_getEnhancedTrialWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_getEnhancedTrialWeight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_getEnhancedTrialWeight" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  result = (double)(arg1)->getEnhancedTrialWeight();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_canChangeFragPar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_canChangeFragPar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_canChangeFragPar" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::canChangeFragPar();
    } else {
      result = (bool)(arg1)->canChangeFragPar();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_doChangeFragPar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  Pythia8::StringFlav *arg2 = (Pythia8::StringFlav *) 0 ;
  Pythia8::StringZ *arg3 = (Pythia8::StringZ *) 0 ;
  Pythia8::StringPT *arg4 = (Pythia8::StringPT *) 0 ;
  int arg5 ;
  double arg6 ;
  std::vector< int,std::allocator< int > > arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:UserHooks_doChangeFragPar",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_doChangeFragPar" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooks_doChangeFragPar" "', argument " "2"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::StringFlav * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__StringZ, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UserHooks_doChangeFragPar" "', argument " "3"" of type '" "Pythia8::StringZ *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::StringZ * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__StringPT, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "UserHooks_doChangeFragPar" "', argument " "4"" of type '" "Pythia8::StringPT *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::StringPT * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "UserHooks_doChangeFragPar" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "UserHooks_doChangeFragPar" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj6, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "UserHooks_doChangeFragPar" "', argument " "7"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg7 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::doChangeFragPar(arg2,arg3,arg4,arg5,arg6,arg7);
    } else {
      result = (bool)(arg1)->doChangeFragPar(arg2,arg3,arg4,arg5,arg6,arg7);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_doVetoFragmentation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  Pythia8::Particle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_doVetoFragmentation",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_doVetoFragmentation" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Particle,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooks_doVetoFragmentation" "', argument " "2"" of type '" "Pythia8::Particle""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooks_doVetoFragmentation" "', argument " "2"" of type '" "Pythia8::Particle""'");
    } else {
      Pythia8::Particle * temp = reinterpret_cast< Pythia8::Particle * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::UserHooks::doVetoFragmentation(arg2);
    } else {
      result = (bool)(arg1)->doVetoFragmentation(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_canSetImpactParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_canSetImpactParameter",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_canSetImpactParameter" "', argument " "1"" of type '" "Pythia8::UserHooks const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)((Pythia8::UserHooks const *)arg1)->Pythia8::UserHooks::canSetImpactParameter();
    } else {
      result = (bool)((Pythia8::UserHooks const *)arg1)->canSetImpactParameter();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_doSetImpactParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_doSetImpactParameter",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_doSetImpactParameter" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::UserHooks::doSetImpactParameter();
    } else {
      result = (double)(arg1)->doSetImpactParameter();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UserHooks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::UserHooks *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_UserHooks",&obj0)) SWIG_fail;
  arg1 = obj0;
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (Pythia8::UserHooks *)new SwigDirector_UserHooks(arg1); 
  } else {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
    SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__UserHooks, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_infoPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_infoPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_infoPtr_set" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooks_infoPtr_set" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  if (arg1) darg->infoPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_infoPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  Pythia8::Info *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_infoPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_infoPtr_get" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  result = (Pythia8::Info *) (darg->infoPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_settingsPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  Pythia8::Settings *arg2 = (Pythia8::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_settingsPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_settingsPtr_set" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Settings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooks_settingsPtr_set" "', argument " "2"" of type '" "Pythia8::Settings *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  if (arg1) darg->settingsPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_settingsPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  Pythia8::Settings *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_settingsPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_settingsPtr_get" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  result = (Pythia8::Settings *) (darg->settingsPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_particleDataPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  Pythia8::ParticleData *arg2 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_particleDataPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_particleDataPtr_set" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ParticleData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooks_particleDataPtr_set" "', argument " "2"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ParticleData * >(argp2);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  if (arg1) darg->particleDataPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_particleDataPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  Pythia8::ParticleData *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_particleDataPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_particleDataPtr_get" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  result = (Pythia8::ParticleData *) (darg->particleDataPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_rndmPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  Pythia8::Rndm *arg2 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_rndmPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_rndmPtr_set" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Rndm, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooks_rndmPtr_set" "', argument " "2"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Rndm * >(argp2);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  if (arg1) darg->rndmPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_rndmPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  Pythia8::Rndm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_rndmPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_rndmPtr_get" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  result = (Pythia8::Rndm *) (darg->rndmPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_beamAPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  Pythia8::BeamParticle *arg2 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_beamAPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_beamAPtr_set" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__BeamParticle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooks_beamAPtr_set" "', argument " "2"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::BeamParticle * >(argp2);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  if (arg1) darg->beamAPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_beamAPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  Pythia8::BeamParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_beamAPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_beamAPtr_get" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  result = (Pythia8::BeamParticle *) (darg->beamAPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_beamBPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  Pythia8::BeamParticle *arg2 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_beamBPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_beamBPtr_set" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__BeamParticle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooks_beamBPtr_set" "', argument " "2"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::BeamParticle * >(argp2);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  if (arg1) darg->beamBPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_beamBPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  Pythia8::BeamParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_beamBPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_beamBPtr_get" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  result = (Pythia8::BeamParticle *) (darg->beamBPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_beamPomAPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  Pythia8::BeamParticle *arg2 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_beamPomAPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_beamPomAPtr_set" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__BeamParticle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooks_beamPomAPtr_set" "', argument " "2"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::BeamParticle * >(argp2);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  if (arg1) darg->beamPomAPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_beamPomAPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  Pythia8::BeamParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_beamPomAPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_beamPomAPtr_get" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  result = (Pythia8::BeamParticle *) (darg->beamPomAPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_beamPomBPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  Pythia8::BeamParticle *arg2 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_beamPomBPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_beamPomBPtr_set" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__BeamParticle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooks_beamPomBPtr_set" "', argument " "2"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::BeamParticle * >(argp2);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  if (arg1) darg->beamPomBPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_beamPomBPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  Pythia8::BeamParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_beamPomBPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_beamPomBPtr_get" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  result = (Pythia8::BeamParticle *) (darg->beamPomBPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_coupSMPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  Pythia8::CoupSM *arg2 = (Pythia8::CoupSM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_coupSMPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_coupSMPtr_set" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__CoupSM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooks_coupSMPtr_set" "', argument " "2"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::CoupSM * >(argp2);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  if (arg1) darg->coupSMPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_coupSMPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  Pythia8::CoupSM *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_coupSMPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_coupSMPtr_get" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  result = (Pythia8::CoupSM *) (darg->coupSMPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_partonSystemsPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  Pythia8::PartonSystems *arg2 = (Pythia8::PartonSystems *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_partonSystemsPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_partonSystemsPtr_set" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PartonSystems, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooks_partonSystemsPtr_set" "', argument " "2"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PartonSystems * >(argp2);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  if (arg1) darg->partonSystemsPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_partonSystemsPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  Pythia8::PartonSystems *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_partonSystemsPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_partonSystemsPtr_get" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  result = (Pythia8::PartonSystems *) (darg->partonSystemsPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_sigmaTotPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  Pythia8::SigmaTotal *arg2 = (Pythia8::SigmaTotal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_sigmaTotPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_sigmaTotPtr_set" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__SigmaTotal, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooks_sigmaTotPtr_set" "', argument " "2"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::SigmaTotal * >(argp2);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  if (arg1) darg->sigmaTotPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_sigmaTotPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  Pythia8::SigmaTotal *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_sigmaTotPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_sigmaTotPtr_get" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  result = (Pythia8::SigmaTotal *) (darg->sigmaTotPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_omitResonanceDecays__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:UserHooks_omitResonanceDecays",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_omitResonanceDecays" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooks_omitResonanceDecays" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooks_omitResonanceDecays" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UserHooks_omitResonanceDecays" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  (darg)->omitResonanceDecays((Pythia8::Event const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_omitResonanceDecays__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_omitResonanceDecays",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_omitResonanceDecays" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooks_omitResonanceDecays" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooks_omitResonanceDecays" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  (darg)->omitResonanceDecays((Pythia8::Event const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_omitResonanceDecays(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__UserHooks, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_UserHooks_omitResonanceDecays__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__UserHooks, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UserHooks_omitResonanceDecays__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'UserHooks_omitResonanceDecays'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::UserHooks::omitResonanceDecays(Pythia8::Event const &,bool)\n"
    "    Pythia8::UserHooks::omitResonanceDecays(Pythia8::Event const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UserHooks_subEvent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:UserHooks_subEvent",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_subEvent" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooks_subEvent" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooks_subEvent" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UserHooks_subEvent" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  (darg)->subEvent((Pythia8::Event const &)*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_subEvent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_subEvent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_subEvent" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooks_subEvent" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooks_subEvent" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  (darg)->subEvent((Pythia8::Event const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_subEvent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__UserHooks, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_UserHooks_subEvent__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__UserHooks, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UserHooks_subEvent__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'UserHooks_subEvent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::UserHooks::subEvent(Pythia8::Event const &,bool)\n"
    "    Pythia8::UserHooks::subEvent(Pythia8::Event const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UserHooks_workEvent_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  Pythia8::Event *arg2 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_workEvent_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_workEvent_set" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooks_workEvent_set" "', argument " "2"" of type '" "Pythia8::Event *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  if (arg1) darg->workEvent = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_workEvent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  Pythia8::Event *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_workEvent_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_workEvent_get" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  result = (Pythia8::Event *)& (darg->workEvent);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_selBias_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_selBias_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_selBias_set" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UserHooks_selBias_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  if (arg1) darg->selBias = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_selBias_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_selBias_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_selBias_get" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  result = (double) (darg->selBias);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_enhancedEventWeight_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_enhancedEventWeight_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_enhancedEventWeight_set" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UserHooks_enhancedEventWeight_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  if (arg1) darg->enhancedEventWeight = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_enhancedEventWeight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_enhancedEventWeight_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_enhancedEventWeight_get" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  result = (double) (darg->enhancedEventWeight);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_pTEnhanced_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_pTEnhanced_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_pTEnhanced_set" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UserHooks_pTEnhanced_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  if (arg1) darg->pTEnhanced = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_pTEnhanced_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_pTEnhanced_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_pTEnhanced_get" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  result = (double) (darg->pTEnhanced);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_wtEnhanced_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooks_wtEnhanced_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_wtEnhanced_set" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UserHooks_wtEnhanced_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  if (arg1) darg->wtEnhanced = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooks_wtEnhanced_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_UserHooks *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooks_wtEnhanced_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooks_wtEnhanced_get" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  darg = dynamic_cast<SwigDirector_UserHooks *>(arg1);
  result = (double) (darg->wtEnhanced);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_UserHooks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooks *arg1 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:disown_UserHooks",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_UserHooks" "', argument " "1"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooks * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UserHooks_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__UserHooks, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SuppressSmallPT__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  int arg2 ;
  bool arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::SuppressSmallPT *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_SuppressSmallPT",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SuppressSmallPT" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SuppressSmallPT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SuppressSmallPT" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (Pythia8::SuppressSmallPT *)new Pythia8::SuppressSmallPT(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SuppressSmallPT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SuppressSmallPT__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  int arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::SuppressSmallPT *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_SuppressSmallPT",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SuppressSmallPT" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SuppressSmallPT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::SuppressSmallPT *)new Pythia8::SuppressSmallPT(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SuppressSmallPT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SuppressSmallPT__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::SuppressSmallPT *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SuppressSmallPT",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SuppressSmallPT" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  result = (Pythia8::SuppressSmallPT *)new Pythia8::SuppressSmallPT(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SuppressSmallPT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SuppressSmallPT__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SuppressSmallPT *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SuppressSmallPT")) SWIG_fail;
  result = (Pythia8::SuppressSmallPT *)new Pythia8::SuppressSmallPT();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SuppressSmallPT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SuppressSmallPT(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_SuppressSmallPT__SWIG_3(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SuppressSmallPT__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SuppressSmallPT__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SuppressSmallPT__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SuppressSmallPT'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SuppressSmallPT::SuppressSmallPT(double,int,bool)\n"
    "    Pythia8::SuppressSmallPT::SuppressSmallPT(double,int)\n"
    "    Pythia8::SuppressSmallPT::SuppressSmallPT(double)\n"
    "    Pythia8::SuppressSmallPT::SuppressSmallPT()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SuppressSmallPT_canModifySigma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SuppressSmallPT *arg1 = (Pythia8::SuppressSmallPT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SuppressSmallPT_canModifySigma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SuppressSmallPT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuppressSmallPT_canModifySigma" "', argument " "1"" of type '" "Pythia8::SuppressSmallPT *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SuppressSmallPT * >(argp1);
  result = (bool)(arg1)->canModifySigma();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuppressSmallPT_multiplySigmaBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SuppressSmallPT *arg1 = (Pythia8::SuppressSmallPT *) 0 ;
  Pythia8::SigmaProcess *arg2 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::PhaseSpace *arg3 = (Pythia8::PhaseSpace *) 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SuppressSmallPT_multiplySigmaBy",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SuppressSmallPT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuppressSmallPT_multiplySigmaBy" "', argument " "1"" of type '" "Pythia8::SuppressSmallPT *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SuppressSmallPT * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SuppressSmallPT_multiplySigmaBy" "', argument " "2"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::SigmaProcess * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SuppressSmallPT_multiplySigmaBy" "', argument " "3"" of type '" "Pythia8::PhaseSpace const *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PhaseSpace * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SuppressSmallPT_multiplySigmaBy" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (double)(arg1)->multiplySigmaBy((Pythia8::SigmaProcess const *)arg2,(Pythia8::PhaseSpace const *)arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SuppressSmallPT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SuppressSmallPT *arg1 = (Pythia8::SuppressSmallPT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SuppressSmallPT",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SuppressSmallPT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SuppressSmallPT" "', argument " "1"" of type '" "Pythia8::SuppressSmallPT *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SuppressSmallPT * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SuppressSmallPT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SuppressSmallPT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_UserHooksVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_UserHooksVector",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UserHooksVector" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_initAfterBeams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_initAfterBeams",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_initAfterBeams" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (bool)(arg1)->initAfterBeams();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_canModifySigma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_canModifySigma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_canModifySigma" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (bool)(arg1)->canModifySigma();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_multiplySigmaBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  Pythia8::SigmaProcess *arg2 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::PhaseSpace *arg3 = (Pythia8::PhaseSpace *) 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:UserHooksVector_multiplySigmaBy",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_multiplySigmaBy" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooksVector_multiplySigmaBy" "', argument " "2"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::SigmaProcess * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UserHooksVector_multiplySigmaBy" "', argument " "3"" of type '" "Pythia8::PhaseSpace const *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PhaseSpace * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "UserHooksVector_multiplySigmaBy" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (double)(arg1)->multiplySigmaBy((Pythia8::SigmaProcess const *)arg2,(Pythia8::PhaseSpace const *)arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_canBiasSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_canBiasSelection",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_canBiasSelection" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (bool)(arg1)->canBiasSelection();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_biasSelectionBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  Pythia8::SigmaProcess *arg2 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::PhaseSpace *arg3 = (Pythia8::PhaseSpace *) 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:UserHooksVector_biasSelectionBy",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_biasSelectionBy" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooksVector_biasSelectionBy" "', argument " "2"" of type '" "Pythia8::SigmaProcess const *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::SigmaProcess * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UserHooksVector_biasSelectionBy" "', argument " "3"" of type '" "Pythia8::PhaseSpace const *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PhaseSpace * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "UserHooksVector_biasSelectionBy" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (double)(arg1)->biasSelectionBy((Pythia8::SigmaProcess const *)arg2,(Pythia8::PhaseSpace const *)arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_biasedSelectionWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_biasedSelectionWeight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_biasedSelectionWeight" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (double)(arg1)->biasedSelectionWeight();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_canVetoProcessLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_canVetoProcessLevel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_canVetoProcessLevel" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (bool)(arg1)->canVetoProcessLevel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_doVetoProcessLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooksVector_doVetoProcessLevel",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_doVetoProcessLevel" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooksVector_doVetoProcessLevel" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooksVector_doVetoProcessLevel" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->doVetoProcessLevel(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_canVetoResonanceDecays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_canVetoResonanceDecays",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_canVetoResonanceDecays" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (bool)(arg1)->canVetoResonanceDecays();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_doVetoResonanceDecays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooksVector_doVetoResonanceDecays",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_doVetoResonanceDecays" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooksVector_doVetoResonanceDecays" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooksVector_doVetoResonanceDecays" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->doVetoResonanceDecays(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_canVetoPT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_canVetoPT",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_canVetoPT" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (bool)(arg1)->canVetoPT();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_scaleVetoPT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_scaleVetoPT",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_scaleVetoPT" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (double)(arg1)->scaleVetoPT();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_doVetoPT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:UserHooksVector_doVetoPT",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_doVetoPT" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UserHooksVector_doVetoPT" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UserHooksVector_doVetoPT" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooksVector_doVetoPT" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  result = (bool)(arg1)->doVetoPT(arg2,(Pythia8::Event const &)*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_canVetoStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_canVetoStep",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_canVetoStep" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (bool)(arg1)->canVetoStep();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_numberVetoStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_numberVetoStep",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_numberVetoStep" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (int)(arg1)->numberVetoStep();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_doVetoStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  Pythia8::Event *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:UserHooksVector_doVetoStep",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_doVetoStep" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UserHooksVector_doVetoStep" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UserHooksVector_doVetoStep" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "UserHooksVector_doVetoStep" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "UserHooksVector_doVetoStep" "', argument " "5"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooksVector_doVetoStep" "', argument " "5"" of type '" "Pythia8::Event const &""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Event * >(argp5);
  result = (bool)(arg1)->doVetoStep(arg2,arg3,arg4,(Pythia8::Event const &)*arg5);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_canVetoMPIStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_canVetoMPIStep",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_canVetoMPIStep" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (bool)(arg1)->canVetoMPIStep();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_numberVetoMPIStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_numberVetoMPIStep",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_numberVetoMPIStep" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (int)(arg1)->numberVetoMPIStep();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_doVetoMPIStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:UserHooksVector_doVetoMPIStep",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_doVetoMPIStep" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UserHooksVector_doVetoMPIStep" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UserHooksVector_doVetoMPIStep" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooksVector_doVetoMPIStep" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  result = (bool)(arg1)->doVetoMPIStep(arg2,(Pythia8::Event const &)*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_canVetoPartonLevelEarly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_canVetoPartonLevelEarly",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_canVetoPartonLevelEarly" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (bool)(arg1)->canVetoPartonLevelEarly();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_doVetoPartonLevelEarly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooksVector_doVetoPartonLevelEarly",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_doVetoPartonLevelEarly" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooksVector_doVetoPartonLevelEarly" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooksVector_doVetoPartonLevelEarly" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->doVetoPartonLevelEarly((Pythia8::Event const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_retryPartonLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_retryPartonLevel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_retryPartonLevel" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (bool)(arg1)->retryPartonLevel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_canVetoPartonLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_canVetoPartonLevel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_canVetoPartonLevel" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (bool)(arg1)->canVetoPartonLevel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_doVetoPartonLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooksVector_doVetoPartonLevel",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_doVetoPartonLevel" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooksVector_doVetoPartonLevel" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooksVector_doVetoPartonLevel" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->doVetoPartonLevel((Pythia8::Event const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_canSetResonanceScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_canSetResonanceScale",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_canSetResonanceScale" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (bool)(arg1)->canSetResonanceScale();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_scaleResonance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:UserHooksVector_scaleResonance",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_scaleResonance" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UserHooksVector_scaleResonance" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UserHooksVector_scaleResonance" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooksVector_scaleResonance" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  result = (double)(arg1)->scaleResonance(arg2,(Pythia8::Event const &)*arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_canVetoISREmission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_canVetoISREmission",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_canVetoISREmission" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (bool)(arg1)->canVetoISREmission();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_doVetoISREmission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:UserHooksVector_doVetoISREmission",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_doVetoISREmission" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UserHooksVector_doVetoISREmission" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UserHooksVector_doVetoISREmission" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooksVector_doVetoISREmission" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "UserHooksVector_doVetoISREmission" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (bool)(arg1)->doVetoISREmission(arg2,(Pythia8::Event const &)*arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_canVetoFSREmission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_canVetoFSREmission",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_canVetoFSREmission" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (bool)(arg1)->canVetoFSREmission();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_doVetoFSREmission__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  int arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:UserHooksVector_doVetoFSREmission",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_doVetoFSREmission" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UserHooksVector_doVetoFSREmission" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UserHooksVector_doVetoFSREmission" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooksVector_doVetoFSREmission" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "UserHooksVector_doVetoFSREmission" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "UserHooksVector_doVetoFSREmission" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (bool)(arg1)->doVetoFSREmission(arg2,(Pythia8::Event const &)*arg3,arg4,arg5);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_doVetoFSREmission__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:UserHooksVector_doVetoFSREmission",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_doVetoFSREmission" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UserHooksVector_doVetoFSREmission" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UserHooksVector_doVetoFSREmission" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooksVector_doVetoFSREmission" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "UserHooksVector_doVetoFSREmission" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (bool)(arg1)->doVetoFSREmission(arg2,(Pythia8::Event const &)*arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_doVetoFSREmission(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__UserHooksVector, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Event, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_UserHooksVector_doVetoFSREmission__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__UserHooksVector, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Event, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_UserHooksVector_doVetoFSREmission__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'UserHooksVector_doVetoFSREmission'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::UserHooksVector::doVetoFSREmission(int,Pythia8::Event const &,int,bool)\n"
    "    Pythia8::UserHooksVector::doVetoFSREmission(int,Pythia8::Event const &,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_canVetoMPIEmission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_canVetoMPIEmission",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_canVetoMPIEmission" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (bool)(arg1)->canVetoMPIEmission();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_doVetoMPIEmission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:UserHooksVector_doVetoMPIEmission",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_doVetoMPIEmission" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UserHooksVector_doVetoMPIEmission" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UserHooksVector_doVetoMPIEmission" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooksVector_doVetoMPIEmission" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  result = (bool)(arg1)->doVetoMPIEmission(arg2,(Pythia8::Event const &)*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_canReconnectResonanceSystems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_canReconnectResonanceSystems",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_canReconnectResonanceSystems" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (bool)(arg1)->canReconnectResonanceSystems();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_doReconnectResonanceSystems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:UserHooksVector_doReconnectResonanceSystems",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_doReconnectResonanceSystems" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UserHooksVector_doReconnectResonanceSystems" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UserHooksVector_doReconnectResonanceSystems" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UserHooksVector_doReconnectResonanceSystems" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  result = (bool)(arg1)->doReconnectResonanceSystems(arg2,*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_canEnhanceEmission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_canEnhanceEmission",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_canEnhanceEmission" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (bool)(arg1)->canEnhanceEmission();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_enhanceFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooksVector_enhanceFactor",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_enhanceFactor" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "UserHooksVector_enhanceFactor" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->enhanceFactor(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_vetoProbability(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooksVector_vetoProbability",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_vetoProbability" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "UserHooksVector_vetoProbability" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->vetoProbability(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_canEnhanceTrial(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_canEnhanceTrial",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_canEnhanceTrial" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (bool)(arg1)->canEnhanceTrial();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_canChangeFragPar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_canChangeFragPar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_canChangeFragPar" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (bool)(arg1)->canChangeFragPar();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_canSetImpactParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_canSetImpactParameter",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_canSetImpactParameter" "', argument " "1"" of type '" "Pythia8::UserHooksVector const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (bool)((Pythia8::UserHooksVector const *)arg1)->canSetImpactParameter();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_doSetImpactParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_doSetImpactParameter",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_doSetImpactParameter" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (double)(arg1)->doSetImpactParameter();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_hooks_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  std::vector< Pythia8::UserHooks *,std::allocator< Pythia8::UserHooks * > > *arg2 = (std::vector< Pythia8::UserHooks *,std::allocator< Pythia8::UserHooks * > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:UserHooksVector_hooks_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_hooks_set" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_Pythia8__UserHooks_p_std__allocatorT_Pythia8__UserHooks_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UserHooksVector_hooks_set" "', argument " "2"" of type '" "std::vector< Pythia8::UserHooks *,std::allocator< Pythia8::UserHooks * > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::UserHooks *,std::allocator< Pythia8::UserHooks * > > * >(argp2);
  if (arg1) (arg1)->hooks = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UserHooksVector_hooks_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::UserHooksVector *arg1 = (Pythia8::UserHooksVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::UserHooks *,std::allocator< Pythia8::UserHooks * > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:UserHooksVector_hooks_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__UserHooksVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UserHooksVector_hooks_get" "', argument " "1"" of type '" "Pythia8::UserHooksVector *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::UserHooksVector * >(argp1);
  result = (std::vector< Pythia8::UserHooks *,std::allocator< Pythia8::UserHooks * > > *)& ((arg1)->hooks);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__UserHooks_p_std__allocatorT_Pythia8__UserHooks_p_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UserHooksVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__UserHooksVector, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SigmaMultiparton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMultiparton *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SigmaMultiparton")) SWIG_fail;
  result = (Pythia8::SigmaMultiparton *)new Pythia8::SigmaMultiparton();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SigmaMultiparton, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SigmaMultiparton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMultiparton *arg1 = (Pythia8::SigmaMultiparton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SigmaMultiparton",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMultiparton, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SigmaMultiparton" "', argument " "1"" of type '" "Pythia8::SigmaMultiparton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMultiparton * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaMultiparton_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMultiparton *arg1 = (Pythia8::SigmaMultiparton *) 0 ;
  int arg2 ;
  int arg3 ;
  Pythia8::Info *arg4 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg5 = (Pythia8::Settings *) 0 ;
  Pythia8::ParticleData *arg6 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg7 = (Pythia8::Rndm *) 0 ;
  Pythia8::BeamParticle *arg8 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg9 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::Couplings *arg10 = (Pythia8::Couplings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:SigmaMultiparton_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMultiparton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaMultiparton_init" "', argument " "1"" of type '" "Pythia8::SigmaMultiparton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMultiparton * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaMultiparton_init" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaMultiparton_init" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SigmaMultiparton_init" "', argument " "4"" of type '" "Pythia8::Info *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Info * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SigmaMultiparton_init" "', argument " "5"" of type '" "Pythia8::Settings *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Settings * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SigmaMultiparton_init" "', argument " "6"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::ParticleData * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SigmaMultiparton_init" "', argument " "7"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::Rndm * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "SigmaMultiparton_init" "', argument " "8"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::BeamParticle * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "SigmaMultiparton_init" "', argument " "9"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::BeamParticle * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "SigmaMultiparton_init" "', argument " "10"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg10 = reinterpret_cast< Pythia8::Couplings * >(argp10);
  result = (bool)(arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaMultiparton_sigma__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMultiparton *arg1 = (Pythia8::SigmaMultiparton *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  bool arg11 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:SigmaMultiparton_sigma",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMultiparton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaMultiparton_sigma" "', argument " "1"" of type '" "Pythia8::SigmaMultiparton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMultiparton * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaMultiparton_sigma" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaMultiparton_sigma" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaMultiparton_sigma" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaMultiparton_sigma" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaMultiparton_sigma" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SigmaMultiparton_sigma" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SigmaMultiparton_sigma" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SigmaMultiparton_sigma" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "SigmaMultiparton_sigma" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "SigmaMultiparton_sigma" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "SigmaMultiparton_sigma" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  result = (double)(arg1)->sigma(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaMultiparton_sigma__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMultiparton *arg1 = (Pythia8::SigmaMultiparton *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  bool arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:SigmaMultiparton_sigma",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMultiparton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaMultiparton_sigma" "', argument " "1"" of type '" "Pythia8::SigmaMultiparton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMultiparton * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaMultiparton_sigma" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaMultiparton_sigma" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaMultiparton_sigma" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaMultiparton_sigma" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaMultiparton_sigma" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SigmaMultiparton_sigma" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SigmaMultiparton_sigma" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SigmaMultiparton_sigma" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "SigmaMultiparton_sigma" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_bool(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "SigmaMultiparton_sigma" "', argument " "11"" of type '" "bool""'");
  } 
  arg11 = static_cast< bool >(val11);
  result = (double)(arg1)->sigma(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaMultiparton_sigma__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMultiparton *arg1 = (Pythia8::SigmaMultiparton *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:SigmaMultiparton_sigma",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMultiparton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaMultiparton_sigma" "', argument " "1"" of type '" "Pythia8::SigmaMultiparton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMultiparton * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaMultiparton_sigma" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaMultiparton_sigma" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SigmaMultiparton_sigma" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SigmaMultiparton_sigma" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SigmaMultiparton_sigma" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SigmaMultiparton_sigma" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SigmaMultiparton_sigma" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SigmaMultiparton_sigma" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "SigmaMultiparton_sigma" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (double)(arg1)->sigma(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaMultiparton_sigma(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[13] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 12) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaMultiparton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_SigmaMultiparton_sigma__SWIG_2(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaMultiparton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_SigmaMultiparton_sigma__SWIG_1(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaMultiparton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_SigmaMultiparton_sigma__SWIG_0(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaMultiparton_sigma'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaMultiparton::sigma(int,int,double,double,double,double,double,double,double,bool,bool)\n"
    "    Pythia8::SigmaMultiparton::sigma(int,int,double,double,double,double,double,double,double,bool)\n"
    "    Pythia8::SigmaMultiparton::sigma(int,int,double,double,double,double,double,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaMultiparton_pickedOther(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMultiparton *arg1 = (Pythia8::SigmaMultiparton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaMultiparton_pickedOther",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMultiparton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaMultiparton_pickedOther" "', argument " "1"" of type '" "Pythia8::SigmaMultiparton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMultiparton * >(argp1);
  result = (bool)(arg1)->pickedOther();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaMultiparton_sigmaSel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMultiparton *arg1 = (Pythia8::SigmaMultiparton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  Pythia8::SigmaProcess *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaMultiparton_sigmaSel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMultiparton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaMultiparton_sigmaSel" "', argument " "1"" of type '" "Pythia8::SigmaMultiparton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMultiparton * >(argp1);
  result = (Pythia8::SigmaProcess *)(arg1)->sigmaSel();
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaMultiparton_swapTU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMultiparton *arg1 = (Pythia8::SigmaMultiparton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaMultiparton_swapTU",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMultiparton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaMultiparton_swapTU" "', argument " "1"" of type '" "Pythia8::SigmaMultiparton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMultiparton * >(argp1);
  result = (bool)(arg1)->swapTU();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaMultiparton_nProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMultiparton *arg1 = (Pythia8::SigmaMultiparton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SigmaMultiparton_nProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMultiparton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaMultiparton_nProc" "', argument " "1"" of type '" "Pythia8::SigmaMultiparton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMultiparton * >(argp1);
  result = (int)((Pythia8::SigmaMultiparton const *)arg1)->nProc();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaMultiparton_codeProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMultiparton *arg1 = (Pythia8::SigmaMultiparton *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaMultiparton_codeProc",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMultiparton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaMultiparton_codeProc" "', argument " "1"" of type '" "Pythia8::SigmaMultiparton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMultiparton * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaMultiparton_codeProc" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::SigmaMultiparton const *)arg1)->codeProc(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaMultiparton_nameProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaMultiparton *arg1 = (Pythia8::SigmaMultiparton *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaMultiparton_nameProc",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaMultiparton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaMultiparton_nameProc" "', argument " "1"" of type '" "Pythia8::SigmaMultiparton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaMultiparton * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SigmaMultiparton_nameProc" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((Pythia8::SigmaMultiparton const *)arg1)->nameProc(arg2);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SigmaMultiparton_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SigmaMultiparton, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MultipartonInteractions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MultipartonInteractions")) SWIG_fail;
  result = (Pythia8::MultipartonInteractions *)new Pythia8::MultipartonInteractions();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MultipartonInteractions, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_init__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  bool arg2 ;
  int arg3 ;
  Pythia8::Info *arg4 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg5 = 0 ;
  Pythia8::ParticleData *arg6 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg7 = (Pythia8::Rndm *) 0 ;
  Pythia8::BeamParticle *arg8 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg9 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::Couplings *arg10 = (Pythia8::Couplings *) 0 ;
  Pythia8::PartonSystems *arg11 = (Pythia8::PartonSystems *) 0 ;
  Pythia8::SigmaTotal *arg12 = (Pythia8::SigmaTotal *) 0 ;
  Pythia8::UserHooks *arg13 = (Pythia8::UserHooks *) 0 ;
  Pythia8::PartonVertex *arg14 = (Pythia8::PartonVertex *) 0 ;
  bool arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:MultipartonInteractions_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_init" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MultipartonInteractions_init" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MultipartonInteractions_init" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MultipartonInteractions_init" "', argument " "4"" of type '" "Pythia8::Info *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Info * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MultipartonInteractions_init" "', argument " "5"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultipartonInteractions_init" "', argument " "5"" of type '" "Pythia8::Settings &""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Settings * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "MultipartonInteractions_init" "', argument " "6"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::ParticleData * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "MultipartonInteractions_init" "', argument " "7"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::Rndm * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "MultipartonInteractions_init" "', argument " "8"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::BeamParticle * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "MultipartonInteractions_init" "', argument " "9"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::BeamParticle * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "MultipartonInteractions_init" "', argument " "10"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg10 = reinterpret_cast< Pythia8::Couplings * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "MultipartonInteractions_init" "', argument " "11"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg11 = reinterpret_cast< Pythia8::PartonSystems * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "MultipartonInteractions_init" "', argument " "12"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg12 = reinterpret_cast< Pythia8::SigmaTotal * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "MultipartonInteractions_init" "', argument " "13"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg13 = reinterpret_cast< Pythia8::UserHooks * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14,SWIGTYPE_p_Pythia8__PartonVertex, 0 |  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "MultipartonInteractions_init" "', argument " "14"" of type '" "Pythia8::PartonVertex *""'"); 
  }
  arg14 = reinterpret_cast< Pythia8::PartonVertex * >(argp14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "MultipartonInteractions_init" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  result = (bool)(arg1)->init(arg2,arg3,arg4,*arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_init__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  bool arg2 ;
  int arg3 ;
  Pythia8::Info *arg4 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg5 = 0 ;
  Pythia8::ParticleData *arg6 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg7 = (Pythia8::Rndm *) 0 ;
  Pythia8::BeamParticle *arg8 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg9 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::Couplings *arg10 = (Pythia8::Couplings *) 0 ;
  Pythia8::PartonSystems *arg11 = (Pythia8::PartonSystems *) 0 ;
  Pythia8::SigmaTotal *arg12 = (Pythia8::SigmaTotal *) 0 ;
  Pythia8::UserHooks *arg13 = (Pythia8::UserHooks *) 0 ;
  Pythia8::PartonVertex *arg14 = (Pythia8::PartonVertex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:MultipartonInteractions_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_init" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MultipartonInteractions_init" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MultipartonInteractions_init" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MultipartonInteractions_init" "', argument " "4"" of type '" "Pythia8::Info *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Info * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MultipartonInteractions_init" "', argument " "5"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultipartonInteractions_init" "', argument " "5"" of type '" "Pythia8::Settings &""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Settings * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "MultipartonInteractions_init" "', argument " "6"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::ParticleData * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "MultipartonInteractions_init" "', argument " "7"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::Rndm * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "MultipartonInteractions_init" "', argument " "8"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::BeamParticle * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "MultipartonInteractions_init" "', argument " "9"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::BeamParticle * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "MultipartonInteractions_init" "', argument " "10"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg10 = reinterpret_cast< Pythia8::Couplings * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "MultipartonInteractions_init" "', argument " "11"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg11 = reinterpret_cast< Pythia8::PartonSystems * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "MultipartonInteractions_init" "', argument " "12"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg12 = reinterpret_cast< Pythia8::SigmaTotal * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "MultipartonInteractions_init" "', argument " "13"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg13 = reinterpret_cast< Pythia8::UserHooks * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14,SWIGTYPE_p_Pythia8__PartonVertex, 0 |  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "MultipartonInteractions_init" "', argument " "14"" of type '" "Pythia8::PartonVertex *""'"); 
  }
  arg14 = reinterpret_cast< Pythia8::PartonVertex * >(argp14);
  result = (bool)(arg1)->init(arg2,arg3,arg4,*arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_init(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[16] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 15) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MultipartonInteractions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__Rndm, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_Pythia8__Couplings, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_Pythia8__PartonSystems, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_Pythia8__SigmaTotal, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_Pythia8__UserHooks, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_Pythia8__PartonVertex, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                return _wrap_MultipartonInteractions_init__SWIG_1(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MultipartonInteractions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__Rndm, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_Pythia8__Couplings, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_Pythia8__PartonSystems, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_Pythia8__SigmaTotal, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_Pythia8__UserHooks, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_Pythia8__PartonVertex, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_bool(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_MultipartonInteractions_init__SWIG_0(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MultipartonInteractions_init'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::MultipartonInteractions::init(bool,int,Pythia8::Info *,Pythia8::Settings &,Pythia8::ParticleData *,Pythia8::Rndm *,Pythia8::BeamParticle *,Pythia8::BeamParticle *,Pythia8::Couplings *,Pythia8::PartonSystems *,Pythia8::SigmaTotal *,Pythia8::UserHooks *,Pythia8::PartonVertex *,bool)\n"
    "    Pythia8::MultipartonInteractions::init(bool,int,Pythia8::Info *,Pythia8::Settings &,Pythia8::ParticleData *,Pythia8::Rndm *,Pythia8::BeamParticle *,Pythia8::BeamParticle *,Pythia8::Couplings *,Pythia8::PartonSystems *,Pythia8::SigmaTotal *,Pythia8::UserHooks *,Pythia8::PartonVertex *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MultipartonInteractions_reset",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_reset" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  (arg1)->reset();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_pTfirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MultipartonInteractions_pTfirst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_pTfirst" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  (arg1)->pTfirst();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_setupFirstSys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MultipartonInteractions_setupFirstSys",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_setupFirstSys" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultipartonInteractions_setupFirstSys" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultipartonInteractions_setupFirstSys" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  (arg1)->setupFirstSys(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_limitPTmax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MultipartonInteractions_limitPTmax",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_limitPTmax" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultipartonInteractions_limitPTmax" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultipartonInteractions_limitPTmax" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->limitPTmax(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_scaleLimitPT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MultipartonInteractions_scaleLimitPT",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_scaleLimitPT" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  result = (double)((Pythia8::MultipartonInteractions const *)arg1)->scaleLimitPT();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_prepare__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  double arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:MultipartonInteractions_prepare",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_prepare" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultipartonInteractions_prepare" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultipartonInteractions_prepare" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MultipartonInteractions_prepare" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MultipartonInteractions_prepare" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->prepare(*arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_prepare__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MultipartonInteractions_prepare",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_prepare" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultipartonInteractions_prepare" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultipartonInteractions_prepare" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MultipartonInteractions_prepare" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->prepare(*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_prepare__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MultipartonInteractions_prepare",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_prepare" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultipartonInteractions_prepare" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultipartonInteractions_prepare" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  (arg1)->prepare(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_prepare(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MultipartonInteractions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MultipartonInteractions_prepare__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MultipartonInteractions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MultipartonInteractions_prepare__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MultipartonInteractions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_MultipartonInteractions_prepare__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MultipartonInteractions_prepare'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::MultipartonInteractions::prepare(Pythia8::Event &,double,bool)\n"
    "    Pythia8::MultipartonInteractions::prepare(Pythia8::Event &,double)\n"
    "    Pythia8::MultipartonInteractions::prepare(Pythia8::Event &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_pTnext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  double arg2 ;
  double arg3 ;
  Pythia8::Event *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:MultipartonInteractions_pTnext",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_pTnext" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MultipartonInteractions_pTnext" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MultipartonInteractions_pTnext" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MultipartonInteractions_pTnext" "', argument " "4"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultipartonInteractions_pTnext" "', argument " "4"" of type '" "Pythia8::Event &""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Event * >(argp4);
  result = (double)(arg1)->pTnext(arg2,arg3,*arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_scatter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MultipartonInteractions_scatter",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_scatter" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultipartonInteractions_scatter" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultipartonInteractions_scatter" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->scatter(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_setEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MultipartonInteractions_setEmpty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_setEmpty" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  (arg1)->setEmpty();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_Q2Ren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MultipartonInteractions_Q2Ren",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_Q2Ren" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  result = (double)((Pythia8::MultipartonInteractions const *)arg1)->Q2Ren();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_alphaSH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MultipartonInteractions_alphaSH",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_alphaSH" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  result = (double)((Pythia8::MultipartonInteractions const *)arg1)->alphaSH();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_alphaEMH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MultipartonInteractions_alphaEMH",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_alphaEMH" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  result = (double)((Pythia8::MultipartonInteractions const *)arg1)->alphaEMH();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_x1H(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MultipartonInteractions_x1H",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_x1H" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  result = (double)((Pythia8::MultipartonInteractions const *)arg1)->x1H();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_x2H(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MultipartonInteractions_x2H",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_x2H" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  result = (double)((Pythia8::MultipartonInteractions const *)arg1)->x2H();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_Q2Fac(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MultipartonInteractions_Q2Fac",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_Q2Fac" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  result = (double)((Pythia8::MultipartonInteractions const *)arg1)->Q2Fac();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_pdf1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MultipartonInteractions_pdf1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_pdf1" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  result = (double)((Pythia8::MultipartonInteractions const *)arg1)->pdf1();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_pdf2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MultipartonInteractions_pdf2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_pdf2" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  result = (double)((Pythia8::MultipartonInteractions const *)arg1)->pdf2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_bMPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MultipartonInteractions_bMPI",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_bMPI" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  result = (double)((Pythia8::MultipartonInteractions const *)arg1)->bMPI();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_enhanceMPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MultipartonInteractions_enhanceMPI",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_enhanceMPI" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  result = (double)((Pythia8::MultipartonInteractions const *)arg1)->enhanceMPI();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_enhanceMPIavg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MultipartonInteractions_enhanceMPIavg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_enhanceMPIavg" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  result = (double)((Pythia8::MultipartonInteractions const *)arg1)->enhanceMPIavg();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_getVSC1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MultipartonInteractions_getVSC1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_getVSC1" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  result = (int)((Pythia8::MultipartonInteractions const *)arg1)->getVSC1();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_getVSC2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MultipartonInteractions_getVSC2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_getVSC2" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  result = (int)((Pythia8::MultipartonInteractions const *)arg1)->getVSC2();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_getBeamOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MultipartonInteractions_getBeamOffset",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_getBeamOffset" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  result = (int)((Pythia8::MultipartonInteractions const *)arg1)->getBeamOffset();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_setBeamOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MultipartonInteractions_setBeamOffset",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_setBeamOffset" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MultipartonInteractions_setBeamOffset" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setBeamOffset(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_accumulate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MultipartonInteractions_accumulate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_accumulate" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  (arg1)->accumulate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_statistics__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MultipartonInteractions_statistics",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_statistics" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MultipartonInteractions_statistics" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->statistics(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_statistics__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MultipartonInteractions_statistics",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_statistics" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  (arg1)->statistics();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_statistics(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MultipartonInteractions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MultipartonInteractions_statistics__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__MultipartonInteractions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MultipartonInteractions_statistics__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MultipartonInteractions_statistics'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::MultipartonInteractions::statistics(bool)\n"
    "    Pythia8::MultipartonInteractions::statistics()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MultipartonInteractions_resetStatistics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MultipartonInteractions_resetStatistics",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultipartonInteractions_resetStatistics" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  (arg1)->resetStatistics();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MultipartonInteractions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultipartonInteractions *arg1 = (Pythia8::MultipartonInteractions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MultipartonInteractions",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultipartonInteractions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MultipartonInteractions" "', argument " "1"" of type '" "Pythia8::MultipartonInteractions *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultipartonInteractions * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MultipartonInteractions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__MultipartonInteractions, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_PhaseSpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PhaseSpace",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PhaseSpace" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  Pythia8::SigmaProcess *arg3 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::Info *arg4 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg5 = (Pythia8::Settings *) 0 ;
  Pythia8::ParticleData *arg6 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg7 = (Pythia8::Rndm *) 0 ;
  Pythia8::BeamParticle *arg8 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg9 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::Couplings *arg10 = (Pythia8::Couplings *) 0 ;
  Pythia8::SigmaTotal *arg11 = (Pythia8::SigmaTotal *) 0 ;
  Pythia8::UserHooks *arg12 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:PhaseSpace_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_init" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_init" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PhaseSpace_init" "', argument " "3"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::SigmaProcess * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PhaseSpace_init" "', argument " "4"" of type '" "Pythia8::Info *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Info * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "PhaseSpace_init" "', argument " "5"" of type '" "Pythia8::Settings *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Settings * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "PhaseSpace_init" "', argument " "6"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::ParticleData * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "PhaseSpace_init" "', argument " "7"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::Rndm * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "PhaseSpace_init" "', argument " "8"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::BeamParticle * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "PhaseSpace_init" "', argument " "9"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::BeamParticle * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "PhaseSpace_init" "', argument " "10"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg10 = reinterpret_cast< Pythia8::Couplings * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "PhaseSpace_init" "', argument " "11"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg11 = reinterpret_cast< Pythia8::SigmaTotal * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "PhaseSpace_init" "', argument " "12"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg12 = reinterpret_cast< Pythia8::UserHooks * >(argp12);
  (arg1)->init(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_newECM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_newECM",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_newECM" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_newECM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->newECM(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_setLHAPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  Pythia8::LHAup *arg2 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_setLHAPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_setLHAPtr" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_setLHAPtr" "', argument " "2"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHAup * >(argp2);
  (arg1)->setLHAPtr(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_setupSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_setupSampling",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_setupSampling" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("Pythia8::PhaseSpace::setupSampling");
    } else {
      result = (bool)(arg1)->setupSampling();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_trialKin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PhaseSpace_trialKin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_trialKin" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PhaseSpace_trialKin" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("Pythia8::PhaseSpace::trialKin");
    } else {
      result = (bool)(arg1)->trialKin(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_trialKin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_trialKin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_trialKin" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("Pythia8::PhaseSpace::trialKin");
    } else {
      result = (bool)(arg1)->trialKin(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_trialKin__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_trialKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("Pythia8::PhaseSpace::trialKin");
    } else {
      result = (bool)(arg1)->trialKin();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_trialKin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_PhaseSpace_trialKin__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PhaseSpace_trialKin__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_PhaseSpace_trialKin__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PhaseSpace_trialKin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PhaseSpace::trialKin(bool,bool)\n"
    "    Pythia8::PhaseSpace::trialKin(bool)\n"
    "    Pythia8::PhaseSpace::trialKin()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_finalKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_finalKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_finalKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("Pythia8::PhaseSpace::finalKin");
    } else {
      result = (bool)(arg1)->finalKin();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_decayKinematics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_decayKinematics",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_decayKinematics" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_decayKinematics" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PhaseSpace_decayKinematics" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  (arg1)->decayKinematics(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sigmaNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_sigmaNow",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sigmaNow" "', argument " "1"" of type '" "Pythia8::PhaseSpace const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  result = (double)((Pythia8::PhaseSpace const *)arg1)->sigmaNow();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sigmaMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_sigmaMax",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sigmaMax" "', argument " "1"" of type '" "Pythia8::PhaseSpace const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  result = (double)((Pythia8::PhaseSpace const *)arg1)->sigmaMax();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_biasSelectionWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_biasSelectionWeight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_biasSelectionWeight" "', argument " "1"" of type '" "Pythia8::PhaseSpace const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  result = (double)((Pythia8::PhaseSpace const *)arg1)->biasSelectionWeight();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_newSigmaMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_newSigmaMax",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_newSigmaMax" "', argument " "1"" of type '" "Pythia8::PhaseSpace const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  result = (bool)((Pythia8::PhaseSpace const *)arg1)->newSigmaMax();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_setSigmaMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_setSigmaMax",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_setSigmaMax" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_setSigmaMax" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setSigmaMax(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sigmaSumSigned(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_sigmaSumSigned",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sigmaSumSigned" "', argument " "1"" of type '" "Pythia8::PhaseSpace const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)((Pythia8::PhaseSpace const *)arg1)->Pythia8::PhaseSpace::sigmaSumSigned();
    } else {
      result = (double)((Pythia8::PhaseSpace const *)arg1)->sigmaSumSigned();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_p",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_p" "', argument " "1"" of type '" "Pythia8::PhaseSpace const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_p" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((Pythia8::PhaseSpace const *)arg1)->p(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_m(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_m",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_m" "', argument " "1"" of type '" "Pythia8::PhaseSpace const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_m" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)((Pythia8::PhaseSpace const *)arg1)->m(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_setP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  int arg2 ;
  Pythia8::Vec4 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PhaseSpace_setP",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_setP" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_setP" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PhaseSpace_setP" "', argument " "3"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PhaseSpace_setP" "', argument " "3"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  (arg1)->setP(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_ecm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_ecm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_ecm" "', argument " "1"" of type '" "Pythia8::PhaseSpace const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  result = (double)((Pythia8::PhaseSpace const *)arg1)->ecm();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_x1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_x1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_x1" "', argument " "1"" of type '" "Pythia8::PhaseSpace const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  result = (double)((Pythia8::PhaseSpace const *)arg1)->x1();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_x2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_x2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_x2" "', argument " "1"" of type '" "Pythia8::PhaseSpace const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  result = (double)((Pythia8::PhaseSpace const *)arg1)->x2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_sHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sHat" "', argument " "1"" of type '" "Pythia8::PhaseSpace const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  result = (double)((Pythia8::PhaseSpace const *)arg1)->sHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_tHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_tHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_tHat" "', argument " "1"" of type '" "Pythia8::PhaseSpace const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  result = (double)((Pythia8::PhaseSpace const *)arg1)->tHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_uHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_uHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_uHat" "', argument " "1"" of type '" "Pythia8::PhaseSpace const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  result = (double)((Pythia8::PhaseSpace const *)arg1)->uHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_pTHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_pTHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_pTHat" "', argument " "1"" of type '" "Pythia8::PhaseSpace const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  result = (double)((Pythia8::PhaseSpace const *)arg1)->pTHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_thetaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_thetaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_thetaHat" "', argument " "1"" of type '" "Pythia8::PhaseSpace const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  result = (double)((Pythia8::PhaseSpace const *)arg1)->thetaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_phiHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_phiHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_phiHat" "', argument " "1"" of type '" "Pythia8::PhaseSpace const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  result = (double)((Pythia8::PhaseSpace const *)arg1)->phiHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_runBW3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_runBW3",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_runBW3" "', argument " "1"" of type '" "Pythia8::PhaseSpace const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  result = (double)((Pythia8::PhaseSpace const *)arg1)->runBW3();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_runBW4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_runBW4",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_runBW4" "', argument " "1"" of type '" "Pythia8::PhaseSpace const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  result = (double)((Pythia8::PhaseSpace const *)arg1)->runBW4();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_runBW5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_runBW5",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_runBW5" "', argument " "1"" of type '" "Pythia8::PhaseSpace const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  result = (double)((Pythia8::PhaseSpace const *)arg1)->runBW5();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_isResolved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_isResolved",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_isResolved" "', argument " "1"" of type '" "Pythia8::PhaseSpace const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)((Pythia8::PhaseSpace const *)arg1)->Pythia8::PhaseSpace::isResolved();
    } else {
      result = (bool)((Pythia8::PhaseSpace const *)arg1)->isResolved();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_rescaleSigma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_rescaleSigma",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_rescaleSigma" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_rescaleSigma" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::PhaseSpace::rescaleSigma(arg2);
    } else {
      (arg1)->rescaleSigma(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_rescaleMomenta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_rescaleMomenta",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_rescaleMomenta" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_rescaleMomenta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::PhaseSpace::rescaleMomenta(arg2);
    } else {
      (arg1)->rescaleMomenta(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_weightGammaPDFApprox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_weightGammaPDFApprox",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_weightGammaPDFApprox" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::PhaseSpace::weightGammaPDFApprox();
    } else {
      result = (double)(arg1)->weightGammaPDFApprox();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_setGammaKinPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  Pythia8::GammaKinematics *arg2 = (Pythia8::GammaKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_setGammaKinPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_setGammaKinPtr" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__GammaKinematics, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_setGammaKinPtr" "', argument " "2"" of type '" "Pythia8::GammaKinematics *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::GammaKinematics * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::PhaseSpace::setGammaKinPtr(arg2);
    } else {
      (arg1)->setGammaKinPtr(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PhaseSpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::PhaseSpace *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PhaseSpace",&obj0)) SWIG_fail;
  arg1 = obj0;
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (Pythia8::PhaseSpace *)new SwigDirector_PhaseSpace(arg1); 
  } else {
    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); 
    SWIG_fail;
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PhaseSpace, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int Swig_var_PhaseSpace_NMAXTRY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PhaseSpace_NMAXTRY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PhaseSpace_NMAXTRY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(SwigDirector_PhaseSpace::NMAXTRY));
  return pyobj;
}


SWIGINTERN int Swig_var_PhaseSpace_NTRY3BODY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PhaseSpace_NTRY3BODY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PhaseSpace_NTRY3BODY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(SwigDirector_PhaseSpace::NTRY3BODY));
  return pyobj;
}


SWIGINTERN int Swig_var_PhaseSpace_SAFETYMARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PhaseSpace_SAFETYMARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PhaseSpace_SAFETYMARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(SwigDirector_PhaseSpace::SAFETYMARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_PhaseSpace_TINY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PhaseSpace_TINY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PhaseSpace_TINY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(SwigDirector_PhaseSpace::TINY));
  return pyobj;
}


SWIGINTERN int Swig_var_PhaseSpace_EVENFRAC_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PhaseSpace_EVENFRAC is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PhaseSpace_EVENFRAC_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(SwigDirector_PhaseSpace::EVENFRAC));
  return pyobj;
}


SWIGINTERN int Swig_var_PhaseSpace_SAMESIGMA_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PhaseSpace_SAMESIGMA is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PhaseSpace_SAMESIGMA_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(SwigDirector_PhaseSpace::SAMESIGMA));
  return pyobj;
}


SWIGINTERN int Swig_var_PhaseSpace_MRESMINABS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PhaseSpace_MRESMINABS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PhaseSpace_MRESMINABS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(SwigDirector_PhaseSpace::MRESMINABS));
  return pyobj;
}


SWIGINTERN int Swig_var_PhaseSpace_WIDTHMARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PhaseSpace_WIDTHMARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PhaseSpace_WIDTHMARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(SwigDirector_PhaseSpace::WIDTHMARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_PhaseSpace_SAMEMASS_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PhaseSpace_SAMEMASS is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PhaseSpace_SAMEMASS_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(SwigDirector_PhaseSpace::SAMEMASS));
  return pyobj;
}


SWIGINTERN int Swig_var_PhaseSpace_MASSMARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PhaseSpace_MASSMARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PhaseSpace_MASSMARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(SwigDirector_PhaseSpace::MASSMARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_PhaseSpace_EXTRABWWTMAX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PhaseSpace_EXTRABWWTMAX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PhaseSpace_EXTRABWWTMAX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(SwigDirector_PhaseSpace::EXTRABWWTMAX));
  return pyobj;
}


SWIGINTERN int Swig_var_PhaseSpace_THRESHOLDSIZE_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PhaseSpace_THRESHOLDSIZE is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PhaseSpace_THRESHOLDSIZE_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(SwigDirector_PhaseSpace::THRESHOLDSIZE));
  return pyobj;
}


SWIGINTERN int Swig_var_PhaseSpace_THRESHOLDSTEP_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PhaseSpace_THRESHOLDSTEP is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PhaseSpace_THRESHOLDSTEP_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(SwigDirector_PhaseSpace::THRESHOLDSTEP));
  return pyobj;
}


SWIGINTERN int Swig_var_PhaseSpace_YRANGEMARGIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PhaseSpace_YRANGEMARGIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PhaseSpace_YRANGEMARGIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(SwigDirector_PhaseSpace::YRANGEMARGIN));
  return pyobj;
}


SWIGINTERN int Swig_var_PhaseSpace_LEPTONXMIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PhaseSpace_LEPTONXMIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PhaseSpace_LEPTONXMIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(SwigDirector_PhaseSpace::LEPTONXMIN));
  return pyobj;
}


SWIGINTERN int Swig_var_PhaseSpace_LEPTONXMAX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PhaseSpace_LEPTONXMAX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PhaseSpace_LEPTONXMAX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(SwigDirector_PhaseSpace::LEPTONXMAX));
  return pyobj;
}


SWIGINTERN int Swig_var_PhaseSpace_LEPTONXLOGMIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PhaseSpace_LEPTONXLOGMIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PhaseSpace_LEPTONXLOGMIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(SwigDirector_PhaseSpace::LEPTONXLOGMIN));
  return pyobj;
}


SWIGINTERN int Swig_var_PhaseSpace_LEPTONXLOGMAX_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PhaseSpace_LEPTONXLOGMAX is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PhaseSpace_LEPTONXLOGMAX_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(SwigDirector_PhaseSpace::LEPTONXLOGMAX));
  return pyobj;
}


SWIGINTERN int Swig_var_PhaseSpace_LEPTONTAUMIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PhaseSpace_LEPTONTAUMIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PhaseSpace_LEPTONTAUMIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(SwigDirector_PhaseSpace::LEPTONTAUMIN));
  return pyobj;
}


SWIGINTERN int Swig_var_PhaseSpace_SHATMINZ_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PhaseSpace_SHATMINZ is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PhaseSpace_SHATMINZ_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(SwigDirector_PhaseSpace::SHATMINZ));
  return pyobj;
}


SWIGINTERN int Swig_var_PhaseSpace_PT2RATMINZ_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PhaseSpace_PT2RATMINZ is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PhaseSpace_PT2RATMINZ_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(SwigDirector_PhaseSpace::PT2RATMINZ));
  return pyobj;
}


SWIGINTERN int Swig_var_PhaseSpace_WTCORRECTION_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable PhaseSpace_WTCORRECTION is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_PhaseSpace_WTCORRECTION_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(SwigDirector_PhaseSpace::WTCORRECTION), SWIGTYPE_p_double,  0 );
  return pyobj;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sigmaProcessPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  Pythia8::SigmaProcess *arg2 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_sigmaProcessPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sigmaProcessPtr_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__SigmaProcess, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_sigmaProcessPtr_set" "', argument " "2"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::SigmaProcess * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->sigmaProcessPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sigmaProcessPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  Pythia8::SigmaProcess *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_sigmaProcessPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sigmaProcessPtr_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (Pythia8::SigmaProcess *) (darg->sigmaProcessPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_infoPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_infoPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_infoPtr_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_infoPtr_set" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->infoPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_infoPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  Pythia8::Info *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_infoPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_infoPtr_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (Pythia8::Info *) (darg->infoPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_settingsPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  Pythia8::Settings *arg2 = (Pythia8::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_settingsPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_settingsPtr_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Settings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_settingsPtr_set" "', argument " "2"" of type '" "Pythia8::Settings *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->settingsPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_settingsPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  Pythia8::Settings *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_settingsPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_settingsPtr_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (Pythia8::Settings *) (darg->settingsPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_particleDataPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  Pythia8::ParticleData *arg2 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_particleDataPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_particleDataPtr_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ParticleData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_particleDataPtr_set" "', argument " "2"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ParticleData * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->particleDataPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_particleDataPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  Pythia8::ParticleData *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_particleDataPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_particleDataPtr_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (Pythia8::ParticleData *) (darg->particleDataPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_rndmPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  Pythia8::Rndm *arg2 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_rndmPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_rndmPtr_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Rndm, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_rndmPtr_set" "', argument " "2"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Rndm * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->rndmPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_rndmPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  Pythia8::Rndm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_rndmPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_rndmPtr_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (Pythia8::Rndm *) (darg->rndmPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_beamAPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  Pythia8::BeamParticle *arg2 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_beamAPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_beamAPtr_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__BeamParticle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_beamAPtr_set" "', argument " "2"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::BeamParticle * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->beamAPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_beamAPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  Pythia8::BeamParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_beamAPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_beamAPtr_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (Pythia8::BeamParticle *) (darg->beamAPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_beamBPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  Pythia8::BeamParticle *arg2 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_beamBPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_beamBPtr_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__BeamParticle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_beamBPtr_set" "', argument " "2"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::BeamParticle * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->beamBPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_beamBPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  Pythia8::BeamParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_beamBPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_beamBPtr_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (Pythia8::BeamParticle *) (darg->beamBPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_couplingsPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  Pythia8::Couplings *arg2 = (Pythia8::Couplings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_couplingsPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_couplingsPtr_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Couplings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_couplingsPtr_set" "', argument " "2"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Couplings * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->couplingsPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_couplingsPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  Pythia8::Couplings *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_couplingsPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_couplingsPtr_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (Pythia8::Couplings *) (darg->couplingsPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sigmaTotPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  Pythia8::SigmaTotal *arg2 = (Pythia8::SigmaTotal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_sigmaTotPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sigmaTotPtr_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__SigmaTotal, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_sigmaTotPtr_set" "', argument " "2"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::SigmaTotal * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->sigmaTotPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sigmaTotPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  Pythia8::SigmaTotal *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_sigmaTotPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sigmaTotPtr_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (Pythia8::SigmaTotal *) (darg->sigmaTotPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_userHooksPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  Pythia8::UserHooks *arg2 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_userHooksPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_userHooksPtr_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__UserHooks, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_userHooksPtr_set" "', argument " "2"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::UserHooks * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->userHooksPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_userHooksPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  Pythia8::UserHooks *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_userHooksPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_userHooksPtr_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (Pythia8::UserHooks *) (darg->userHooksPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_lhaUpPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  Pythia8::LHAup *arg2 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_lhaUpPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_lhaUpPtr_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHAup, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_lhaUpPtr_set" "', argument " "2"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHAup * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->lhaUpPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_lhaUpPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  Pythia8::LHAup *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_lhaUpPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_lhaUpPtr_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (Pythia8::LHAup *) (darg->lhaUpPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_useBreitWigners_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_useBreitWigners_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_useBreitWigners_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_useBreitWigners_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->useBreitWigners = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_useBreitWigners_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_useBreitWigners_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_useBreitWigners_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool) (darg->useBreitWigners);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_doEnergySpread_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_doEnergySpread_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_doEnergySpread_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_doEnergySpread_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->doEnergySpread = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_doEnergySpread_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_doEnergySpread_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_doEnergySpread_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool) (darg->doEnergySpread);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_showSearch_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_showSearch_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_showSearch_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_showSearch_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->showSearch = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_showSearch_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_showSearch_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_showSearch_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool) (darg->showSearch);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_showViolation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_showViolation_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_showViolation_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_showViolation_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->showViolation = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_showViolation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_showViolation_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_showViolation_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool) (darg->showViolation);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_increaseMaximum_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_increaseMaximum_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_increaseMaximum_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_increaseMaximum_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->increaseMaximum = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_increaseMaximum_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_increaseMaximum_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_increaseMaximum_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool) (darg->increaseMaximum);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_hasQ2Min_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_hasQ2Min_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_hasQ2Min_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_hasQ2Min_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->hasQ2Min = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_hasQ2Min_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_hasQ2Min_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_hasQ2Min_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool) (darg->hasQ2Min);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_gmZmodeGlobal_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_gmZmodeGlobal_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_gmZmodeGlobal_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_gmZmodeGlobal_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->gmZmodeGlobal = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_gmZmodeGlobal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_gmZmodeGlobal_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_gmZmodeGlobal_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (int) (darg->gmZmodeGlobal);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mHatGlobalMin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_mHatGlobalMin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mHatGlobalMin_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_mHatGlobalMin_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->mHatGlobalMin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mHatGlobalMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_mHatGlobalMin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mHatGlobalMin_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->mHatGlobalMin);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mHatGlobalMax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_mHatGlobalMax_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mHatGlobalMax_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_mHatGlobalMax_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->mHatGlobalMax = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mHatGlobalMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_mHatGlobalMax_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mHatGlobalMax_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->mHatGlobalMax);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_pTHatGlobalMin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_pTHatGlobalMin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_pTHatGlobalMin_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_pTHatGlobalMin_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->pTHatGlobalMin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_pTHatGlobalMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_pTHatGlobalMin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_pTHatGlobalMin_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->pTHatGlobalMin);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_pTHatGlobalMax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_pTHatGlobalMax_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_pTHatGlobalMax_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_pTHatGlobalMax_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->pTHatGlobalMax = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_pTHatGlobalMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_pTHatGlobalMax_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_pTHatGlobalMax_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->pTHatGlobalMax);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_Q2GlobalMin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_Q2GlobalMin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_Q2GlobalMin_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_Q2GlobalMin_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->Q2GlobalMin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_Q2GlobalMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_Q2GlobalMin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_Q2GlobalMin_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->Q2GlobalMin);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_pTHatMinDiverge_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_pTHatMinDiverge_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_pTHatMinDiverge_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_pTHatMinDiverge_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->pTHatMinDiverge = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_pTHatMinDiverge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_pTHatMinDiverge_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_pTHatMinDiverge_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->pTHatMinDiverge);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_minWidthBreitWigners_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_minWidthBreitWigners_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_minWidthBreitWigners_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_minWidthBreitWigners_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->minWidthBreitWigners = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_minWidthBreitWigners_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_minWidthBreitWigners_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_minWidthBreitWigners_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->minWidthBreitWigners);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_idA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_idA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_idA_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_idA_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->idA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_idA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_idA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_idA_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (int) (darg->idA);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_idB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_idB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_idB_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_idB_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->idB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_idB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_idB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_idB_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (int) (darg->idB);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_mA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mA_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_mA_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->mA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_mA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mA_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->mA);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_mB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mB_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_mB_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->mB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_mB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mB_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->mB);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_eCM_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_eCM_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_eCM_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_eCM_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->eCM = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_eCM_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_eCM_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_eCM_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->eCM);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_s_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_s_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_s_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_s_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->s = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_s_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_s_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_s_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->s);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_hasLeptonBeamA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_hasLeptonBeamA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_hasLeptonBeamA_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_hasLeptonBeamA_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->hasLeptonBeamA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_hasLeptonBeamA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_hasLeptonBeamA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_hasLeptonBeamA_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool) (darg->hasLeptonBeamA);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_hasLeptonBeamB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_hasLeptonBeamB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_hasLeptonBeamB_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_hasLeptonBeamB_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->hasLeptonBeamB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_hasLeptonBeamB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_hasLeptonBeamB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_hasLeptonBeamB_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool) (darg->hasLeptonBeamB);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_hasOneLeptonBeam_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_hasOneLeptonBeam_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_hasOneLeptonBeam_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_hasOneLeptonBeam_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->hasOneLeptonBeam = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_hasOneLeptonBeam_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_hasOneLeptonBeam_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_hasOneLeptonBeam_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool) (darg->hasOneLeptonBeam);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_hasTwoLeptonBeams_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_hasTwoLeptonBeams_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_hasTwoLeptonBeams_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_hasTwoLeptonBeams_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->hasTwoLeptonBeams = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_hasTwoLeptonBeams_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_hasTwoLeptonBeams_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_hasTwoLeptonBeams_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool) (darg->hasTwoLeptonBeams);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_hasPointGammaA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_hasPointGammaA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_hasPointGammaA_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_hasPointGammaA_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->hasPointGammaA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_hasPointGammaA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_hasPointGammaA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_hasPointGammaA_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool) (darg->hasPointGammaA);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_hasPointGammaB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_hasPointGammaB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_hasPointGammaB_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_hasPointGammaB_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->hasPointGammaB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_hasPointGammaB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_hasPointGammaB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_hasPointGammaB_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool) (darg->hasPointGammaB);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_hasOnePointParticle_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_hasOnePointParticle_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_hasOnePointParticle_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_hasOnePointParticle_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->hasOnePointParticle = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_hasOnePointParticle_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_hasOnePointParticle_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_hasOnePointParticle_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool) (darg->hasOnePointParticle);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_hasTwoPointParticles_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_hasTwoPointParticles_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_hasTwoPointParticles_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_hasTwoPointParticles_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->hasTwoPointParticles = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_hasTwoPointParticles_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_hasTwoPointParticles_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_hasTwoPointParticles_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool) (darg->hasTwoPointParticles);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_newSigmaMx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_newSigmaMx_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_newSigmaMx_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_newSigmaMx_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->newSigmaMx = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_newSigmaMx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_newSigmaMx_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_newSigmaMx_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool) (darg->newSigmaMx);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_canModifySigma_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_canModifySigma_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_canModifySigma_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_canModifySigma_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->canModifySigma = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_canModifySigma_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_canModifySigma_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_canModifySigma_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool) (darg->canModifySigma);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_canBiasSelection_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_canBiasSelection_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_canBiasSelection_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_canBiasSelection_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->canBiasSelection = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_canBiasSelection_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_canBiasSelection_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_canBiasSelection_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool) (darg->canBiasSelection);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_canBias2Sel_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_canBias2Sel_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_canBias2Sel_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_canBias2Sel_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->canBias2Sel = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_canBias2Sel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_canBias2Sel_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_canBias2Sel_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool) (darg->canBias2Sel);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_gmZmode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_gmZmode_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_gmZmode_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_gmZmode_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->gmZmode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_gmZmode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_gmZmode_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_gmZmode_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (int) (darg->gmZmode);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_bias2SelPow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_bias2SelPow_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_bias2SelPow_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_bias2SelPow_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->bias2SelPow = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_bias2SelPow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_bias2SelPow_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_bias2SelPow_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->bias2SelPow);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_bias2SelRef_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_bias2SelRef_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_bias2SelRef_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_bias2SelRef_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->bias2SelRef = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_bias2SelRef_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_bias2SelRef_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_bias2SelRef_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->bias2SelRef);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_wtBW_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_wtBW_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_wtBW_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_wtBW_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->wtBW = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_wtBW_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_wtBW_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_wtBW_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->wtBW);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sigmaNw_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_sigmaNw_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sigmaNw_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_sigmaNw_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->sigmaNw = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sigmaNw_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_sigmaNw_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sigmaNw_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->sigmaNw);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sigmaMx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_sigmaMx_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sigmaMx_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_sigmaMx_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->sigmaMx = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sigmaMx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_sigmaMx_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sigmaMx_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->sigmaMx);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sigmaPos_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_sigmaPos_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sigmaPos_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_sigmaPos_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->sigmaPos = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sigmaPos_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_sigmaPos_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sigmaPos_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->sigmaPos);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sigmaNeg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_sigmaNeg_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sigmaNeg_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_sigmaNeg_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->sigmaNeg = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sigmaNeg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_sigmaNeg_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sigmaNeg_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->sigmaNeg);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_biasWt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_biasWt_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_biasWt_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_biasWt_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->biasWt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_biasWt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_biasWt_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_biasWt_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->biasWt);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mHatMin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_mHatMin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mHatMin_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_mHatMin_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->mHatMin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mHatMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_mHatMin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mHatMin_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->mHatMin);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mHatMax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_mHatMax_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mHatMax_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_mHatMax_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->mHatMax = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mHatMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_mHatMax_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mHatMax_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->mHatMax);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sHatMin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_sHatMin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sHatMin_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_sHatMin_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->sHatMin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sHatMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_sHatMin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sHatMin_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->sHatMin);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sHatMax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_sHatMax_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sHatMax_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_sHatMax_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->sHatMax = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sHatMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_sHatMax_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sHatMax_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->sHatMax);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_pTHatMin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_pTHatMin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_pTHatMin_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_pTHatMin_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->pTHatMin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_pTHatMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_pTHatMin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_pTHatMin_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->pTHatMin);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_pTHatMax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_pTHatMax_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_pTHatMax_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_pTHatMax_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->pTHatMax = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_pTHatMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_pTHatMax_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_pTHatMax_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->pTHatMax);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_pT2HatMin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_pT2HatMin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_pT2HatMin_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_pT2HatMin_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->pT2HatMin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_pT2HatMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_pT2HatMin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_pT2HatMin_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->pT2HatMin);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_pT2HatMax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_pT2HatMax_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_pT2HatMax_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_pT2HatMax_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->pT2HatMax = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_pT2HatMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_pT2HatMax_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_pT2HatMax_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->pT2HatMax);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_x1H_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_x1H_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_x1H_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_x1H_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->x1H = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_x1H_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_x1H_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_x1H_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->x1H);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_x2H_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_x2H_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_x2H_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_x2H_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->x2H = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_x2H_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_x2H_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_x2H_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->x2H);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_m3_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_m3_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_m3_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_m3_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->m3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_m3_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_m3_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_m3_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->m3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_m4_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_m4_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_m4_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_m4_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->m4 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_m4_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_m4_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_m4_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->m4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_m5_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_m5_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_m5_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_m5_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->m5 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_m5_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_m5_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_m5_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->m5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_s3_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_s3_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_s3_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_s3_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->s3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_s3_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_s3_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_s3_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->s3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_s4_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_s4_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_s4_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_s4_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->s4 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_s4_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_s4_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_s4_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->s4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_s5_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_s5_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_s5_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_s5_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->s5 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_s5_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_s5_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_s5_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->s5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mHat_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_mHat_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mHat_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_mHat_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->mHat = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mHat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_mHat_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mHat_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->mHat);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sH_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_sH_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sH_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_sH_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->sH = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sH_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_sH_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sH_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->sH);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_tH_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_tH_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_tH_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_tH_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->tH = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_tH_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_tH_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_tH_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->tH);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_uH_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_uH_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_uH_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_uH_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->uH = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_uH_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_uH_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_uH_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->uH);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_pAbs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_pAbs_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_pAbs_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_pAbs_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->pAbs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_pAbs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_pAbs_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_pAbs_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->pAbs);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_p2Abs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_p2Abs_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_p2Abs_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_p2Abs_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->p2Abs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_p2Abs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_p2Abs_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_p2Abs_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->p2Abs);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_pTH_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_pTH_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_pTH_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_pTH_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->pTH = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_pTH_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_pTH_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_pTH_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->pTH);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_theta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_theta_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_theta_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_theta_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->theta = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_theta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_theta_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_theta_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->theta);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_phi_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_phi_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_phi_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_phi_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->phi = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_phi_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_phi_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_phi_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->phi);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_betaZ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_betaZ_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_betaZ_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_betaZ_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->betaZ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_betaZ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_betaZ_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_betaZ_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->betaZ);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_pH_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  Pythia8::Vec4 *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_pH_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_pH_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_pH_set" "', argument " "2"" of type '" "Pythia8::Vec4 [12]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)12; ++ii) *(Pythia8::Vec4 *)&darg->pH[ii] = *((Pythia8::Vec4 *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""pH""' of type '""Pythia8::Vec4 [12]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_pH_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_pH_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_pH_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (Pythia8::Vec4 *)(Pythia8::Vec4 *) (darg->pH);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mH_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_mH_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mH_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_mH_set" "', argument " "2"" of type '" "double [12]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)12; ++ii) *(double *)&darg->mH[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""mH""' of type '""double [12]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mH_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_mH_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mH_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->mH);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_decayKinematicsStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PhaseSpace_decayKinematicsStep",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_decayKinematicsStep" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_decayKinematicsStep" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PhaseSpace_decayKinematicsStep" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PhaseSpace_decayKinematicsStep" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  (darg)->decayKinematicsStep(*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_setup3Body(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_setup3Body",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_setup3Body" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  (darg)->setup3Body();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_setupSampling123(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PhaseSpace_setupSampling123",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_setupSampling123" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_setupSampling123" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PhaseSpace_setupSampling123" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool)(darg)->setupSampling123(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_trialKin123__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:PhaseSpace_trialKin123",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_trialKin123" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_trialKin123" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PhaseSpace_trialKin123" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PhaseSpace_trialKin123" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool)(darg)->trialKin123(arg2,arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_trialKin123__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PhaseSpace_trialKin123",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_trialKin123" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_trialKin123" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PhaseSpace_trialKin123" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool)(darg)->trialKin123(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_trialKin123(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_PhaseSpace_trialKin123__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_PhaseSpace_trialKin123__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PhaseSpace_trialKin123'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PhaseSpace::trialKin123(bool,bool,bool)\n"
    "    Pythia8::PhaseSpace::trialKin123(bool,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_idResA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_idResA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_idResA_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_idResA_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->idResA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_idResA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_idResA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_idResA_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (int) (darg->idResA);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_idResB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_idResB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_idResB_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_idResB_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->idResB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_idResB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_idResB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_idResB_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (int) (darg->idResB);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mResA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_mResA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mResA_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_mResA_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->mResA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mResA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_mResA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mResA_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->mResA);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mResB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_mResB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mResB_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_mResB_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->mResB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mResB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_mResB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mResB_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->mResB);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_GammaResA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_GammaResA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_GammaResA_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_GammaResA_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->GammaResA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_GammaResA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_GammaResA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_GammaResA_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->GammaResA);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_GammaResB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_GammaResB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_GammaResB_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_GammaResB_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->GammaResB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_GammaResB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_GammaResB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_GammaResB_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->GammaResB);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_tauResA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_tauResA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_tauResA_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_tauResA_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->tauResA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_tauResA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_tauResA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_tauResA_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->tauResA);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_tauResB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_tauResB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_tauResB_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_tauResB_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->tauResB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_tauResB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_tauResB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_tauResB_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->tauResB);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_widResA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_widResA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_widResA_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_widResA_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->widResA = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_widResA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_widResA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_widResA_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->widResA);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_widResB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_widResB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_widResB_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_widResB_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->widResB = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_widResB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_widResB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_widResB_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->widResB);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sameResMass_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_sameResMass_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sameResMass_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_sameResMass_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->sameResMass = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sameResMass_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_sameResMass_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sameResMass_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool) (darg->sameResMass);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_useMirrorWeight_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_useMirrorWeight_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_useMirrorWeight_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_useMirrorWeight_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->useMirrorWeight = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_useMirrorWeight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_useMirrorWeight_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_useMirrorWeight_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool) (darg->useMirrorWeight);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_hasNegZ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_hasNegZ_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_hasNegZ_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_hasNegZ_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->hasNegZ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_hasNegZ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_hasNegZ_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_hasNegZ_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool) (darg->hasNegZ);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_hasPosZ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_hasPosZ_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_hasPosZ_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_hasPosZ_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->hasPosZ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_hasPosZ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_hasPosZ_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_hasPosZ_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool) (darg->hasPosZ);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_tau_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_tau_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_tau_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_tau_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->tau = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_tau_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_tau_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_tau_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->tau);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_y_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_y_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_y_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->y = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_y_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_y_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->y);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_z_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_z_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_z_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_z_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->z = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_z_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_z_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_z_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->z);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_tauMin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_tauMin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_tauMin_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_tauMin_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->tauMin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_tauMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_tauMin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_tauMin_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->tauMin);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_tauMax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_tauMax_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_tauMax_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_tauMax_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->tauMax = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_tauMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_tauMax_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_tauMax_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->tauMax);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_yMax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_yMax_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_yMax_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_yMax_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->yMax = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_yMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_yMax_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_yMax_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->yMax);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_zMin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_zMin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_zMin_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_zMin_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->zMin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_zMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_zMin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_zMin_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->zMin);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_zMax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_zMax_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_zMax_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_zMax_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->zMax = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_zMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_zMax_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_zMax_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->zMax);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_ratio34_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_ratio34_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_ratio34_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_ratio34_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->ratio34 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_ratio34_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_ratio34_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_ratio34_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->ratio34);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_unity34_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_unity34_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_unity34_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_unity34_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->unity34 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_unity34_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_unity34_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_unity34_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->unity34);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_zNeg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_zNeg_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_zNeg_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_zNeg_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->zNeg = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_zNeg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_zNeg_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_zNeg_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->zNeg);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_zPos_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_zPos_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_zPos_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_zPos_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->zPos = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_zPos_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_zPos_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_zPos_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->zPos);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_wtTau_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_wtTau_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_wtTau_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_wtTau_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->wtTau = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_wtTau_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_wtTau_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_wtTau_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->wtTau);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_wtY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_wtY_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_wtY_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_wtY_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->wtY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_wtY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_wtY_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_wtY_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->wtY);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_wtZ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_wtZ_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_wtZ_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_wtZ_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->wtZ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_wtZ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_wtZ_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_wtZ_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->wtZ);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_wt3Body_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_wt3Body_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_wt3Body_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_wt3Body_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->wt3Body = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_wt3Body_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_wt3Body_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_wt3Body_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->wt3Body);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_runBW3H_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_runBW3H_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_runBW3H_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_runBW3H_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->runBW3H = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_runBW3H_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_runBW3H_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_runBW3H_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->runBW3H);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_runBW4H_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_runBW4H_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_runBW4H_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_runBW4H_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->runBW4H = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_runBW4H_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_runBW4H_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_runBW4H_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->runBW4H);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_runBW5H_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_runBW5H_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_runBW5H_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_runBW5H_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->runBW5H = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_runBW5H_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_runBW5H_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_runBW5H_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->runBW5H);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intTau0_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_intTau0_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intTau0_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_intTau0_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->intTau0 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intTau0_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_intTau0_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intTau0_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->intTau0);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intTau1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_intTau1_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intTau1_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_intTau1_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->intTau1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intTau1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_intTau1_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intTau1_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->intTau1);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intTau2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_intTau2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intTau2_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_intTau2_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->intTau2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intTau2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_intTau2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intTau2_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->intTau2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intTau3_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_intTau3_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intTau3_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_intTau3_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->intTau3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intTau3_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_intTau3_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intTau3_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->intTau3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intTau4_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_intTau4_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intTau4_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_intTau4_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->intTau4 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intTau4_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_intTau4_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intTau4_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->intTau4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intTau5_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_intTau5_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intTau5_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_intTau5_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->intTau5 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intTau5_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_intTau5_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intTau5_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->intTau5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intTau6_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_intTau6_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intTau6_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_intTau6_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->intTau6 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intTau6_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_intTau6_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intTau6_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->intTau6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intY0_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_intY0_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intY0_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_intY0_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->intY0 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intY0_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_intY0_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intY0_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->intY0);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intY12_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_intY12_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intY12_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_intY12_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->intY12 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intY12_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_intY12_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intY12_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->intY12);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intY34_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_intY34_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intY34_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_intY34_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->intY34 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intY34_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_intY34_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intY34_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->intY34);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intY56_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_intY56_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intY56_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_intY56_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->intY56 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intY56_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_intY56_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intY56_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->intY56);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mTchan1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_mTchan1_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mTchan1_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_mTchan1_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->mTchan1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mTchan1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_mTchan1_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mTchan1_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->mTchan1);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sTchan1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_sTchan1_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sTchan1_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_sTchan1_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->sTchan1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sTchan1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_sTchan1_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sTchan1_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->sTchan1);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mTchan2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_mTchan2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mTchan2_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_mTchan2_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->mTchan2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mTchan2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_mTchan2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mTchan2_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->mTchan2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sTchan2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_sTchan2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sTchan2_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_sTchan2_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->sTchan2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sTchan2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_sTchan2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sTchan2_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->sTchan2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_frac3Flat_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_frac3Flat_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_frac3Flat_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_frac3Flat_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->frac3Flat = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_frac3Flat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_frac3Flat_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_frac3Flat_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->frac3Flat);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_frac3Pow1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_frac3Pow1_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_frac3Pow1_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_frac3Pow1_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->frac3Pow1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_frac3Pow1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_frac3Pow1_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_frac3Pow1_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->frac3Pow1);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_frac3Pow2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_frac3Pow2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_frac3Pow2_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_frac3Pow2_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->frac3Pow2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_frac3Pow2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_frac3Pow2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_frac3Pow2_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->frac3Pow2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_zNegMin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_zNegMin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_zNegMin_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_zNegMin_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->zNegMin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_zNegMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_zNegMin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_zNegMin_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->zNegMin);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_zNegMax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_zNegMax_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_zNegMax_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_zNegMax_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->zNegMax = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_zNegMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_zNegMax_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_zNegMax_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->zNegMax);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_zPosMin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_zPosMin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_zPosMin_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_zPosMin_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->zPosMin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_zPosMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_zPosMin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_zPosMin_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->zPosMin);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_zPosMax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_zPosMax_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_zPosMax_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_zPosMax_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->zPosMax = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_zPosMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_zPosMax_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_zPosMax_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double) (darg->zPosMax);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_p3cm_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  Pythia8::Vec4 *arg2 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_p3cm_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_p3cm_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_p3cm_set" "', argument " "2"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->p3cm = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_p3cm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_p3cm_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_p3cm_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (Pythia8::Vec4 *)& (darg->p3cm);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_p4cm_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  Pythia8::Vec4 *arg2 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_p4cm_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_p4cm_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_p4cm_set" "', argument " "2"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->p4cm = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_p4cm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_p4cm_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_p4cm_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (Pythia8::Vec4 *)& (darg->p4cm);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_p5cm_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  Pythia8::Vec4 *arg2 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_p5cm_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_p5cm_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_p5cm_set" "', argument " "2"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->p5cm = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_p5cm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_p5cm_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_p5cm_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (Pythia8::Vec4 *)& (darg->p5cm);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_nTau_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_nTau_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_nTau_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_nTau_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->nTau = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_nTau_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_nTau_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_nTau_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (int) (darg->nTau);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_nY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_nY_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_nY_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_nY_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->nY = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_nY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_nY_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_nY_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (int) (darg->nY);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_nZ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_nZ_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_nZ_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_nZ_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  if (arg1) darg->nZ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_nZ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_nZ_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_nZ_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (int) (darg->nZ);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_tauCoef_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_tauCoef_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_tauCoef_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_tauCoef_set" "', argument " "2"" of type '" "double [8]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)8; ++ii) *(double *)&darg->tauCoef[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""tauCoef""' of type '""double [8]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_tauCoef_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_tauCoef_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_tauCoef_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->tauCoef);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_yCoef_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_yCoef_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_yCoef_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_yCoef_set" "', argument " "2"" of type '" "double [8]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)8; ++ii) *(double *)&darg->yCoef[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""yCoef""' of type '""double [8]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_yCoef_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_yCoef_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_yCoef_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->yCoef);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_zCoef_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_zCoef_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_zCoef_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_zCoef_set" "', argument " "2"" of type '" "double [8]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)8; ++ii) *(double *)&darg->zCoef[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""zCoef""' of type '""double [8]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_zCoef_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_zCoef_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_zCoef_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->zCoef);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_tauCoefSum_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_tauCoefSum_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_tauCoefSum_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_tauCoefSum_set" "', argument " "2"" of type '" "double [8]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)8; ++ii) *(double *)&darg->tauCoefSum[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""tauCoefSum""' of type '""double [8]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_tauCoefSum_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_tauCoefSum_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_tauCoefSum_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->tauCoefSum);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_yCoefSum_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_yCoefSum_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_yCoefSum_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_yCoefSum_set" "', argument " "2"" of type '" "double [8]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)8; ++ii) *(double *)&darg->yCoefSum[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""yCoefSum""' of type '""double [8]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_yCoefSum_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_yCoefSum_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_yCoefSum_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->yCoefSum);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_zCoefSum_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_zCoefSum_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_zCoefSum_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_zCoefSum_set" "', argument " "2"" of type '" "double [8]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)8; ++ii) *(double *)&darg->zCoefSum[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""zCoefSum""' of type '""double [8]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_zCoefSum_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_zCoefSum_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_zCoefSum_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->zCoefSum);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_limitTau(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PhaseSpace_limitTau",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_limitTau" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_limitTau" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PhaseSpace_limitTau" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool)(darg)->limitTau(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_limitY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_limitY",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_limitY" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool)(darg)->limitY();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_limitZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_limitZ",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_limitZ" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool)(darg)->limitZ();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_selectTau(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  int arg2 ;
  double arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:PhaseSpace_selectTau",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_selectTau" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_selectTau" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PhaseSpace_selectTau" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PhaseSpace_selectTau" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  (darg)->selectTau(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_selectY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PhaseSpace_selectY",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_selectY" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_selectY" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PhaseSpace_selectY" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  (darg)->selectY(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_selectZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PhaseSpace_selectZ",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_selectZ" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_selectZ" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PhaseSpace_selectZ" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  (darg)->selectZ(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_select3Body(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_select3Body",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_select3Body" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool)(darg)->select3Body();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_solveSys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  int arg2 ;
  int *arg3 ;
  double *arg4 ;
  double (*arg5)[8] ;
  double *arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:PhaseSpace_solveSys",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_solveSys" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_solveSys" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PhaseSpace_solveSys" "', argument " "3"" of type '" "int [8]""'"); 
  } 
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PhaseSpace_solveSys" "', argument " "4"" of type '" "double [8]""'"); 
  } 
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_a_8__double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "PhaseSpace_solveSys" "', argument " "5"" of type '" "double [8][8]""'"); 
  } 
  arg5 = reinterpret_cast< double (*)[8] >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "PhaseSpace_solveSys" "', argument " "6"" of type '" "double [8]""'"); 
  } 
  arg6 = reinterpret_cast< double * >(argp6);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  (darg)->solveSys(arg2,arg3,arg4,(double (*)[8])arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_useBW_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  bool *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_useBW_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_useBW_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_bool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_useBW_set" "', argument " "2"" of type '" "bool [6]""'"); 
  } 
  arg2 = reinterpret_cast< bool * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(bool *)&darg->useBW[ii] = *((bool *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""useBW""' of type '""bool [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_useBW_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_useBW_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_useBW_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool *)(bool *) (darg->useBW);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bool, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_idMass_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  int *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_idMass_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_idMass_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_idMass_set" "', argument " "2"" of type '" "int [6]""'"); 
  } 
  arg2 = reinterpret_cast< int * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(int *)&darg->idMass[ii] = *((int *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""idMass""' of type '""int [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_idMass_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  int *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_idMass_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_idMass_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (int *)(int *) (darg->idMass);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mPeak_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_mPeak_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mPeak_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_mPeak_set" "', argument " "2"" of type '" "double [6]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(double *)&darg->mPeak[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""mPeak""' of type '""double [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mPeak_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_mPeak_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mPeak_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->mPeak);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sPeak_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_sPeak_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sPeak_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_sPeak_set" "', argument " "2"" of type '" "double [6]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(double *)&darg->sPeak[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""sPeak""' of type '""double [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sPeak_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_sPeak_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sPeak_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->sPeak);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mWidth_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_mWidth_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mWidth_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_mWidth_set" "', argument " "2"" of type '" "double [6]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(double *)&darg->mWidth[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""mWidth""' of type '""double [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mWidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_mWidth_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mWidth_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->mWidth);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mMin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_mMin_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mMin_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_mMin_set" "', argument " "2"" of type '" "double [6]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(double *)&darg->mMin[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""mMin""' of type '""double [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mMin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_mMin_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mMin_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->mMin);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mMax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_mMax_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mMax_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_mMax_set" "', argument " "2"" of type '" "double [6]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(double *)&darg->mMax[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""mMax""' of type '""double [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_mMax_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mMax_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->mMax);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mw_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_mw_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mw_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_mw_set" "', argument " "2"" of type '" "double [6]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(double *)&darg->mw[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""mw""' of type '""double [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mw_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_mw_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mw_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->mw);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_wmRat_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_wmRat_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_wmRat_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_wmRat_set" "', argument " "2"" of type '" "double [6]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(double *)&darg->wmRat[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""wmRat""' of type '""double [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_wmRat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_wmRat_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_wmRat_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->wmRat);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mLower_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_mLower_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mLower_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_mLower_set" "', argument " "2"" of type '" "double [6]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(double *)&darg->mLower[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""mLower""' of type '""double [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mLower_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_mLower_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mLower_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->mLower);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mUpper_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_mUpper_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mUpper_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_mUpper_set" "', argument " "2"" of type '" "double [6]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(double *)&darg->mUpper[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""mUpper""' of type '""double [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_mUpper_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_mUpper_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_mUpper_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->mUpper);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sLower_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_sLower_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sLower_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_sLower_set" "', argument " "2"" of type '" "double [6]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(double *)&darg->sLower[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""sLower""' of type '""double [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sLower_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_sLower_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sLower_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->sLower);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sUpper_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_sUpper_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sUpper_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_sUpper_set" "', argument " "2"" of type '" "double [6]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(double *)&darg->sUpper[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""sUpper""' of type '""double [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_sUpper_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_sUpper_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_sUpper_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->sUpper);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_fracFlatS_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_fracFlatS_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_fracFlatS_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_fracFlatS_set" "', argument " "2"" of type '" "double [6]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(double *)&darg->fracFlatS[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""fracFlatS""' of type '""double [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_fracFlatS_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_fracFlatS_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_fracFlatS_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->fracFlatS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_fracFlatM_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_fracFlatM_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_fracFlatM_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_fracFlatM_set" "', argument " "2"" of type '" "double [6]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(double *)&darg->fracFlatM[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""fracFlatM""' of type '""double [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_fracFlatM_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_fracFlatM_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_fracFlatM_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->fracFlatM);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_fracInv_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_fracInv_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_fracInv_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_fracInv_set" "', argument " "2"" of type '" "double [6]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(double *)&darg->fracInv[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""fracInv""' of type '""double [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_fracInv_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_fracInv_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_fracInv_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->fracInv);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_fracInv2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_fracInv2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_fracInv2_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_fracInv2_set" "', argument " "2"" of type '" "double [6]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(double *)&darg->fracInv2[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""fracInv2""' of type '""double [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_fracInv2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_fracInv2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_fracInv2_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->fracInv2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_atanLower_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_atanLower_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_atanLower_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_atanLower_set" "', argument " "2"" of type '" "double [6]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(double *)&darg->atanLower[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""atanLower""' of type '""double [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_atanLower_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_atanLower_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_atanLower_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->atanLower);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_atanUpper_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_atanUpper_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_atanUpper_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_atanUpper_set" "', argument " "2"" of type '" "double [6]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(double *)&darg->atanUpper[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""atanUpper""' of type '""double [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_atanUpper_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_atanUpper_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_atanUpper_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->atanUpper);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intBW_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_intBW_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intBW_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_intBW_set" "', argument " "2"" of type '" "double [6]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(double *)&darg->intBW[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""intBW""' of type '""double [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intBW_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_intBW_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intBW_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->intBW);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intFlatS_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_intFlatS_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intFlatS_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_intFlatS_set" "', argument " "2"" of type '" "double [6]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(double *)&darg->intFlatS[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""intFlatS""' of type '""double [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intFlatS_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_intFlatS_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intFlatS_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->intFlatS);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intFlatM_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_intFlatM_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intFlatM_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_intFlatM_set" "', argument " "2"" of type '" "double [6]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(double *)&darg->intFlatM[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""intFlatM""' of type '""double [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intFlatM_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_intFlatM_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intFlatM_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->intFlatM);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intInv_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_intInv_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intInv_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_intInv_set" "', argument " "2"" of type '" "double [6]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(double *)&darg->intInv[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""intInv""' of type '""double [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intInv_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_intInv_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intInv_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->intInv);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intInv2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double *arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_intInv2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intInv2_set" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace_intInv2_set" "', argument " "2"" of type '" "double [6]""'"); 
  } 
  arg2 = reinterpret_cast< double * >(argp2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)6; ++ii) *(double *)&darg->intInv2[ii] = *((double *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""intInv2""' of type '""double [6]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_intInv2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace_intInv2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_intInv2_get" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double *)(double *) (darg->intInv2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_setupMass1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_setupMass1",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_setupMass1" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_setupMass1" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  (darg)->setupMass1(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_setupMass2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PhaseSpace_setupMass2",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_setupMass2" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_setupMass2" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PhaseSpace_setupMass2" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  (darg)->setupMass2(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_trialMass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_trialMass",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_trialMass" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_trialMass" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  (darg)->trialMass(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_weightMass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace_weightMass",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_weightMass" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_weightMass" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (double)(darg)->weightMass(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_tRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  SwigValueWrapper< std::pair< double,double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:PhaseSpace_tRange",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_tRange" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_tRange" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PhaseSpace_tRange" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PhaseSpace_tRange" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PhaseSpace_tRange" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PhaseSpace_tRange" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (darg)->tRange(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj((new std::pair< double,double >(static_cast< const std::pair< double,double >& >(result))), SWIGTYPE_p_std__pairT_double_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace_tInRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  SwigDirector_PhaseSpace *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:PhaseSpace_tInRange",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace_tInRange" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace_tInRange" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PhaseSpace_tInRange" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PhaseSpace_tInRange" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PhaseSpace_tInRange" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PhaseSpace_tInRange" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "PhaseSpace_tInRange" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  darg = dynamic_cast<SwigDirector_PhaseSpace *>(arg1);
  result = (bool)(darg)->tInRange(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_PhaseSpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace *arg1 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:disown_PhaseSpace",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_PhaseSpace" "', argument " "1"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PhaseSpace_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__PhaseSpace, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PhaseSpace2to1tauy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to1tauy *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PhaseSpace2to1tauy")) SWIG_fail;
  result = (Pythia8::PhaseSpace2to1tauy *)new Pythia8::PhaseSpace2to1tauy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PhaseSpace2to1tauy, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to1tauy_setupSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to1tauy *arg1 = (Pythia8::PhaseSpace2to1tauy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to1tauy_setupSampling",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to1tauy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to1tauy_setupSampling" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to1tauy *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to1tauy * >(argp1);
  result = (bool)(arg1)->setupSampling();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to1tauy_trialKin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to1tauy *arg1 = (Pythia8::PhaseSpace2to1tauy *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PhaseSpace2to1tauy_trialKin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to1tauy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to1tauy_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to1tauy *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to1tauy * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace2to1tauy_trialKin" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PhaseSpace2to1tauy_trialKin" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->trialKin(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to1tauy_trialKin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to1tauy *arg1 = (Pythia8::PhaseSpace2to1tauy *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace2to1tauy_trialKin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to1tauy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to1tauy_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to1tauy *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to1tauy * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace2to1tauy_trialKin" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)(arg1)->trialKin(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to1tauy_trialKin__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to1tauy *arg1 = (Pythia8::PhaseSpace2to1tauy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to1tauy_trialKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to1tauy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to1tauy_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to1tauy *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to1tauy * >(argp1);
  result = (bool)(arg1)->trialKin();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to1tauy_trialKin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to1tauy, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_PhaseSpace2to1tauy_trialKin__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to1tauy, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PhaseSpace2to1tauy_trialKin__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to1tauy, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_PhaseSpace2to1tauy_trialKin__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PhaseSpace2to1tauy_trialKin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PhaseSpace2to1tauy::trialKin(bool,bool)\n"
    "    Pythia8::PhaseSpace2to1tauy::trialKin(bool)\n"
    "    Pythia8::PhaseSpace2to1tauy::trialKin()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to1tauy_finalKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to1tauy *arg1 = (Pythia8::PhaseSpace2to1tauy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to1tauy_finalKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to1tauy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to1tauy_finalKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to1tauy *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to1tauy * >(argp1);
  result = (bool)(arg1)->finalKin();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PhaseSpace2to1tauy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to1tauy *arg1 = (Pythia8::PhaseSpace2to1tauy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PhaseSpace2to1tauy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to1tauy, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PhaseSpace2to1tauy" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to1tauy *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to1tauy * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PhaseSpace2to1tauy_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__PhaseSpace2to1tauy, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PhaseSpace2to2tauyz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2tauyz *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PhaseSpace2to2tauyz")) SWIG_fail;
  result = (Pythia8::PhaseSpace2to2tauyz *)new Pythia8::PhaseSpace2to2tauyz();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PhaseSpace2to2tauyz, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2tauyz_setupSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2tauyz *arg1 = (Pythia8::PhaseSpace2to2tauyz *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to2tauyz_setupSampling",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2tauyz, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2tauyz_setupSampling" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2tauyz *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2tauyz * >(argp1);
  result = (bool)(arg1)->setupSampling();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2tauyz_trialKin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2tauyz *arg1 = (Pythia8::PhaseSpace2to2tauyz *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PhaseSpace2to2tauyz_trialKin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2tauyz, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2tauyz_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2tauyz *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2tauyz * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace2to2tauyz_trialKin" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PhaseSpace2to2tauyz_trialKin" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->trialKin(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2tauyz_trialKin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2tauyz *arg1 = (Pythia8::PhaseSpace2to2tauyz *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace2to2tauyz_trialKin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2tauyz, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2tauyz_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2tauyz *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2tauyz * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace2to2tauyz_trialKin" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)(arg1)->trialKin(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2tauyz_trialKin__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2tauyz *arg1 = (Pythia8::PhaseSpace2to2tauyz *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to2tauyz_trialKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2tauyz, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2tauyz_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2tauyz *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2tauyz * >(argp1);
  result = (bool)(arg1)->trialKin();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2tauyz_trialKin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to2tauyz, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_PhaseSpace2to2tauyz_trialKin__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to2tauyz, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PhaseSpace2to2tauyz_trialKin__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to2tauyz, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_PhaseSpace2to2tauyz_trialKin__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PhaseSpace2to2tauyz_trialKin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PhaseSpace2to2tauyz::trialKin(bool,bool)\n"
    "    Pythia8::PhaseSpace2to2tauyz::trialKin(bool)\n"
    "    Pythia8::PhaseSpace2to2tauyz::trialKin()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2tauyz_finalKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2tauyz *arg1 = (Pythia8::PhaseSpace2to2tauyz *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to2tauyz_finalKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2tauyz, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2tauyz_finalKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2tauyz *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2tauyz * >(argp1);
  result = (bool)(arg1)->finalKin();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2tauyz_rescaleMomenta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2tauyz *arg1 = (Pythia8::PhaseSpace2to2tauyz *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace2to2tauyz_rescaleMomenta",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2tauyz, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2tauyz_rescaleMomenta" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2tauyz *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2tauyz * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace2to2tauyz_rescaleMomenta" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->rescaleMomenta(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2tauyz_rescaleSigma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2tauyz *arg1 = (Pythia8::PhaseSpace2to2tauyz *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace2to2tauyz_rescaleSigma",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2tauyz, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2tauyz_rescaleSigma" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2tauyz *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2tauyz * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace2to2tauyz_rescaleSigma" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->rescaleSigma(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2tauyz_weightGammaPDFApprox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2tauyz *arg1 = (Pythia8::PhaseSpace2to2tauyz *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to2tauyz_weightGammaPDFApprox",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2tauyz, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2tauyz_weightGammaPDFApprox" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2tauyz *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2tauyz * >(argp1);
  result = (double)(arg1)->weightGammaPDFApprox();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PhaseSpace2to2tauyz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2tauyz *arg1 = (Pythia8::PhaseSpace2to2tauyz *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PhaseSpace2to2tauyz",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2tauyz, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PhaseSpace2to2tauyz" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2tauyz *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2tauyz * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PhaseSpace2to2tauyz_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__PhaseSpace2to2tauyz, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PhaseSpace2to2elastic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2elastic *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PhaseSpace2to2elastic")) SWIG_fail;
  result = (Pythia8::PhaseSpace2to2elastic *)new Pythia8::PhaseSpace2to2elastic();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PhaseSpace2to2elastic, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2elastic_setupSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2elastic *arg1 = (Pythia8::PhaseSpace2to2elastic *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to2elastic_setupSampling",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2elastic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2elastic_setupSampling" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2elastic *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2elastic * >(argp1);
  result = (bool)(arg1)->setupSampling();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2elastic_trialKin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2elastic *arg1 = (Pythia8::PhaseSpace2to2elastic *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PhaseSpace2to2elastic_trialKin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2elastic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2elastic_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2elastic *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2elastic * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace2to2elastic_trialKin" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PhaseSpace2to2elastic_trialKin" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->trialKin(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2elastic_trialKin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2elastic *arg1 = (Pythia8::PhaseSpace2to2elastic *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace2to2elastic_trialKin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2elastic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2elastic_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2elastic *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2elastic * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace2to2elastic_trialKin" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)(arg1)->trialKin(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2elastic_trialKin__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2elastic *arg1 = (Pythia8::PhaseSpace2to2elastic *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to2elastic_trialKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2elastic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2elastic_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2elastic *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2elastic * >(argp1);
  result = (bool)(arg1)->trialKin();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2elastic_trialKin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to2elastic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_PhaseSpace2to2elastic_trialKin__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to2elastic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PhaseSpace2to2elastic_trialKin__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to2elastic, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_PhaseSpace2to2elastic_trialKin__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PhaseSpace2to2elastic_trialKin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PhaseSpace2to2elastic::trialKin(bool,bool)\n"
    "    Pythia8::PhaseSpace2to2elastic::trialKin(bool)\n"
    "    Pythia8::PhaseSpace2to2elastic::trialKin()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2elastic_finalKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2elastic *arg1 = (Pythia8::PhaseSpace2to2elastic *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to2elastic_finalKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2elastic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2elastic_finalKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2elastic *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2elastic * >(argp1);
  result = (bool)(arg1)->finalKin();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2elastic_isResolved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2elastic *arg1 = (Pythia8::PhaseSpace2to2elastic *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to2elastic_isResolved",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2elastic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2elastic_isResolved" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2elastic const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2elastic * >(argp1);
  result = (bool)((Pythia8::PhaseSpace2to2elastic const *)arg1)->isResolved();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PhaseSpace2to2elastic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2elastic *arg1 = (Pythia8::PhaseSpace2to2elastic *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PhaseSpace2to2elastic",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2elastic, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PhaseSpace2to2elastic" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2elastic *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2elastic * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PhaseSpace2to2elastic_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__PhaseSpace2to2elastic, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PhaseSpace2to2diffractive__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool arg2 ;
  bool val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::PhaseSpace2to2diffractive *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_PhaseSpace2to2diffractive",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PhaseSpace2to2diffractive" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PhaseSpace2to2diffractive" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (Pythia8::PhaseSpace2to2diffractive *)new Pythia8::PhaseSpace2to2diffractive(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PhaseSpace2to2diffractive, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PhaseSpace2to2diffractive__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::PhaseSpace2to2diffractive *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_PhaseSpace2to2diffractive",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PhaseSpace2to2diffractive" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  result = (Pythia8::PhaseSpace2to2diffractive *)new Pythia8::PhaseSpace2to2diffractive(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PhaseSpace2to2diffractive, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PhaseSpace2to2diffractive__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2diffractive *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PhaseSpace2to2diffractive")) SWIG_fail;
  result = (Pythia8::PhaseSpace2to2diffractive *)new Pythia8::PhaseSpace2to2diffractive();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PhaseSpace2to2diffractive, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PhaseSpace2to2diffractive(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_PhaseSpace2to2diffractive__SWIG_2(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_PhaseSpace2to2diffractive__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_PhaseSpace2to2diffractive__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PhaseSpace2to2diffractive'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PhaseSpace2to2diffractive::PhaseSpace2to2diffractive(bool,bool)\n"
    "    Pythia8::PhaseSpace2to2diffractive::PhaseSpace2to2diffractive(bool)\n"
    "    Pythia8::PhaseSpace2to2diffractive::PhaseSpace2to2diffractive()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2diffractive_setupSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2diffractive *arg1 = (Pythia8::PhaseSpace2to2diffractive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to2diffractive_setupSampling",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2diffractive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2diffractive_setupSampling" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2diffractive *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2diffractive * >(argp1);
  result = (bool)(arg1)->setupSampling();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2diffractive_trialKin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2diffractive *arg1 = (Pythia8::PhaseSpace2to2diffractive *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PhaseSpace2to2diffractive_trialKin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2diffractive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2diffractive_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2diffractive *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2diffractive * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace2to2diffractive_trialKin" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PhaseSpace2to2diffractive_trialKin" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->trialKin(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2diffractive_trialKin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2diffractive *arg1 = (Pythia8::PhaseSpace2to2diffractive *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace2to2diffractive_trialKin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2diffractive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2diffractive_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2diffractive *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2diffractive * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace2to2diffractive_trialKin" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)(arg1)->trialKin(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2diffractive_trialKin__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2diffractive *arg1 = (Pythia8::PhaseSpace2to2diffractive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to2diffractive_trialKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2diffractive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2diffractive_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2diffractive *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2diffractive * >(argp1);
  result = (bool)(arg1)->trialKin();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2diffractive_trialKin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to2diffractive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_PhaseSpace2to2diffractive_trialKin__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to2diffractive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PhaseSpace2to2diffractive_trialKin__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to2diffractive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_PhaseSpace2to2diffractive_trialKin__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PhaseSpace2to2diffractive_trialKin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PhaseSpace2to2diffractive::trialKin(bool,bool)\n"
    "    Pythia8::PhaseSpace2to2diffractive::trialKin(bool)\n"
    "    Pythia8::PhaseSpace2to2diffractive::trialKin()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2diffractive_finalKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2diffractive *arg1 = (Pythia8::PhaseSpace2to2diffractive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to2diffractive_finalKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2diffractive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2diffractive_finalKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2diffractive *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2diffractive * >(argp1);
  result = (bool)(arg1)->finalKin();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2diffractive_isResolved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2diffractive *arg1 = (Pythia8::PhaseSpace2to2diffractive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to2diffractive_isResolved",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2diffractive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2diffractive_isResolved" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2diffractive const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2diffractive * >(argp1);
  result = (bool)((Pythia8::PhaseSpace2to2diffractive const *)arg1)->isResolved();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PhaseSpace2to2diffractive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2diffractive *arg1 = (Pythia8::PhaseSpace2to2diffractive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PhaseSpace2to2diffractive",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2diffractive, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PhaseSpace2to2diffractive" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2diffractive *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2diffractive * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PhaseSpace2to2diffractive_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__PhaseSpace2to2diffractive, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PhaseSpace2to3diffractive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to3diffractive *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PhaseSpace2to3diffractive")) SWIG_fail;
  result = (Pythia8::PhaseSpace2to3diffractive *)new Pythia8::PhaseSpace2to3diffractive();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PhaseSpace2to3diffractive, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to3diffractive_setupSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to3diffractive *arg1 = (Pythia8::PhaseSpace2to3diffractive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to3diffractive_setupSampling",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to3diffractive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to3diffractive_setupSampling" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to3diffractive *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to3diffractive * >(argp1);
  result = (bool)(arg1)->setupSampling();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to3diffractive_trialKin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to3diffractive *arg1 = (Pythia8::PhaseSpace2to3diffractive *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PhaseSpace2to3diffractive_trialKin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to3diffractive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to3diffractive_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to3diffractive *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to3diffractive * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace2to3diffractive_trialKin" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PhaseSpace2to3diffractive_trialKin" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->trialKin(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to3diffractive_trialKin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to3diffractive *arg1 = (Pythia8::PhaseSpace2to3diffractive *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace2to3diffractive_trialKin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to3diffractive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to3diffractive_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to3diffractive *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to3diffractive * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace2to3diffractive_trialKin" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)(arg1)->trialKin(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to3diffractive_trialKin__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to3diffractive *arg1 = (Pythia8::PhaseSpace2to3diffractive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to3diffractive_trialKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to3diffractive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to3diffractive_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to3diffractive *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to3diffractive * >(argp1);
  result = (bool)(arg1)->trialKin();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to3diffractive_trialKin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to3diffractive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_PhaseSpace2to3diffractive_trialKin__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to3diffractive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PhaseSpace2to3diffractive_trialKin__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to3diffractive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_PhaseSpace2to3diffractive_trialKin__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PhaseSpace2to3diffractive_trialKin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PhaseSpace2to3diffractive::trialKin(bool,bool)\n"
    "    Pythia8::PhaseSpace2to3diffractive::trialKin(bool)\n"
    "    Pythia8::PhaseSpace2to3diffractive::trialKin()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to3diffractive_finalKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to3diffractive *arg1 = (Pythia8::PhaseSpace2to3diffractive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to3diffractive_finalKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to3diffractive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to3diffractive_finalKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to3diffractive *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to3diffractive * >(argp1);
  result = (bool)(arg1)->finalKin();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to3diffractive_isResolved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to3diffractive *arg1 = (Pythia8::PhaseSpace2to3diffractive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to3diffractive_isResolved",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to3diffractive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to3diffractive_isResolved" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to3diffractive const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to3diffractive * >(argp1);
  result = (bool)((Pythia8::PhaseSpace2to3diffractive const *)arg1)->isResolved();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PhaseSpace2to3diffractive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to3diffractive *arg1 = (Pythia8::PhaseSpace2to3diffractive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PhaseSpace2to3diffractive",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to3diffractive, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PhaseSpace2to3diffractive" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to3diffractive *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to3diffractive * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PhaseSpace2to3diffractive_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__PhaseSpace2to3diffractive, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_PhaseSpace2to2nondiffractive_setupSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2nondiffractive *arg1 = (Pythia8::PhaseSpace2to2nondiffractive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to2nondiffractive_setupSampling",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2nondiffractive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2nondiffractive_setupSampling" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2nondiffractive *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2nondiffractive * >(argp1);
  result = (bool)(arg1)->setupSampling();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2nondiffractive_trialKin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2nondiffractive *arg1 = (Pythia8::PhaseSpace2to2nondiffractive *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PhaseSpace2to2nondiffractive_trialKin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2nondiffractive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2nondiffractive_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2nondiffractive *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2nondiffractive * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace2to2nondiffractive_trialKin" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PhaseSpace2to2nondiffractive_trialKin" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->trialKin(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2nondiffractive_trialKin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2nondiffractive *arg1 = (Pythia8::PhaseSpace2to2nondiffractive *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace2to2nondiffractive_trialKin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2nondiffractive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2nondiffractive_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2nondiffractive *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2nondiffractive * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace2to2nondiffractive_trialKin" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)(arg1)->trialKin(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2nondiffractive_trialKin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to2nondiffractive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PhaseSpace2to2nondiffractive_trialKin__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to2nondiffractive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_PhaseSpace2to2nondiffractive_trialKin__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PhaseSpace2to2nondiffractive_trialKin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PhaseSpace2to2nondiffractive::trialKin(bool,bool)\n"
    "    Pythia8::PhaseSpace2to2nondiffractive::trialKin(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2nondiffractive_finalKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2nondiffractive *arg1 = (Pythia8::PhaseSpace2to2nondiffractive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to2nondiffractive_finalKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2nondiffractive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2nondiffractive_finalKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2nondiffractive *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2nondiffractive * >(argp1);
  result = (bool)(arg1)->finalKin();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PhaseSpace2to2nondiffractive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2nondiffractive *arg1 = (Pythia8::PhaseSpace2to2nondiffractive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PhaseSpace2to2nondiffractive",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2nondiffractive, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PhaseSpace2to2nondiffractive" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2nondiffractive *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2nondiffractive * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PhaseSpace2to2nondiffractive_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__PhaseSpace2to2nondiffractive, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PhaseSpace2to2nondiffractiveGamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2nondiffractiveGamma *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PhaseSpace2to2nondiffractiveGamma")) SWIG_fail;
  result = (Pythia8::PhaseSpace2to2nondiffractiveGamma *)new Pythia8::PhaseSpace2to2nondiffractiveGamma();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PhaseSpace2to2nondiffractiveGamma, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2nondiffractiveGamma_setupSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2nondiffractiveGamma *arg1 = (Pythia8::PhaseSpace2to2nondiffractiveGamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to2nondiffractiveGamma_setupSampling",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2nondiffractiveGamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2nondiffractiveGamma_setupSampling" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2nondiffractiveGamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2nondiffractiveGamma * >(argp1);
  result = (bool)(arg1)->setupSampling();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2nondiffractiveGamma_trialKin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2nondiffractiveGamma *arg1 = (Pythia8::PhaseSpace2to2nondiffractiveGamma *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PhaseSpace2to2nondiffractiveGamma_trialKin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2nondiffractiveGamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2nondiffractiveGamma_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2nondiffractiveGamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2nondiffractiveGamma * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace2to2nondiffractiveGamma_trialKin" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PhaseSpace2to2nondiffractiveGamma_trialKin" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->trialKin(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2nondiffractiveGamma_trialKin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2nondiffractiveGamma *arg1 = (Pythia8::PhaseSpace2to2nondiffractiveGamma *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace2to2nondiffractiveGamma_trialKin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2nondiffractiveGamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2nondiffractiveGamma_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2nondiffractiveGamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2nondiffractiveGamma * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace2to2nondiffractiveGamma_trialKin" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)(arg1)->trialKin(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2nondiffractiveGamma_trialKin__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2nondiffractiveGamma *arg1 = (Pythia8::PhaseSpace2to2nondiffractiveGamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to2nondiffractiveGamma_trialKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2nondiffractiveGamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2nondiffractiveGamma_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2nondiffractiveGamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2nondiffractiveGamma * >(argp1);
  result = (bool)(arg1)->trialKin();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2nondiffractiveGamma_trialKin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to2nondiffractiveGamma, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_PhaseSpace2to2nondiffractiveGamma_trialKin__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to2nondiffractiveGamma, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PhaseSpace2to2nondiffractiveGamma_trialKin__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to2nondiffractiveGamma, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_PhaseSpace2to2nondiffractiveGamma_trialKin__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PhaseSpace2to2nondiffractiveGamma_trialKin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PhaseSpace2to2nondiffractiveGamma::trialKin(bool,bool)\n"
    "    Pythia8::PhaseSpace2to2nondiffractiveGamma::trialKin(bool)\n"
    "    Pythia8::PhaseSpace2to2nondiffractiveGamma::trialKin()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2nondiffractiveGamma_finalKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2nondiffractiveGamma *arg1 = (Pythia8::PhaseSpace2to2nondiffractiveGamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to2nondiffractiveGamma_finalKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2nondiffractiveGamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2nondiffractiveGamma_finalKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2nondiffractiveGamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2nondiffractiveGamma * >(argp1);
  result = (bool)(arg1)->finalKin();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to2nondiffractiveGamma_setGammaKinPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2nondiffractiveGamma *arg1 = (Pythia8::PhaseSpace2to2nondiffractiveGamma *) 0 ;
  Pythia8::GammaKinematics *arg2 = (Pythia8::GammaKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace2to2nondiffractiveGamma_setGammaKinPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2nondiffractiveGamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to2nondiffractiveGamma_setGammaKinPtr" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2nondiffractiveGamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2nondiffractiveGamma * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__GammaKinematics, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PhaseSpace2to2nondiffractiveGamma_setGammaKinPtr" "', argument " "2"" of type '" "Pythia8::GammaKinematics *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::GammaKinematics * >(argp2);
  (arg1)->setGammaKinPtr(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PhaseSpace2to2nondiffractiveGamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to2nondiffractiveGamma *arg1 = (Pythia8::PhaseSpace2to2nondiffractiveGamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PhaseSpace2to2nondiffractiveGamma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to2nondiffractiveGamma, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PhaseSpace2to2nondiffractiveGamma" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to2nondiffractiveGamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to2nondiffractiveGamma * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PhaseSpace2to2nondiffractiveGamma_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__PhaseSpace2to2nondiffractiveGamma, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PhaseSpace2to3tauycyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to3tauycyl *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PhaseSpace2to3tauycyl")) SWIG_fail;
  result = (Pythia8::PhaseSpace2to3tauycyl *)new Pythia8::PhaseSpace2to3tauycyl();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PhaseSpace2to3tauycyl, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to3tauycyl_setupSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to3tauycyl *arg1 = (Pythia8::PhaseSpace2to3tauycyl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to3tauycyl_setupSampling",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to3tauycyl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to3tauycyl_setupSampling" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to3tauycyl *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to3tauycyl * >(argp1);
  result = (bool)(arg1)->setupSampling();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to3tauycyl_trialKin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to3tauycyl *arg1 = (Pythia8::PhaseSpace2to3tauycyl *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PhaseSpace2to3tauycyl_trialKin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to3tauycyl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to3tauycyl_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to3tauycyl *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to3tauycyl * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace2to3tauycyl_trialKin" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PhaseSpace2to3tauycyl_trialKin" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->trialKin(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to3tauycyl_trialKin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to3tauycyl *arg1 = (Pythia8::PhaseSpace2to3tauycyl *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace2to3tauycyl_trialKin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to3tauycyl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to3tauycyl_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to3tauycyl *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to3tauycyl * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace2to3tauycyl_trialKin" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)(arg1)->trialKin(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to3tauycyl_trialKin__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to3tauycyl *arg1 = (Pythia8::PhaseSpace2to3tauycyl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to3tauycyl_trialKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to3tauycyl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to3tauycyl_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to3tauycyl *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to3tauycyl * >(argp1);
  result = (bool)(arg1)->trialKin();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to3tauycyl_trialKin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to3tauycyl, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_PhaseSpace2to3tauycyl_trialKin__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to3tauycyl, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PhaseSpace2to3tauycyl_trialKin__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to3tauycyl, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_PhaseSpace2to3tauycyl_trialKin__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PhaseSpace2to3tauycyl_trialKin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PhaseSpace2to3tauycyl::trialKin(bool,bool)\n"
    "    Pythia8::PhaseSpace2to3tauycyl::trialKin(bool)\n"
    "    Pythia8::PhaseSpace2to3tauycyl::trialKin()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to3tauycyl_finalKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to3tauycyl *arg1 = (Pythia8::PhaseSpace2to3tauycyl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to3tauycyl_finalKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to3tauycyl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to3tauycyl_finalKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to3tauycyl *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to3tauycyl * >(argp1);
  result = (bool)(arg1)->finalKin();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PhaseSpace2to3tauycyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to3tauycyl *arg1 = (Pythia8::PhaseSpace2to3tauycyl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PhaseSpace2to3tauycyl",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to3tauycyl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PhaseSpace2to3tauycyl" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to3tauycyl *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to3tauycyl * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PhaseSpace2to3tauycyl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__PhaseSpace2to3tauycyl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PhaseSpace2to3yyycyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to3yyycyl *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PhaseSpace2to3yyycyl")) SWIG_fail;
  result = (Pythia8::PhaseSpace2to3yyycyl *)new Pythia8::PhaseSpace2to3yyycyl();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PhaseSpace2to3yyycyl, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to3yyycyl_setupSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to3yyycyl *arg1 = (Pythia8::PhaseSpace2to3yyycyl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to3yyycyl_setupSampling",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to3yyycyl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to3yyycyl_setupSampling" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to3yyycyl *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to3yyycyl * >(argp1);
  result = (bool)(arg1)->setupSampling();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to3yyycyl_trialKin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to3yyycyl *arg1 = (Pythia8::PhaseSpace2to3yyycyl *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PhaseSpace2to3yyycyl_trialKin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to3yyycyl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to3yyycyl_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to3yyycyl *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to3yyycyl * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace2to3yyycyl_trialKin" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PhaseSpace2to3yyycyl_trialKin" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->trialKin(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to3yyycyl_trialKin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to3yyycyl *arg1 = (Pythia8::PhaseSpace2to3yyycyl *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpace2to3yyycyl_trialKin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to3yyycyl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to3yyycyl_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to3yyycyl *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to3yyycyl * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpace2to3yyycyl_trialKin" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)(arg1)->trialKin(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to3yyycyl_trialKin__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to3yyycyl *arg1 = (Pythia8::PhaseSpace2to3yyycyl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to3yyycyl_trialKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to3yyycyl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to3yyycyl_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to3yyycyl *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to3yyycyl * >(argp1);
  result = (bool)(arg1)->trialKin();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to3yyycyl_trialKin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to3yyycyl, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_PhaseSpace2to3yyycyl_trialKin__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to3yyycyl, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PhaseSpace2to3yyycyl_trialKin__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace2to3yyycyl, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_PhaseSpace2to3yyycyl_trialKin__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PhaseSpace2to3yyycyl_trialKin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PhaseSpace2to3yyycyl::trialKin(bool,bool)\n"
    "    Pythia8::PhaseSpace2to3yyycyl::trialKin(bool)\n"
    "    Pythia8::PhaseSpace2to3yyycyl::trialKin()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PhaseSpace2to3yyycyl_finalKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to3yyycyl *arg1 = (Pythia8::PhaseSpace2to3yyycyl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpace2to3yyycyl_finalKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to3yyycyl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpace2to3yyycyl_finalKin" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to3yyycyl *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to3yyycyl * >(argp1);
  result = (bool)(arg1)->finalKin();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PhaseSpace2to3yyycyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpace2to3yyycyl *arg1 = (Pythia8::PhaseSpace2to3yyycyl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PhaseSpace2to3yyycyl",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpace2to3yyycyl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PhaseSpace2to3yyycyl" "', argument " "1"" of type '" "Pythia8::PhaseSpace2to3yyycyl *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpace2to3yyycyl * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PhaseSpace2to3yyycyl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__PhaseSpace2to3yyycyl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_PhaseSpaceLHA_setupSampling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpaceLHA *arg1 = (Pythia8::PhaseSpaceLHA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpaceLHA_setupSampling",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpaceLHA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpaceLHA_setupSampling" "', argument " "1"" of type '" "Pythia8::PhaseSpaceLHA *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpaceLHA * >(argp1);
  result = (bool)(arg1)->setupSampling();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpaceLHA_trialKin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpaceLHA *arg1 = (Pythia8::PhaseSpaceLHA *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PhaseSpaceLHA_trialKin",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpaceLHA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpaceLHA_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpaceLHA *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpaceLHA * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpaceLHA_trialKin" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PhaseSpaceLHA_trialKin" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->trialKin(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpaceLHA_trialKin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpaceLHA *arg1 = (Pythia8::PhaseSpaceLHA *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PhaseSpaceLHA_trialKin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpaceLHA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpaceLHA_trialKin" "', argument " "1"" of type '" "Pythia8::PhaseSpaceLHA *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpaceLHA * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PhaseSpaceLHA_trialKin" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)(arg1)->trialKin(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpaceLHA_trialKin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpaceLHA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PhaseSpaceLHA_trialKin__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PhaseSpaceLHA, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_PhaseSpaceLHA_trialKin__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PhaseSpaceLHA_trialKin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PhaseSpaceLHA::trialKin(bool,bool)\n"
    "    Pythia8::PhaseSpaceLHA::trialKin(bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PhaseSpaceLHA_finalKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpaceLHA *arg1 = (Pythia8::PhaseSpaceLHA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpaceLHA_finalKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpaceLHA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpaceLHA_finalKin" "', argument " "1"" of type '" "Pythia8::PhaseSpaceLHA *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpaceLHA * >(argp1);
  result = (bool)(arg1)->finalKin();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PhaseSpaceLHA_sigmaSumSigned(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpaceLHA *arg1 = (Pythia8::PhaseSpaceLHA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PhaseSpaceLHA_sigmaSumSigned",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpaceLHA, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PhaseSpaceLHA_sigmaSumSigned" "', argument " "1"" of type '" "Pythia8::PhaseSpaceLHA const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpaceLHA * >(argp1);
  result = (double)((Pythia8::PhaseSpaceLHA const *)arg1)->sigmaSumSigned();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PhaseSpaceLHA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PhaseSpaceLHA *arg1 = (Pythia8::PhaseSpaceLHA *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PhaseSpaceLHA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PhaseSpaceLHA, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PhaseSpaceLHA" "', argument " "1"" of type '" "Pythia8::PhaseSpaceLHA *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PhaseSpaceLHA * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PhaseSpaceLHA_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__PhaseSpaceLHA, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma1qg2qStar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma1qg2qStar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma1qg2qStar",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma1qg2qStar" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Sigma1qg2qStar *)new Pythia8::Sigma1qg2qStar(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma1qg2qStar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qg2qStar_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qg2qStar *arg1 = (Pythia8::Sigma1qg2qStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qg2qStar_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qg2qStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qg2qStar_initProc" "', argument " "1"" of type '" "Pythia8::Sigma1qg2qStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qg2qStar * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qg2qStar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qg2qStar *arg1 = (Pythia8::Sigma1qg2qStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qg2qStar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qg2qStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qg2qStar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma1qg2qStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qg2qStar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qg2qStar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qg2qStar *arg1 = (Pythia8::Sigma1qg2qStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qg2qStar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qg2qStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qg2qStar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma1qg2qStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qg2qStar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qg2qStar_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qg2qStar *arg1 = (Pythia8::Sigma1qg2qStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qg2qStar_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qg2qStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qg2qStar_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma1qg2qStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qg2qStar * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qg2qStar_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qg2qStar *arg1 = (Pythia8::Sigma1qg2qStar *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma1qg2qStar_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qg2qStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qg2qStar_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma1qg2qStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qg2qStar * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma1qg2qStar_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma1qg2qStar_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma1qg2qStar_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma1qg2qStar_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qg2qStar_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qg2qStar *arg1 = (Pythia8::Sigma1qg2qStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qg2qStar_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qg2qStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qg2qStar_name" "', argument " "1"" of type '" "Pythia8::Sigma1qg2qStar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qg2qStar * >(argp1);
  result = ((Pythia8::Sigma1qg2qStar const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qg2qStar_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qg2qStar *arg1 = (Pythia8::Sigma1qg2qStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qg2qStar_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qg2qStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qg2qStar_code" "', argument " "1"" of type '" "Pythia8::Sigma1qg2qStar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qg2qStar * >(argp1);
  result = (int)((Pythia8::Sigma1qg2qStar const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qg2qStar_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qg2qStar *arg1 = (Pythia8::Sigma1qg2qStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qg2qStar_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qg2qStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qg2qStar_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma1qg2qStar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qg2qStar * >(argp1);
  result = ((Pythia8::Sigma1qg2qStar const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qg2qStar_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qg2qStar *arg1 = (Pythia8::Sigma1qg2qStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qg2qStar_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qg2qStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qg2qStar_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma1qg2qStar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qg2qStar * >(argp1);
  result = (int)((Pythia8::Sigma1qg2qStar const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma1qg2qStar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qg2qStar *arg1 = (Pythia8::Sigma1qg2qStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma1qg2qStar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qg2qStar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma1qg2qStar" "', argument " "1"" of type '" "Pythia8::Sigma1qg2qStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qg2qStar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma1qg2qStar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma1qg2qStar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma1lgm2lStar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma1lgm2lStar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma1lgm2lStar",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma1lgm2lStar" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Sigma1lgm2lStar *)new Pythia8::Sigma1lgm2lStar(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma1lgm2lStar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1lgm2lStar_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1lgm2lStar *arg1 = (Pythia8::Sigma1lgm2lStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1lgm2lStar_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1lgm2lStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1lgm2lStar_initProc" "', argument " "1"" of type '" "Pythia8::Sigma1lgm2lStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1lgm2lStar * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1lgm2lStar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1lgm2lStar *arg1 = (Pythia8::Sigma1lgm2lStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1lgm2lStar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1lgm2lStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1lgm2lStar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma1lgm2lStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1lgm2lStar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1lgm2lStar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1lgm2lStar *arg1 = (Pythia8::Sigma1lgm2lStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1lgm2lStar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1lgm2lStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1lgm2lStar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma1lgm2lStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1lgm2lStar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1lgm2lStar_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1lgm2lStar *arg1 = (Pythia8::Sigma1lgm2lStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1lgm2lStar_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1lgm2lStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1lgm2lStar_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma1lgm2lStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1lgm2lStar * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1lgm2lStar_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1lgm2lStar *arg1 = (Pythia8::Sigma1lgm2lStar *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma1lgm2lStar_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1lgm2lStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1lgm2lStar_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma1lgm2lStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1lgm2lStar * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma1lgm2lStar_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma1lgm2lStar_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma1lgm2lStar_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma1lgm2lStar_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1lgm2lStar_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1lgm2lStar *arg1 = (Pythia8::Sigma1lgm2lStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1lgm2lStar_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1lgm2lStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1lgm2lStar_name" "', argument " "1"" of type '" "Pythia8::Sigma1lgm2lStar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1lgm2lStar * >(argp1);
  result = ((Pythia8::Sigma1lgm2lStar const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1lgm2lStar_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1lgm2lStar *arg1 = (Pythia8::Sigma1lgm2lStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1lgm2lStar_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1lgm2lStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1lgm2lStar_code" "', argument " "1"" of type '" "Pythia8::Sigma1lgm2lStar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1lgm2lStar * >(argp1);
  result = (int)((Pythia8::Sigma1lgm2lStar const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1lgm2lStar_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1lgm2lStar *arg1 = (Pythia8::Sigma1lgm2lStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1lgm2lStar_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1lgm2lStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1lgm2lStar_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma1lgm2lStar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1lgm2lStar * >(argp1);
  result = ((Pythia8::Sigma1lgm2lStar const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1lgm2lStar_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1lgm2lStar *arg1 = (Pythia8::Sigma1lgm2lStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1lgm2lStar_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1lgm2lStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1lgm2lStar_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma1lgm2lStar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1lgm2lStar * >(argp1);
  result = (int)((Pythia8::Sigma1lgm2lStar const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma1lgm2lStar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1lgm2lStar *arg1 = (Pythia8::Sigma1lgm2lStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma1lgm2lStar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1lgm2lStar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma1lgm2lStar" "', argument " "1"" of type '" "Pythia8::Sigma1lgm2lStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1lgm2lStar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma1lgm2lStar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma1lgm2lStar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qq2qStarq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma2qq2qStarq *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma2qq2qStarq",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qq2qStarq" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Sigma2qq2qStarq *)new Pythia8::Sigma2qq2qStarq(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qq2qStarq, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2qStarq_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2qStarq *arg1 = (Pythia8::Sigma2qq2qStarq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2qStarq_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2qStarq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2qStarq_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qq2qStarq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2qStarq * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2qStarq_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2qStarq *arg1 = (Pythia8::Sigma2qq2qStarq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2qStarq_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2qStarq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2qStarq_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qq2qStarq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2qStarq * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2qStarq_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2qStarq *arg1 = (Pythia8::Sigma2qq2qStarq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2qStarq_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2qStarq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2qStarq_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qq2qStarq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2qStarq * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2qStarq_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2qStarq *arg1 = (Pythia8::Sigma2qq2qStarq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2qStarq_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2qStarq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2qStarq_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qq2qStarq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2qStarq * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2qStarq_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2qStarq *arg1 = (Pythia8::Sigma2qq2qStarq *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2qq2qStarq_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2qStarq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2qStarq_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2qq2qStarq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2qStarq * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2qq2qStarq_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2qq2qStarq_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2qq2qStarq_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2qq2qStarq_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2qStarq_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2qStarq *arg1 = (Pythia8::Sigma2qq2qStarq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2qStarq_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2qStarq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2qStarq_name" "', argument " "1"" of type '" "Pythia8::Sigma2qq2qStarq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2qStarq * >(argp1);
  result = ((Pythia8::Sigma2qq2qStarq const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2qStarq_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2qStarq *arg1 = (Pythia8::Sigma2qq2qStarq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2qStarq_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2qStarq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2qStarq_code" "', argument " "1"" of type '" "Pythia8::Sigma2qq2qStarq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2qStarq * >(argp1);
  result = (int)((Pythia8::Sigma2qq2qStarq const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2qStarq_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2qStarq *arg1 = (Pythia8::Sigma2qq2qStarq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2qStarq_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2qStarq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2qStarq_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qq2qStarq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2qStarq * >(argp1);
  result = ((Pythia8::Sigma2qq2qStarq const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2qStarq_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2qStarq *arg1 = (Pythia8::Sigma2qq2qStarq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2qStarq_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2qStarq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2qStarq_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qq2qStarq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2qStarq * >(argp1);
  result = (int)((Pythia8::Sigma2qq2qStarq const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qq2qStarq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2qStarq *arg1 = (Pythia8::Sigma2qq2qStarq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qq2qStarq",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2qStarq, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qq2qStarq" "', argument " "1"" of type '" "Pythia8::Sigma2qq2qStarq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2qStarq * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qq2qStarq_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qq2qStarq, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2lStarlbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma2qqbar2lStarlbar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma2qqbar2lStarlbar",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qqbar2lStarlbar" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Sigma2qqbar2lStarlbar *)new Pythia8::Sigma2qqbar2lStarlbar(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlbar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2lStarlbar_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2lStarlbar *arg1 = (Pythia8::Sigma2qqbar2lStarlbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2lStarlbar_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2lStarlbar_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2lStarlbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2lStarlbar * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2lStarlbar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2lStarlbar *arg1 = (Pythia8::Sigma2qqbar2lStarlbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2lStarlbar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2lStarlbar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2lStarlbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2lStarlbar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2lStarlbar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2lStarlbar *arg1 = (Pythia8::Sigma2qqbar2lStarlbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2lStarlbar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2lStarlbar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2lStarlbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2lStarlbar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2lStarlbar_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2lStarlbar *arg1 = (Pythia8::Sigma2qqbar2lStarlbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2lStarlbar_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2lStarlbar_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2lStarlbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2lStarlbar * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2lStarlbar_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2lStarlbar *arg1 = (Pythia8::Sigma2qqbar2lStarlbar *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2qqbar2lStarlbar_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2lStarlbar_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2lStarlbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2lStarlbar * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2qqbar2lStarlbar_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2qqbar2lStarlbar_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2qqbar2lStarlbar_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2qqbar2lStarlbar_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2lStarlbar_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2lStarlbar *arg1 = (Pythia8::Sigma2qqbar2lStarlbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2lStarlbar_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2lStarlbar_name" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2lStarlbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2lStarlbar * >(argp1);
  result = ((Pythia8::Sigma2qqbar2lStarlbar const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2lStarlbar_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2lStarlbar *arg1 = (Pythia8::Sigma2qqbar2lStarlbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2lStarlbar_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2lStarlbar_code" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2lStarlbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2lStarlbar * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2lStarlbar const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2lStarlbar_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2lStarlbar *arg1 = (Pythia8::Sigma2qqbar2lStarlbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2lStarlbar_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2lStarlbar_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2lStarlbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2lStarlbar * >(argp1);
  result = ((Pythia8::Sigma2qqbar2lStarlbar const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2lStarlbar_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2lStarlbar *arg1 = (Pythia8::Sigma2qqbar2lStarlbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2lStarlbar_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2lStarlbar_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2lStarlbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2lStarlbar * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2lStarlbar const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2lStarlbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2lStarlbar *arg1 = (Pythia8::Sigma2qqbar2lStarlbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2lStarlbar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlbar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2lStarlbar" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2lStarlbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2lStarlbar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2lStarlbar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlbar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2lStarlStarBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma2qqbar2lStarlStarBar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma2qqbar2lStarlStarBar",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qqbar2lStarlStarBar" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Sigma2qqbar2lStarlStarBar *)new Pythia8::Sigma2qqbar2lStarlStarBar(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlStarBar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2lStarlStarBar_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2lStarlStarBar *arg1 = (Pythia8::Sigma2qqbar2lStarlStarBar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2lStarlStarBar_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlStarBar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2lStarlStarBar_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2lStarlStarBar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2lStarlStarBar * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2lStarlStarBar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2lStarlStarBar *arg1 = (Pythia8::Sigma2qqbar2lStarlStarBar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2lStarlStarBar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlStarBar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2lStarlStarBar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2lStarlStarBar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2lStarlStarBar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2lStarlStarBar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2lStarlStarBar *arg1 = (Pythia8::Sigma2qqbar2lStarlStarBar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2lStarlStarBar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlStarBar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2lStarlStarBar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2lStarlStarBar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2lStarlStarBar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2lStarlStarBar_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2lStarlStarBar *arg1 = (Pythia8::Sigma2qqbar2lStarlStarBar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2lStarlStarBar_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlStarBar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2lStarlStarBar_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2lStarlStarBar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2lStarlStarBar * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2lStarlStarBar_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2lStarlStarBar *arg1 = (Pythia8::Sigma2qqbar2lStarlStarBar *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2qqbar2lStarlStarBar_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlStarBar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2lStarlStarBar_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2lStarlStarBar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2lStarlStarBar * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2qqbar2lStarlStarBar_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2qqbar2lStarlStarBar_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2qqbar2lStarlStarBar_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2qqbar2lStarlStarBar_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2lStarlStarBar_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2lStarlStarBar *arg1 = (Pythia8::Sigma2qqbar2lStarlStarBar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2lStarlStarBar_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlStarBar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2lStarlStarBar_name" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2lStarlStarBar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2lStarlStarBar * >(argp1);
  result = ((Pythia8::Sigma2qqbar2lStarlStarBar const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2lStarlStarBar_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2lStarlStarBar *arg1 = (Pythia8::Sigma2qqbar2lStarlStarBar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2lStarlStarBar_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlStarBar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2lStarlStarBar_code" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2lStarlStarBar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2lStarlStarBar * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2lStarlStarBar const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2lStarlStarBar_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2lStarlStarBar *arg1 = (Pythia8::Sigma2qqbar2lStarlStarBar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2lStarlStarBar_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlStarBar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2lStarlStarBar_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2lStarlStarBar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2lStarlStarBar * >(argp1);
  result = ((Pythia8::Sigma2qqbar2lStarlStarBar const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2lStarlStarBar_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2lStarlStarBar *arg1 = (Pythia8::Sigma2qqbar2lStarlStarBar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2lStarlStarBar_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlStarBar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2lStarlStarBar_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2lStarlStarBar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2lStarlStarBar * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2lStarlStarBar const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2lStarlStarBar_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2lStarlStarBar *arg1 = (Pythia8::Sigma2qqbar2lStarlStarBar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2lStarlStarBar_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlStarBar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2lStarlStarBar_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2lStarlStarBar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2lStarlStarBar * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2lStarlStarBar const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2lStarlStarBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2lStarlStarBar *arg1 = (Pythia8::Sigma2qqbar2lStarlStarBar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2lStarlStarBar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlStarBar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2lStarlStarBar" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2lStarlStarBar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2lStarlStarBar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2lStarlStarBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2lStarlStarBar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2QCqq2qq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCqq2qq *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2QCqq2qq")) SWIG_fail;
  result = (Pythia8::Sigma2QCqq2qq *)new Pythia8::Sigma2QCqq2qq();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2QCqq2qq, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2QCqq2qq_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCqq2qq *arg1 = (Pythia8::Sigma2QCqq2qq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2QCqq2qq_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2QCqq2qq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2QCqq2qq_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2QCqq2qq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2QCqq2qq * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2QCqq2qq_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCqq2qq *arg1 = (Pythia8::Sigma2QCqq2qq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2QCqq2qq_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2QCqq2qq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2QCqq2qq_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2QCqq2qq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2QCqq2qq * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2QCqq2qq_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCqq2qq *arg1 = (Pythia8::Sigma2QCqq2qq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2QCqq2qq_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2QCqq2qq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2QCqq2qq_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2QCqq2qq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2QCqq2qq * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2QCqq2qq_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCqq2qq *arg1 = (Pythia8::Sigma2QCqq2qq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2QCqq2qq_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2QCqq2qq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2QCqq2qq_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2QCqq2qq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2QCqq2qq * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2QCqq2qq_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCqq2qq *arg1 = (Pythia8::Sigma2QCqq2qq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2QCqq2qq_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2QCqq2qq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2QCqq2qq_name" "', argument " "1"" of type '" "Pythia8::Sigma2QCqq2qq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2QCqq2qq * >(argp1);
  result = ((Pythia8::Sigma2QCqq2qq const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2QCqq2qq_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCqq2qq *arg1 = (Pythia8::Sigma2QCqq2qq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2QCqq2qq_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2QCqq2qq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2QCqq2qq_code" "', argument " "1"" of type '" "Pythia8::Sigma2QCqq2qq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2QCqq2qq * >(argp1);
  result = (int)((Pythia8::Sigma2QCqq2qq const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2QCqq2qq_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCqq2qq *arg1 = (Pythia8::Sigma2QCqq2qq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2QCqq2qq_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2QCqq2qq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2QCqq2qq_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2QCqq2qq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2QCqq2qq * >(argp1);
  result = ((Pythia8::Sigma2QCqq2qq const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2QCqq2qq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCqq2qq *arg1 = (Pythia8::Sigma2QCqq2qq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2QCqq2qq",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2QCqq2qq, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2QCqq2qq" "', argument " "1"" of type '" "Pythia8::Sigma2QCqq2qq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2QCqq2qq * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2QCqq2qq_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2QCqq2qq, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2QCqqbar2qqbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCqqbar2qqbar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2QCqqbar2qqbar")) SWIG_fail;
  result = (Pythia8::Sigma2QCqqbar2qqbar *)new Pythia8::Sigma2QCqqbar2qqbar();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2QCqqbar2qqbar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2QCqqbar2qqbar_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCqqbar2qqbar *arg1 = (Pythia8::Sigma2QCqqbar2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2QCqqbar2qqbar_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2QCqqbar2qqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2QCqqbar2qqbar_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2QCqqbar2qqbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2QCqqbar2qqbar * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2QCqqbar2qqbar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCqqbar2qqbar *arg1 = (Pythia8::Sigma2QCqqbar2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2QCqqbar2qqbar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2QCqqbar2qqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2QCqqbar2qqbar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2QCqqbar2qqbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2QCqqbar2qqbar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2QCqqbar2qqbar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCqqbar2qqbar *arg1 = (Pythia8::Sigma2QCqqbar2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2QCqqbar2qqbar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2QCqqbar2qqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2QCqqbar2qqbar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2QCqqbar2qqbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2QCqqbar2qqbar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2QCqqbar2qqbar_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCqqbar2qqbar *arg1 = (Pythia8::Sigma2QCqqbar2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2QCqqbar2qqbar_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2QCqqbar2qqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2QCqqbar2qqbar_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2QCqqbar2qqbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2QCqqbar2qqbar * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2QCqqbar2qqbar_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCqqbar2qqbar *arg1 = (Pythia8::Sigma2QCqqbar2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2QCqqbar2qqbar_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2QCqqbar2qqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2QCqqbar2qqbar_name" "', argument " "1"" of type '" "Pythia8::Sigma2QCqqbar2qqbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2QCqqbar2qqbar * >(argp1);
  result = ((Pythia8::Sigma2QCqqbar2qqbar const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2QCqqbar2qqbar_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCqqbar2qqbar *arg1 = (Pythia8::Sigma2QCqqbar2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2QCqqbar2qqbar_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2QCqqbar2qqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2QCqqbar2qqbar_code" "', argument " "1"" of type '" "Pythia8::Sigma2QCqqbar2qqbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2QCqqbar2qqbar * >(argp1);
  result = (int)((Pythia8::Sigma2QCqqbar2qqbar const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2QCqqbar2qqbar_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCqqbar2qqbar *arg1 = (Pythia8::Sigma2QCqqbar2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2QCqqbar2qqbar_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2QCqqbar2qqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2QCqqbar2qqbar_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2QCqqbar2qqbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2QCqqbar2qqbar * >(argp1);
  result = ((Pythia8::Sigma2QCqqbar2qqbar const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2QCqqbar2qqbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCqqbar2qqbar *arg1 = (Pythia8::Sigma2QCqqbar2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2QCqqbar2qqbar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2QCqqbar2qqbar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2QCqqbar2qqbar" "', argument " "1"" of type '" "Pythia8::Sigma2QCqqbar2qqbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2QCqqbar2qqbar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2QCqqbar2qqbar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2QCqqbar2qqbar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2QCffbar2llbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Sigma2QCffbar2llbar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Sigma2QCffbar2llbar",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2QCffbar2llbar" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2QCffbar2llbar" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::Sigma2QCffbar2llbar *)new Pythia8::Sigma2QCffbar2llbar(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2QCffbar2llbar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2QCffbar2llbar_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCffbar2llbar *arg1 = (Pythia8::Sigma2QCffbar2llbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2QCffbar2llbar_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2QCffbar2llbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2QCffbar2llbar_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2QCffbar2llbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2QCffbar2llbar * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2QCffbar2llbar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCffbar2llbar *arg1 = (Pythia8::Sigma2QCffbar2llbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2QCffbar2llbar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2QCffbar2llbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2QCffbar2llbar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2QCffbar2llbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2QCffbar2llbar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2QCffbar2llbar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCffbar2llbar *arg1 = (Pythia8::Sigma2QCffbar2llbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2QCffbar2llbar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2QCffbar2llbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2QCffbar2llbar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2QCffbar2llbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2QCffbar2llbar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2QCffbar2llbar_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCffbar2llbar *arg1 = (Pythia8::Sigma2QCffbar2llbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2QCffbar2llbar_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2QCffbar2llbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2QCffbar2llbar_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2QCffbar2llbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2QCffbar2llbar * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2QCffbar2llbar_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCffbar2llbar *arg1 = (Pythia8::Sigma2QCffbar2llbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2QCffbar2llbar_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2QCffbar2llbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2QCffbar2llbar_name" "', argument " "1"" of type '" "Pythia8::Sigma2QCffbar2llbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2QCffbar2llbar * >(argp1);
  result = ((Pythia8::Sigma2QCffbar2llbar const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2QCffbar2llbar_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCffbar2llbar *arg1 = (Pythia8::Sigma2QCffbar2llbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2QCffbar2llbar_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2QCffbar2llbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2QCffbar2llbar_code" "', argument " "1"" of type '" "Pythia8::Sigma2QCffbar2llbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2QCffbar2llbar * >(argp1);
  result = (int)((Pythia8::Sigma2QCffbar2llbar const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2QCffbar2llbar_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCffbar2llbar *arg1 = (Pythia8::Sigma2QCffbar2llbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2QCffbar2llbar_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2QCffbar2llbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2QCffbar2llbar_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2QCffbar2llbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2QCffbar2llbar * >(argp1);
  result = ((Pythia8::Sigma2QCffbar2llbar const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2QCffbar2llbar_isSChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCffbar2llbar *arg1 = (Pythia8::Sigma2QCffbar2llbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2QCffbar2llbar_isSChannel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2QCffbar2llbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2QCffbar2llbar_isSChannel" "', argument " "1"" of type '" "Pythia8::Sigma2QCffbar2llbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2QCffbar2llbar * >(argp1);
  result = (bool)((Pythia8::Sigma2QCffbar2llbar const *)arg1)->isSChannel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2QCffbar2llbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2QCffbar2llbar *arg1 = (Pythia8::Sigma2QCffbar2llbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2QCffbar2llbar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2QCffbar2llbar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2QCffbar2llbar" "', argument " "1"" of type '" "Pythia8::Sigma2QCffbar2llbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2QCffbar2llbar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2QCffbar2llbar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2QCffbar2llbar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma1ffbar2Zp2XX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Zp2XX *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma1ffbar2Zp2XX")) SWIG_fail;
  result = (Pythia8::Sigma1ffbar2Zp2XX *)new Pythia8::Sigma1ffbar2Zp2XX();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma1ffbar2Zp2XX, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Zp2XX_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Zp2XX *arg1 = (Pythia8::Sigma1ffbar2Zp2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Zp2XX_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Zp2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Zp2XX_initProc" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Zp2XX *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Zp2XX * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Zp2XX_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Zp2XX *arg1 = (Pythia8::Sigma1ffbar2Zp2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Zp2XX_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Zp2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Zp2XX_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Zp2XX *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Zp2XX * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Zp2XX_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Zp2XX *arg1 = (Pythia8::Sigma1ffbar2Zp2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Zp2XX_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Zp2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Zp2XX_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Zp2XX *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Zp2XX * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Zp2XX_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Zp2XX *arg1 = (Pythia8::Sigma1ffbar2Zp2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Zp2XX_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Zp2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Zp2XX_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Zp2XX *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Zp2XX * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Zp2XX_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Zp2XX *arg1 = (Pythia8::Sigma1ffbar2Zp2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Zp2XX_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Zp2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Zp2XX_name" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Zp2XX const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Zp2XX * >(argp1);
  result = ((Pythia8::Sigma1ffbar2Zp2XX const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Zp2XX_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Zp2XX *arg1 = (Pythia8::Sigma1ffbar2Zp2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Zp2XX_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Zp2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Zp2XX_code" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Zp2XX const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Zp2XX * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2Zp2XX const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Zp2XX_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Zp2XX *arg1 = (Pythia8::Sigma1ffbar2Zp2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Zp2XX_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Zp2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Zp2XX_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Zp2XX const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Zp2XX * >(argp1);
  result = ((Pythia8::Sigma1ffbar2Zp2XX const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Zp2XX_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Zp2XX *arg1 = (Pythia8::Sigma1ffbar2Zp2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Zp2XX_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Zp2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Zp2XX_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Zp2XX const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Zp2XX * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2Zp2XX const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Zp2XX_isSChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Zp2XX *arg1 = (Pythia8::Sigma1ffbar2Zp2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Zp2XX_isSChannel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Zp2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Zp2XX_isSChannel" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Zp2XX const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Zp2XX * >(argp1);
  result = (bool)((Pythia8::Sigma1ffbar2Zp2XX const *)arg1)->isSChannel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Zp2XX_gmZmode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Zp2XX *arg1 = (Pythia8::Sigma1ffbar2Zp2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Zp2XX_gmZmode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Zp2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Zp2XX_gmZmode" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Zp2XX const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Zp2XX * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2Zp2XX const *)arg1)->gmZmode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma1ffbar2Zp2XX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Zp2XX *arg1 = (Pythia8::Sigma1ffbar2Zp2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma1ffbar2Zp2XX",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Zp2XX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma1ffbar2Zp2XX" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Zp2XX *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Zp2XX * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma1ffbar2Zp2XX_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma1ffbar2Zp2XX, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2Zpg2XXj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Zpg2XXj *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qqbar2Zpg2XXj")) SWIG_fail;
  result = (Pythia8::Sigma2qqbar2Zpg2XXj *)new Pythia8::Sigma2qqbar2Zpg2XXj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2Zpg2XXj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Zpg2XXj_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Zpg2XXj *arg1 = (Pythia8::Sigma2qqbar2Zpg2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Zpg2XXj_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Zpg2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Zpg2XXj_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Zpg2XXj *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Zpg2XXj * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Zpg2XXj_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Zpg2XXj *arg1 = (Pythia8::Sigma2qqbar2Zpg2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Zpg2XXj_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Zpg2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Zpg2XXj_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Zpg2XXj *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Zpg2XXj * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Zpg2XXj_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Zpg2XXj *arg1 = (Pythia8::Sigma2qqbar2Zpg2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Zpg2XXj_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Zpg2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Zpg2XXj_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Zpg2XXj *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Zpg2XXj * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Zpg2XXj_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Zpg2XXj *arg1 = (Pythia8::Sigma2qqbar2Zpg2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Zpg2XXj_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Zpg2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Zpg2XXj_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Zpg2XXj *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Zpg2XXj * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Zpg2XXj_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Zpg2XXj *arg1 = (Pythia8::Sigma2qqbar2Zpg2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Zpg2XXj_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Zpg2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Zpg2XXj_name" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Zpg2XXj const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Zpg2XXj * >(argp1);
  result = ((Pythia8::Sigma2qqbar2Zpg2XXj const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Zpg2XXj_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Zpg2XXj *arg1 = (Pythia8::Sigma2qqbar2Zpg2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Zpg2XXj_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Zpg2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Zpg2XXj_code" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Zpg2XXj const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Zpg2XXj * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2Zpg2XXj const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Zpg2XXj_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Zpg2XXj *arg1 = (Pythia8::Sigma2qqbar2Zpg2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Zpg2XXj_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Zpg2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Zpg2XXj_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Zpg2XXj const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Zpg2XXj * >(argp1);
  result = ((Pythia8::Sigma2qqbar2Zpg2XXj const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Zpg2XXj_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Zpg2XXj *arg1 = (Pythia8::Sigma2qqbar2Zpg2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Zpg2XXj_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Zpg2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Zpg2XXj_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Zpg2XXj const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Zpg2XXj * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2Zpg2XXj const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Zpg2XXj_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Zpg2XXj *arg1 = (Pythia8::Sigma2qqbar2Zpg2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Zpg2XXj_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Zpg2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Zpg2XXj_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Zpg2XXj const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Zpg2XXj * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2Zpg2XXj const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Zpg2XXj_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Zpg2XXj *arg1 = (Pythia8::Sigma2qqbar2Zpg2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Zpg2XXj_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Zpg2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Zpg2XXj_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Zpg2XXj const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Zpg2XXj * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2Zpg2XXj const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Zpg2XXj_isSChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Zpg2XXj *arg1 = (Pythia8::Sigma2qqbar2Zpg2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Zpg2XXj_isSChannel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Zpg2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Zpg2XXj_isSChannel" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Zpg2XXj const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Zpg2XXj * >(argp1);
  result = (bool)((Pythia8::Sigma2qqbar2Zpg2XXj const *)arg1)->isSChannel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Zpg2XXj_gmZmode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Zpg2XXj *arg1 = (Pythia8::Sigma2qqbar2Zpg2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Zpg2XXj_gmZmode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Zpg2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Zpg2XXj_gmZmode" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Zpg2XXj const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Zpg2XXj * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2Zpg2XXj const *)arg1)->gmZmode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2Zpg2XXj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Zpg2XXj *arg1 = (Pythia8::Sigma2qqbar2Zpg2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2Zpg2XXj",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Zpg2XXj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2Zpg2XXj" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Zpg2XXj *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Zpg2XXj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2Zpg2XXj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2Zpg2XXj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_Sigma2qg2Zpq2XXj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Zpq2XXj *arg1 = (Pythia8::Sigma2qg2Zpq2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qg2Zpq2XXj",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Zpq2XXj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qg2Zpq2XXj" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Zpq2XXj *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Zpq2XXj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qg2Zpq2XXj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qg2Zpq2XXj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2ZpH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZpH *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2ffbar2ZpH")) SWIG_fail;
  result = (Pythia8::Sigma2ffbar2ZpH *)new Pythia8::Sigma2ffbar2ZpH();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbar2ZpH, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ZpH_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZpH *arg1 = (Pythia8::Sigma2ffbar2ZpH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ZpH_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ZpH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ZpH_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ZpH *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ZpH * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ZpH_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZpH *arg1 = (Pythia8::Sigma2ffbar2ZpH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ZpH_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ZpH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ZpH_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ZpH *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ZpH * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ZpH_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZpH *arg1 = (Pythia8::Sigma2ffbar2ZpH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ZpH_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ZpH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ZpH_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ZpH *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ZpH * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ZpH_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZpH *arg1 = (Pythia8::Sigma2ffbar2ZpH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ZpH_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ZpH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ZpH_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ZpH *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ZpH * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ZpH_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZpH *arg1 = (Pythia8::Sigma2ffbar2ZpH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ZpH_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ZpH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ZpH_name" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ZpH const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ZpH * >(argp1);
  result = ((Pythia8::Sigma2ffbar2ZpH const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ZpH_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZpH *arg1 = (Pythia8::Sigma2ffbar2ZpH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ZpH_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ZpH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ZpH_code" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ZpH const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ZpH * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2ZpH const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ZpH_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZpH *arg1 = (Pythia8::Sigma2ffbar2ZpH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ZpH_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ZpH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ZpH_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ZpH const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ZpH * >(argp1);
  result = ((Pythia8::Sigma2ffbar2ZpH const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ZpH_isSChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZpH *arg1 = (Pythia8::Sigma2ffbar2ZpH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ZpH_isSChannel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ZpH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ZpH_isSChannel" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ZpH const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ZpH * >(argp1);
  result = (bool)((Pythia8::Sigma2ffbar2ZpH const *)arg1)->isSChannel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ZpH_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZpH *arg1 = (Pythia8::Sigma2ffbar2ZpH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ZpH_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ZpH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ZpH_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ZpH const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ZpH * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2ZpH const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ZpH_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZpH *arg1 = (Pythia8::Sigma2ffbar2ZpH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ZpH_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ZpH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ZpH_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ZpH const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ZpH * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2ZpH const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ZpH_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZpH *arg1 = (Pythia8::Sigma2ffbar2ZpH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ZpH_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ZpH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ZpH_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ZpH const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ZpH * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2ZpH const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ZpH_gmZmode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZpH *arg1 = (Pythia8::Sigma2ffbar2ZpH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ZpH_gmZmode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ZpH, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ZpH_gmZmode" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ZpH const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ZpH * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2ZpH const *)arg1)->gmZmode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbar2ZpH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZpH *arg1 = (Pythia8::Sigma2ffbar2ZpH *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbar2ZpH",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ZpH, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbar2ZpH" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ZpH *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ZpH * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbar2ZpH_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbar2ZpH, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma1gg2S2XX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2S2XX *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma1gg2S2XX")) SWIG_fail;
  result = (Pythia8::Sigma1gg2S2XX *)new Pythia8::Sigma1gg2S2XX();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma1gg2S2XX, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2S2XX_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2S2XX *arg1 = (Pythia8::Sigma1gg2S2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gg2S2XX_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2S2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2S2XX_initProc" "', argument " "1"" of type '" "Pythia8::Sigma1gg2S2XX *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2S2XX * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2S2XX_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2S2XX *arg1 = (Pythia8::Sigma1gg2S2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gg2S2XX_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2S2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2S2XX_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma1gg2S2XX *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2S2XX * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2S2XX_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2S2XX *arg1 = (Pythia8::Sigma1gg2S2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gg2S2XX_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2S2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2S2XX_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma1gg2S2XX *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2S2XX * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2S2XX_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2S2XX *arg1 = (Pythia8::Sigma1gg2S2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gg2S2XX_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2S2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2S2XX_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma1gg2S2XX *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2S2XX * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2S2XX_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2S2XX *arg1 = (Pythia8::Sigma1gg2S2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gg2S2XX_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2S2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2S2XX_name" "', argument " "1"" of type '" "Pythia8::Sigma1gg2S2XX const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2S2XX * >(argp1);
  result = ((Pythia8::Sigma1gg2S2XX const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2S2XX_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2S2XX *arg1 = (Pythia8::Sigma1gg2S2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gg2S2XX_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2S2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2S2XX_code" "', argument " "1"" of type '" "Pythia8::Sigma1gg2S2XX const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2S2XX * >(argp1);
  result = (int)((Pythia8::Sigma1gg2S2XX const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2S2XX_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2S2XX *arg1 = (Pythia8::Sigma1gg2S2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gg2S2XX_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2S2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2S2XX_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma1gg2S2XX const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2S2XX * >(argp1);
  result = ((Pythia8::Sigma1gg2S2XX const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2S2XX_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2S2XX *arg1 = (Pythia8::Sigma1gg2S2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gg2S2XX_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2S2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2S2XX_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma1gg2S2XX const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2S2XX * >(argp1);
  result = (int)((Pythia8::Sigma1gg2S2XX const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2S2XX_isSChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2S2XX *arg1 = (Pythia8::Sigma1gg2S2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gg2S2XX_isSChannel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2S2XX, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2S2XX_isSChannel" "', argument " "1"" of type '" "Pythia8::Sigma1gg2S2XX const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2S2XX * >(argp1);
  result = (bool)((Pythia8::Sigma1gg2S2XX const *)arg1)->isSChannel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma1gg2S2XX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2S2XX *arg1 = (Pythia8::Sigma1gg2S2XX *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma1gg2S2XX",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2S2XX, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma1gg2S2XX" "', argument " "1"" of type '" "Pythia8::Sigma1gg2S2XX *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2S2XX * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma1gg2S2XX_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma1gg2S2XX, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2gg2Sg2XXj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2Sg2XXj *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2gg2Sg2XXj")) SWIG_fail;
  result = (Pythia8::Sigma2gg2Sg2XXj *)new Pythia8::Sigma2gg2Sg2XXj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gg2Sg2XXj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2Sg2XXj_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2Sg2XXj *arg1 = (Pythia8::Sigma2gg2Sg2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2Sg2XXj_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2Sg2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2Sg2XXj_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2gg2Sg2XXj *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2Sg2XXj * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2Sg2XXj_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2Sg2XXj *arg1 = (Pythia8::Sigma2gg2Sg2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2Sg2XXj_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2Sg2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2Sg2XXj_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2gg2Sg2XXj *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2Sg2XXj * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2Sg2XXj_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2Sg2XXj *arg1 = (Pythia8::Sigma2gg2Sg2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2Sg2XXj_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2Sg2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2Sg2XXj_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2gg2Sg2XXj *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2Sg2XXj * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2Sg2XXj_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2Sg2XXj *arg1 = (Pythia8::Sigma2gg2Sg2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2Sg2XXj_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2Sg2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2Sg2XXj_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2gg2Sg2XXj *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2Sg2XXj * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2Sg2XXj_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2Sg2XXj *arg1 = (Pythia8::Sigma2gg2Sg2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2Sg2XXj_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2Sg2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2Sg2XXj_name" "', argument " "1"" of type '" "Pythia8::Sigma2gg2Sg2XXj const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2Sg2XXj * >(argp1);
  result = ((Pythia8::Sigma2gg2Sg2XXj const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2Sg2XXj_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2Sg2XXj *arg1 = (Pythia8::Sigma2gg2Sg2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2Sg2XXj_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2Sg2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2Sg2XXj_code" "', argument " "1"" of type '" "Pythia8::Sigma2gg2Sg2XXj const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2Sg2XXj * >(argp1);
  result = (int)((Pythia8::Sigma2gg2Sg2XXj const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2Sg2XXj_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2Sg2XXj *arg1 = (Pythia8::Sigma2gg2Sg2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2Sg2XXj_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2Sg2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2Sg2XXj_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2gg2Sg2XXj const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2Sg2XXj * >(argp1);
  result = ((Pythia8::Sigma2gg2Sg2XXj const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2Sg2XXj_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2Sg2XXj *arg1 = (Pythia8::Sigma2gg2Sg2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2Sg2XXj_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2Sg2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2Sg2XXj_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma2gg2Sg2XXj const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2Sg2XXj * >(argp1);
  result = (int)((Pythia8::Sigma2gg2Sg2XXj const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2Sg2XXj_isSChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2Sg2XXj *arg1 = (Pythia8::Sigma2gg2Sg2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2Sg2XXj_isSChannel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2Sg2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2Sg2XXj_isSChannel" "', argument " "1"" of type '" "Pythia8::Sigma2gg2Sg2XXj const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2Sg2XXj * >(argp1);
  result = (bool)((Pythia8::Sigma2gg2Sg2XXj const *)arg1)->isSChannel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2Sg2XXj_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2Sg2XXj *arg1 = (Pythia8::Sigma2gg2Sg2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2Sg2XXj_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2Sg2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2Sg2XXj_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2gg2Sg2XXj const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2Sg2XXj * >(argp1);
  result = (int)((Pythia8::Sigma2gg2Sg2XXj const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2Sg2XXj_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2Sg2XXj *arg1 = (Pythia8::Sigma2gg2Sg2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2Sg2XXj_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2Sg2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2Sg2XXj_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2gg2Sg2XXj const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2Sg2XXj * >(argp1);
  result = (int)((Pythia8::Sigma2gg2Sg2XXj const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2gg2Sg2XXj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2Sg2XXj *arg1 = (Pythia8::Sigma2gg2Sg2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2gg2Sg2XXj",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2Sg2XXj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2gg2Sg2XXj" "', argument " "1"" of type '" "Pythia8::Sigma2gg2Sg2XXj *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2Sg2XXj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2gg2Sg2XXj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2gg2Sg2XXj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qg2Sq2XXj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Sq2XXj *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qg2Sq2XXj")) SWIG_fail;
  result = (Pythia8::Sigma2qg2Sq2XXj *)new Pythia8::Sigma2qg2Sq2XXj();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qg2Sq2XXj, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Sq2XXj_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Sq2XXj *arg1 = (Pythia8::Sigma2qg2Sq2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Sq2XXj_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Sq2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Sq2XXj_name" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Sq2XXj const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Sq2XXj * >(argp1);
  result = ((Pythia8::Sigma2qg2Sq2XXj const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Sq2XXj_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Sq2XXj *arg1 = (Pythia8::Sigma2qg2Sq2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Sq2XXj_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Sq2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Sq2XXj_code" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Sq2XXj const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Sq2XXj * >(argp1);
  result = (int)((Pythia8::Sigma2qg2Sq2XXj const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Sq2XXj_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Sq2XXj *arg1 = (Pythia8::Sigma2qg2Sq2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Sq2XXj_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Sq2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Sq2XXj_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Sq2XXj const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Sq2XXj * >(argp1);
  result = ((Pythia8::Sigma2qg2Sq2XXj const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Sq2XXj_isSChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Sq2XXj *arg1 = (Pythia8::Sigma2qg2Sq2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Sq2XXj_isSChannel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Sq2XXj, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Sq2XXj_isSChannel" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Sq2XXj const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Sq2XXj * >(argp1);
  result = (bool)((Pythia8::Sigma2qg2Sq2XXj const *)arg1)->isSChannel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qg2Sq2XXj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Sq2XXj *arg1 = (Pythia8::Sigma2qg2Sq2XXj *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qg2Sq2XXj",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Sq2XXj, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qg2Sq2XXj" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Sq2XXj *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Sq2XXj * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qg2Sq2XXj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qg2Sq2XXj, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qg2qgamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2qgamma *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qg2qgamma")) SWIG_fail;
  result = (Pythia8::Sigma2qg2qgamma *)new Pythia8::Sigma2qg2qgamma();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qg2qgamma, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2qgamma_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2qgamma *arg1 = (Pythia8::Sigma2qg2qgamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2qgamma_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2qgamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2qgamma_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qg2qgamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2qgamma * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2qgamma_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2qgamma *arg1 = (Pythia8::Sigma2qg2qgamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2qgamma_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2qgamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2qgamma_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qg2qgamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2qgamma * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2qgamma_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2qgamma *arg1 = (Pythia8::Sigma2qg2qgamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2qgamma_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2qgamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2qgamma_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qg2qgamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2qgamma * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2qgamma_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2qgamma *arg1 = (Pythia8::Sigma2qg2qgamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2qgamma_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2qgamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2qgamma_name" "', argument " "1"" of type '" "Pythia8::Sigma2qg2qgamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2qgamma * >(argp1);
  result = ((Pythia8::Sigma2qg2qgamma const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2qgamma_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2qgamma *arg1 = (Pythia8::Sigma2qg2qgamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2qgamma_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2qgamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2qgamma_code" "', argument " "1"" of type '" "Pythia8::Sigma2qg2qgamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2qgamma * >(argp1);
  result = (int)((Pythia8::Sigma2qg2qgamma const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2qgamma_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2qgamma *arg1 = (Pythia8::Sigma2qg2qgamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2qgamma_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2qgamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2qgamma_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qg2qgamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2qgamma * >(argp1);
  result = ((Pythia8::Sigma2qg2qgamma const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qg2qgamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2qgamma *arg1 = (Pythia8::Sigma2qg2qgamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qg2qgamma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2qgamma, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qg2qgamma" "', argument " "1"" of type '" "Pythia8::Sigma2qg2qgamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2qgamma * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qg2qgamma_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qg2qgamma, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2ggamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2ggamma *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qqbar2ggamma")) SWIG_fail;
  result = (Pythia8::Sigma2qqbar2ggamma *)new Pythia8::Sigma2qqbar2ggamma();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2ggamma, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2ggamma_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2ggamma *arg1 = (Pythia8::Sigma2qqbar2ggamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2ggamma_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2ggamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2ggamma_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2ggamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2ggamma * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2ggamma_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2ggamma *arg1 = (Pythia8::Sigma2qqbar2ggamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2ggamma_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2ggamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2ggamma_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2ggamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2ggamma * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2ggamma_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2ggamma *arg1 = (Pythia8::Sigma2qqbar2ggamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2ggamma_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2ggamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2ggamma_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2ggamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2ggamma * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2ggamma_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2ggamma *arg1 = (Pythia8::Sigma2qqbar2ggamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2ggamma_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2ggamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2ggamma_name" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2ggamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2ggamma * >(argp1);
  result = ((Pythia8::Sigma2qqbar2ggamma const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2ggamma_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2ggamma *arg1 = (Pythia8::Sigma2qqbar2ggamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2ggamma_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2ggamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2ggamma_code" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2ggamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2ggamma * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2ggamma const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2ggamma_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2ggamma *arg1 = (Pythia8::Sigma2qqbar2ggamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2ggamma_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2ggamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2ggamma_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2ggamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2ggamma * >(argp1);
  result = ((Pythia8::Sigma2qqbar2ggamma const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2ggamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2ggamma *arg1 = (Pythia8::Sigma2qqbar2ggamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2ggamma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2ggamma, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2ggamma" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2ggamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2ggamma * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2ggamma_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2ggamma, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2gg2ggamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2ggamma *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2gg2ggamma")) SWIG_fail;
  result = (Pythia8::Sigma2gg2ggamma *)new Pythia8::Sigma2gg2ggamma();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gg2ggamma, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2ggamma_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2ggamma *arg1 = (Pythia8::Sigma2gg2ggamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2ggamma_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2ggamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2ggamma_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2gg2ggamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2ggamma * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2ggamma_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2ggamma *arg1 = (Pythia8::Sigma2gg2ggamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2ggamma_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2ggamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2ggamma_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2gg2ggamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2ggamma * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2ggamma_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2ggamma *arg1 = (Pythia8::Sigma2gg2ggamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2ggamma_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2ggamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2ggamma_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2gg2ggamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2ggamma * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2ggamma_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2ggamma *arg1 = (Pythia8::Sigma2gg2ggamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2ggamma_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2ggamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2ggamma_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2gg2ggamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2ggamma * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2ggamma_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2ggamma *arg1 = (Pythia8::Sigma2gg2ggamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2ggamma_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2ggamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2ggamma_name" "', argument " "1"" of type '" "Pythia8::Sigma2gg2ggamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2ggamma * >(argp1);
  result = ((Pythia8::Sigma2gg2ggamma const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2ggamma_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2ggamma *arg1 = (Pythia8::Sigma2gg2ggamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2ggamma_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2ggamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2ggamma_code" "', argument " "1"" of type '" "Pythia8::Sigma2gg2ggamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2ggamma * >(argp1);
  result = (int)((Pythia8::Sigma2gg2ggamma const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2ggamma_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2ggamma *arg1 = (Pythia8::Sigma2gg2ggamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2ggamma_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2ggamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2ggamma_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2gg2ggamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2ggamma * >(argp1);
  result = ((Pythia8::Sigma2gg2ggamma const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2gg2ggamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2ggamma *arg1 = (Pythia8::Sigma2gg2ggamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2gg2ggamma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2ggamma, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2gg2ggamma" "', argument " "1"" of type '" "Pythia8::Sigma2gg2ggamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2ggamma * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2gg2ggamma_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2gg2ggamma, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2gammagamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gammagamma *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2ffbar2gammagamma")) SWIG_fail;
  result = (Pythia8::Sigma2ffbar2gammagamma *)new Pythia8::Sigma2ffbar2gammagamma();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbar2gammagamma, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2gammagamma_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gammagamma *arg1 = (Pythia8::Sigma2ffbar2gammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2gammagamma_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2gammagamma_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gammagamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gammagamma * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2gammagamma_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gammagamma *arg1 = (Pythia8::Sigma2ffbar2gammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2gammagamma_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2gammagamma_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gammagamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gammagamma * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2gammagamma_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gammagamma *arg1 = (Pythia8::Sigma2ffbar2gammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2gammagamma_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2gammagamma_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gammagamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gammagamma * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2gammagamma_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gammagamma *arg1 = (Pythia8::Sigma2ffbar2gammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2gammagamma_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2gammagamma_name" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gammagamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gammagamma * >(argp1);
  result = ((Pythia8::Sigma2ffbar2gammagamma const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2gammagamma_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gammagamma *arg1 = (Pythia8::Sigma2ffbar2gammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2gammagamma_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2gammagamma_code" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gammagamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gammagamma * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2gammagamma const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2gammagamma_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gammagamma *arg1 = (Pythia8::Sigma2ffbar2gammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2gammagamma_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2gammagamma_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gammagamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gammagamma * >(argp1);
  result = ((Pythia8::Sigma2ffbar2gammagamma const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbar2gammagamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gammagamma *arg1 = (Pythia8::Sigma2ffbar2gammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbar2gammagamma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gammagamma, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbar2gammagamma" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gammagamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gammagamma * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbar2gammagamma_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbar2gammagamma, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2gg2gammagamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gammagamma *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2gg2gammagamma")) SWIG_fail;
  result = (Pythia8::Sigma2gg2gammagamma *)new Pythia8::Sigma2gg2gammagamma();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gg2gammagamma, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2gammagamma_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gammagamma *arg1 = (Pythia8::Sigma2gg2gammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2gammagamma_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2gammagamma_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gammagamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gammagamma * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2gammagamma_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gammagamma *arg1 = (Pythia8::Sigma2gg2gammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2gammagamma_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2gammagamma_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gammagamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gammagamma * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2gammagamma_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gammagamma *arg1 = (Pythia8::Sigma2gg2gammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2gammagamma_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2gammagamma_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gammagamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gammagamma * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2gammagamma_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gammagamma *arg1 = (Pythia8::Sigma2gg2gammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2gammagamma_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2gammagamma_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gammagamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gammagamma * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2gammagamma_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gammagamma *arg1 = (Pythia8::Sigma2gg2gammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2gammagamma_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2gammagamma_name" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gammagamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gammagamma * >(argp1);
  result = ((Pythia8::Sigma2gg2gammagamma const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2gammagamma_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gammagamma *arg1 = (Pythia8::Sigma2gg2gammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2gammagamma_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2gammagamma_code" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gammagamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gammagamma * >(argp1);
  result = (int)((Pythia8::Sigma2gg2gammagamma const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2gammagamma_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gammagamma *arg1 = (Pythia8::Sigma2gg2gammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2gammagamma_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2gammagamma_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gammagamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gammagamma * >(argp1);
  result = ((Pythia8::Sigma2gg2gammagamma const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2gg2gammagamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gammagamma *arg1 = (Pythia8::Sigma2gg2gammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2gg2gammagamma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gammagamma, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2gg2gammagamma" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gammagamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gammagamma * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2gg2gammagamma_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2gg2gammagamma, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ff2fftgmZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ff2fftgmZ *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2ff2fftgmZ")) SWIG_fail;
  result = (Pythia8::Sigma2ff2fftgmZ *)new Pythia8::Sigma2ff2fftgmZ();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ff2fftgmZ, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ff2fftgmZ_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ff2fftgmZ *arg1 = (Pythia8::Sigma2ff2fftgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ff2fftgmZ_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ff2fftgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ff2fftgmZ_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2ff2fftgmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ff2fftgmZ * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ff2fftgmZ_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ff2fftgmZ *arg1 = (Pythia8::Sigma2ff2fftgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ff2fftgmZ_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ff2fftgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ff2fftgmZ_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ff2fftgmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ff2fftgmZ * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ff2fftgmZ_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ff2fftgmZ *arg1 = (Pythia8::Sigma2ff2fftgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ff2fftgmZ_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ff2fftgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ff2fftgmZ_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ff2fftgmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ff2fftgmZ * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ff2fftgmZ_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ff2fftgmZ *arg1 = (Pythia8::Sigma2ff2fftgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ff2fftgmZ_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ff2fftgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ff2fftgmZ_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ff2fftgmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ff2fftgmZ * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ff2fftgmZ_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ff2fftgmZ *arg1 = (Pythia8::Sigma2ff2fftgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ff2fftgmZ_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ff2fftgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ff2fftgmZ_name" "', argument " "1"" of type '" "Pythia8::Sigma2ff2fftgmZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ff2fftgmZ * >(argp1);
  result = ((Pythia8::Sigma2ff2fftgmZ const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ff2fftgmZ_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ff2fftgmZ *arg1 = (Pythia8::Sigma2ff2fftgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ff2fftgmZ_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ff2fftgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ff2fftgmZ_code" "', argument " "1"" of type '" "Pythia8::Sigma2ff2fftgmZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ff2fftgmZ * >(argp1);
  result = (int)((Pythia8::Sigma2ff2fftgmZ const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ff2fftgmZ_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ff2fftgmZ *arg1 = (Pythia8::Sigma2ff2fftgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ff2fftgmZ_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ff2fftgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ff2fftgmZ_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ff2fftgmZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ff2fftgmZ * >(argp1);
  result = ((Pythia8::Sigma2ff2fftgmZ const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ff2fftgmZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ff2fftgmZ *arg1 = (Pythia8::Sigma2ff2fftgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ff2fftgmZ",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ff2fftgmZ, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ff2fftgmZ" "', argument " "1"" of type '" "Pythia8::Sigma2ff2fftgmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ff2fftgmZ * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ff2fftgmZ_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ff2fftgmZ, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ff2fftW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ff2fftW *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2ff2fftW")) SWIG_fail;
  result = (Pythia8::Sigma2ff2fftW *)new Pythia8::Sigma2ff2fftW();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ff2fftW, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ff2fftW_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ff2fftW *arg1 = (Pythia8::Sigma2ff2fftW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ff2fftW_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ff2fftW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ff2fftW_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2ff2fftW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ff2fftW * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ff2fftW_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ff2fftW *arg1 = (Pythia8::Sigma2ff2fftW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ff2fftW_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ff2fftW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ff2fftW_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ff2fftW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ff2fftW * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ff2fftW_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ff2fftW *arg1 = (Pythia8::Sigma2ff2fftW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ff2fftW_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ff2fftW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ff2fftW_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ff2fftW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ff2fftW * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ff2fftW_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ff2fftW *arg1 = (Pythia8::Sigma2ff2fftW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ff2fftW_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ff2fftW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ff2fftW_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ff2fftW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ff2fftW * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ff2fftW_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ff2fftW *arg1 = (Pythia8::Sigma2ff2fftW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ff2fftW_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ff2fftW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ff2fftW_name" "', argument " "1"" of type '" "Pythia8::Sigma2ff2fftW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ff2fftW * >(argp1);
  result = ((Pythia8::Sigma2ff2fftW const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ff2fftW_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ff2fftW *arg1 = (Pythia8::Sigma2ff2fftW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ff2fftW_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ff2fftW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ff2fftW_code" "', argument " "1"" of type '" "Pythia8::Sigma2ff2fftW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ff2fftW * >(argp1);
  result = (int)((Pythia8::Sigma2ff2fftW const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ff2fftW_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ff2fftW *arg1 = (Pythia8::Sigma2ff2fftW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ff2fftW_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ff2fftW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ff2fftW_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ff2fftW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ff2fftW * >(argp1);
  result = ((Pythia8::Sigma2ff2fftW const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ff2fftW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ff2fftW *arg1 = (Pythia8::Sigma2ff2fftW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ff2fftW",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ff2fftW, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ff2fftW" "', argument " "1"" of type '" "Pythia8::Sigma2ff2fftW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ff2fftW * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ff2fftW_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ff2fftW, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qq2QqtW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Sigma2qq2QqtW *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Sigma2qq2QqtW",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qq2QqtW" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2qq2QqtW" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::Sigma2qq2QqtW *)new Pythia8::Sigma2qq2QqtW(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qq2QqtW, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2QqtW_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2QqtW *arg1 = (Pythia8::Sigma2qq2QqtW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2QqtW_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2QqtW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2QqtW_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qq2QqtW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2QqtW * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2QqtW_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2QqtW *arg1 = (Pythia8::Sigma2qq2QqtW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2QqtW_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2QqtW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2QqtW_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qq2QqtW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2QqtW * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2QqtW_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2QqtW *arg1 = (Pythia8::Sigma2qq2QqtW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2QqtW_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2QqtW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2QqtW_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qq2QqtW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2QqtW * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2QqtW_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2QqtW *arg1 = (Pythia8::Sigma2qq2QqtW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2QqtW_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2QqtW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2QqtW_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qq2QqtW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2QqtW * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2QqtW_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2QqtW *arg1 = (Pythia8::Sigma2qq2QqtW *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2qq2QqtW_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2QqtW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2QqtW_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2qq2QqtW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2QqtW * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2qq2QqtW_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2qq2QqtW_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2qq2QqtW_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2qq2QqtW_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2QqtW_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2QqtW *arg1 = (Pythia8::Sigma2qq2QqtW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2QqtW_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2QqtW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2QqtW_name" "', argument " "1"" of type '" "Pythia8::Sigma2qq2QqtW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2QqtW * >(argp1);
  result = ((Pythia8::Sigma2qq2QqtW const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2QqtW_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2QqtW *arg1 = (Pythia8::Sigma2qq2QqtW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2QqtW_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2QqtW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2QqtW_code" "', argument " "1"" of type '" "Pythia8::Sigma2qq2QqtW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2QqtW * >(argp1);
  result = (int)((Pythia8::Sigma2qq2QqtW const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2QqtW_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2QqtW *arg1 = (Pythia8::Sigma2qq2QqtW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2QqtW_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2QqtW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2QqtW_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qq2QqtW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2QqtW * >(argp1);
  result = ((Pythia8::Sigma2qq2QqtW const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2QqtW_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2QqtW *arg1 = (Pythia8::Sigma2qq2QqtW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2QqtW_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2QqtW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2QqtW_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qq2QqtW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2QqtW * >(argp1);
  result = (int)((Pythia8::Sigma2qq2QqtW const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qq2QqtW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2QqtW *arg1 = (Pythia8::Sigma2qq2QqtW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qq2QqtW",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2QqtW, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qq2QqtW" "', argument " "1"" of type '" "Pythia8::Sigma2qq2QqtW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2QqtW * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qq2QqtW_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qq2QqtW, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma1ffbar2gmZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2gmZ *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma1ffbar2gmZ")) SWIG_fail;
  result = (Pythia8::Sigma1ffbar2gmZ *)new Pythia8::Sigma1ffbar2gmZ();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZ, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2gmZ_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2gmZ *arg1 = (Pythia8::Sigma1ffbar2gmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2gmZ_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2gmZ_initProc" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2gmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2gmZ * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2gmZ_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2gmZ *arg1 = (Pythia8::Sigma1ffbar2gmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2gmZ_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2gmZ_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2gmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2gmZ * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2gmZ_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2gmZ *arg1 = (Pythia8::Sigma1ffbar2gmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2gmZ_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2gmZ_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2gmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2gmZ * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2gmZ_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2gmZ *arg1 = (Pythia8::Sigma1ffbar2gmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2gmZ_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2gmZ_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2gmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2gmZ * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2gmZ_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2gmZ *arg1 = (Pythia8::Sigma1ffbar2gmZ *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma1ffbar2gmZ_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2gmZ_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2gmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2gmZ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma1ffbar2gmZ_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma1ffbar2gmZ_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma1ffbar2gmZ_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma1ffbar2gmZ_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2gmZ_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2gmZ *arg1 = (Pythia8::Sigma1ffbar2gmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2gmZ_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2gmZ_name" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2gmZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2gmZ * >(argp1);
  result = ((Pythia8::Sigma1ffbar2gmZ const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2gmZ_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2gmZ *arg1 = (Pythia8::Sigma1ffbar2gmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2gmZ_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2gmZ_code" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2gmZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2gmZ * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2gmZ const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2gmZ_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2gmZ *arg1 = (Pythia8::Sigma1ffbar2gmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2gmZ_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2gmZ_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2gmZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2gmZ * >(argp1);
  result = ((Pythia8::Sigma1ffbar2gmZ const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2gmZ_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2gmZ *arg1 = (Pythia8::Sigma1ffbar2gmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2gmZ_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2gmZ_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2gmZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2gmZ * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2gmZ const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma1ffbar2gmZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2gmZ *arg1 = (Pythia8::Sigma1ffbar2gmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma1ffbar2gmZ",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZ, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma1ffbar2gmZ" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2gmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2gmZ * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma1ffbar2gmZ_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZ, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma1ffbar2W(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2W *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma1ffbar2W")) SWIG_fail;
  result = (Pythia8::Sigma1ffbar2W *)new Pythia8::Sigma1ffbar2W();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma1ffbar2W, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2W_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2W *arg1 = (Pythia8::Sigma1ffbar2W *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2W_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2W, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2W_initProc" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2W *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2W * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2W_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2W *arg1 = (Pythia8::Sigma1ffbar2W *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2W_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2W, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2W_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2W *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2W * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2W_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2W *arg1 = (Pythia8::Sigma1ffbar2W *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2W_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2W, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2W_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2W *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2W * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2W_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2W *arg1 = (Pythia8::Sigma1ffbar2W *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2W_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2W, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2W_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2W *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2W * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2W_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2W *arg1 = (Pythia8::Sigma1ffbar2W *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma1ffbar2W_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2W, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2W_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2W *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2W * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma1ffbar2W_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma1ffbar2W_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma1ffbar2W_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma1ffbar2W_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2W_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2W *arg1 = (Pythia8::Sigma1ffbar2W *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2W_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2W, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2W_name" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2W const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2W * >(argp1);
  result = ((Pythia8::Sigma1ffbar2W const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2W_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2W *arg1 = (Pythia8::Sigma1ffbar2W *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2W_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2W, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2W_code" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2W const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2W * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2W const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2W_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2W *arg1 = (Pythia8::Sigma1ffbar2W *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2W_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2W, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2W_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2W const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2W * >(argp1);
  result = ((Pythia8::Sigma1ffbar2W const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2W_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2W *arg1 = (Pythia8::Sigma1ffbar2W *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2W_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2W, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2W_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2W const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2W * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2W const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma1ffbar2W(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2W *arg1 = (Pythia8::Sigma1ffbar2W *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma1ffbar2W",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2W, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma1ffbar2W" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2W *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2W * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma1ffbar2W_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma1ffbar2W, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2ffbarsgm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsgm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2ffbar2ffbarsgm")) SWIG_fail;
  result = (Pythia8::Sigma2ffbar2ffbarsgm *)new Pythia8::Sigma2ffbar2ffbarsgm();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsgm_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsgm *arg1 = (Pythia8::Sigma2ffbar2ffbarsgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsgm_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsgm_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsgm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsgm * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsgm_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsgm *arg1 = (Pythia8::Sigma2ffbar2ffbarsgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsgm_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsgm_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsgm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsgm * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsgm_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsgm *arg1 = (Pythia8::Sigma2ffbar2ffbarsgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsgm_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsgm_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsgm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsgm * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsgm_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsgm *arg1 = (Pythia8::Sigma2ffbar2ffbarsgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsgm_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsgm_name" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsgm const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsgm * >(argp1);
  result = ((Pythia8::Sigma2ffbar2ffbarsgm const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsgm_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsgm *arg1 = (Pythia8::Sigma2ffbar2ffbarsgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsgm_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsgm_code" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsgm const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsgm * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2ffbarsgm const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsgm_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsgm *arg1 = (Pythia8::Sigma2ffbar2ffbarsgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsgm_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsgm_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsgm const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsgm * >(argp1);
  result = ((Pythia8::Sigma2ffbar2ffbarsgm const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsgm_isSChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsgm *arg1 = (Pythia8::Sigma2ffbar2ffbarsgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsgm_isSChannel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsgm_isSChannel" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsgm const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsgm * >(argp1);
  result = (bool)((Pythia8::Sigma2ffbar2ffbarsgm const *)arg1)->isSChannel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbar2ffbarsgm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsgm *arg1 = (Pythia8::Sigma2ffbar2ffbarsgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbar2ffbarsgm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgm, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbar2ffbarsgm" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsgm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsgm * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbar2ffbarsgm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgm, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2ffbarsgmZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsgmZ *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2ffbar2ffbarsgmZ")) SWIG_fail;
  result = (Pythia8::Sigma2ffbar2ffbarsgmZ *)new Pythia8::Sigma2ffbar2ffbarsgmZ();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgmZ, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsgmZ_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsgmZ *arg1 = (Pythia8::Sigma2ffbar2ffbarsgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsgmZ_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsgmZ_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsgmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsgmZ * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsgmZ_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsgmZ *arg1 = (Pythia8::Sigma2ffbar2ffbarsgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsgmZ_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsgmZ_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsgmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsgmZ * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsgmZ_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsgmZ *arg1 = (Pythia8::Sigma2ffbar2ffbarsgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsgmZ_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsgmZ_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsgmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsgmZ * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsgmZ_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsgmZ *arg1 = (Pythia8::Sigma2ffbar2ffbarsgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsgmZ_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsgmZ_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsgmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsgmZ * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsgmZ_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsgmZ *arg1 = (Pythia8::Sigma2ffbar2ffbarsgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsgmZ_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsgmZ_name" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsgmZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsgmZ * >(argp1);
  result = ((Pythia8::Sigma2ffbar2ffbarsgmZ const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsgmZ_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsgmZ *arg1 = (Pythia8::Sigma2ffbar2ffbarsgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsgmZ_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsgmZ_code" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsgmZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsgmZ * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2ffbarsgmZ const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsgmZ_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsgmZ *arg1 = (Pythia8::Sigma2ffbar2ffbarsgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsgmZ_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsgmZ_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsgmZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsgmZ * >(argp1);
  result = ((Pythia8::Sigma2ffbar2ffbarsgmZ const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsgmZ_isSChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsgmZ *arg1 = (Pythia8::Sigma2ffbar2ffbarsgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsgmZ_isSChannel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsgmZ_isSChannel" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsgmZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsgmZ * >(argp1);
  result = (bool)((Pythia8::Sigma2ffbar2ffbarsgmZ const *)arg1)->isSChannel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsgmZ_idSChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsgmZ *arg1 = (Pythia8::Sigma2ffbar2ffbarsgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsgmZ_idSChannel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsgmZ_idSChannel" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsgmZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsgmZ * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2ffbarsgmZ const *)arg1)->idSChannel();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsgmZ_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsgmZ *arg1 = (Pythia8::Sigma2ffbar2ffbarsgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsgmZ_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsgmZ_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsgmZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsgmZ * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2ffbarsgmZ const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbar2ffbarsgmZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsgmZ *arg1 = (Pythia8::Sigma2ffbar2ffbarsgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbar2ffbarsgmZ",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgmZ, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbar2ffbarsgmZ" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsgmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsgmZ * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbar2ffbarsgmZ_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsgmZ, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2ffbarsW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsW *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2ffbar2ffbarsW")) SWIG_fail;
  result = (Pythia8::Sigma2ffbar2ffbarsW *)new Pythia8::Sigma2ffbar2ffbarsW();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsW, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsW_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsW *arg1 = (Pythia8::Sigma2ffbar2ffbarsW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsW_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsW_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsW * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsW_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsW *arg1 = (Pythia8::Sigma2ffbar2ffbarsW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsW_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsW_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsW * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsW_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsW *arg1 = (Pythia8::Sigma2ffbar2ffbarsW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsW_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsW_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsW * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsW_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsW *arg1 = (Pythia8::Sigma2ffbar2ffbarsW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsW_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsW_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsW * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsW_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsW *arg1 = (Pythia8::Sigma2ffbar2ffbarsW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsW_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsW_name" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsW * >(argp1);
  result = ((Pythia8::Sigma2ffbar2ffbarsW const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsW_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsW *arg1 = (Pythia8::Sigma2ffbar2ffbarsW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsW_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsW_code" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsW * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2ffbarsW const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsW_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsW *arg1 = (Pythia8::Sigma2ffbar2ffbarsW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsW_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsW_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsW * >(argp1);
  result = ((Pythia8::Sigma2ffbar2ffbarsW const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsW_isSChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsW *arg1 = (Pythia8::Sigma2ffbar2ffbarsW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsW_isSChannel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsW_isSChannel" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsW * >(argp1);
  result = (bool)((Pythia8::Sigma2ffbar2ffbarsW const *)arg1)->isSChannel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsW_idSChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsW *arg1 = (Pythia8::Sigma2ffbar2ffbarsW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsW_idSChannel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsW_idSChannel" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsW * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2ffbarsW const *)arg1)->idSChannel();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ffbarsW_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsW *arg1 = (Pythia8::Sigma2ffbar2ffbarsW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ffbarsW_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ffbarsW_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsW * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2ffbarsW const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbar2ffbarsW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ffbarsW *arg1 = (Pythia8::Sigma2ffbar2ffbarsW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbar2ffbarsW",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsW, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbar2ffbarsW" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ffbarsW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ffbarsW * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbar2ffbarsW_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbar2ffbarsW, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2FFbarsgmZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Sigma2ffbar2FFbarsgmZ *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Sigma2ffbar2FFbarsgmZ",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2ffbar2FFbarsgmZ" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2ffbar2FFbarsgmZ" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::Sigma2ffbar2FFbarsgmZ *)new Pythia8::Sigma2ffbar2FFbarsgmZ(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbar2FFbarsgmZ, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2FFbarsgmZ_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FFbarsgmZ *arg1 = (Pythia8::Sigma2ffbar2FFbarsgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2FFbarsgmZ_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FFbarsgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2FFbarsgmZ_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FFbarsgmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FFbarsgmZ * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2FFbarsgmZ_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FFbarsgmZ *arg1 = (Pythia8::Sigma2ffbar2FFbarsgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2FFbarsgmZ_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FFbarsgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2FFbarsgmZ_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FFbarsgmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FFbarsgmZ * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2FFbarsgmZ_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FFbarsgmZ *arg1 = (Pythia8::Sigma2ffbar2FFbarsgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2FFbarsgmZ_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FFbarsgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2FFbarsgmZ_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FFbarsgmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FFbarsgmZ * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2FFbarsgmZ_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FFbarsgmZ *arg1 = (Pythia8::Sigma2ffbar2FFbarsgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2FFbarsgmZ_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FFbarsgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2FFbarsgmZ_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FFbarsgmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FFbarsgmZ * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2FFbarsgmZ_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FFbarsgmZ *arg1 = (Pythia8::Sigma2ffbar2FFbarsgmZ *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2ffbar2FFbarsgmZ_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FFbarsgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2FFbarsgmZ_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FFbarsgmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FFbarsgmZ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2ffbar2FFbarsgmZ_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2ffbar2FFbarsgmZ_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2ffbar2FFbarsgmZ_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2ffbar2FFbarsgmZ_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2FFbarsgmZ_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FFbarsgmZ *arg1 = (Pythia8::Sigma2ffbar2FFbarsgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2FFbarsgmZ_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FFbarsgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2FFbarsgmZ_name" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FFbarsgmZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FFbarsgmZ * >(argp1);
  result = ((Pythia8::Sigma2ffbar2FFbarsgmZ const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2FFbarsgmZ_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FFbarsgmZ *arg1 = (Pythia8::Sigma2ffbar2FFbarsgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2FFbarsgmZ_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FFbarsgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2FFbarsgmZ_code" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FFbarsgmZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FFbarsgmZ * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2FFbarsgmZ const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2FFbarsgmZ_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FFbarsgmZ *arg1 = (Pythia8::Sigma2ffbar2FFbarsgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2FFbarsgmZ_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FFbarsgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2FFbarsgmZ_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FFbarsgmZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FFbarsgmZ * >(argp1);
  result = ((Pythia8::Sigma2ffbar2FFbarsgmZ const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2FFbarsgmZ_isSChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FFbarsgmZ *arg1 = (Pythia8::Sigma2ffbar2FFbarsgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2FFbarsgmZ_isSChannel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FFbarsgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2FFbarsgmZ_isSChannel" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FFbarsgmZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FFbarsgmZ * >(argp1);
  result = (bool)((Pythia8::Sigma2ffbar2FFbarsgmZ const *)arg1)->isSChannel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2FFbarsgmZ_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FFbarsgmZ *arg1 = (Pythia8::Sigma2ffbar2FFbarsgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2FFbarsgmZ_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FFbarsgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2FFbarsgmZ_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FFbarsgmZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FFbarsgmZ * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2FFbarsgmZ const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2FFbarsgmZ_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FFbarsgmZ *arg1 = (Pythia8::Sigma2ffbar2FFbarsgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2FFbarsgmZ_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FFbarsgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2FFbarsgmZ_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FFbarsgmZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FFbarsgmZ * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2FFbarsgmZ const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2FFbarsgmZ_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FFbarsgmZ *arg1 = (Pythia8::Sigma2ffbar2FFbarsgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2FFbarsgmZ_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FFbarsgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2FFbarsgmZ_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FFbarsgmZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FFbarsgmZ * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2FFbarsgmZ const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbar2FFbarsgmZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FFbarsgmZ *arg1 = (Pythia8::Sigma2ffbar2FFbarsgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbar2FFbarsgmZ",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FFbarsgmZ, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbar2FFbarsgmZ" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FFbarsgmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FFbarsgmZ * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbar2FFbarsgmZ_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbar2FFbarsgmZ, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2FfbarsW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Sigma2ffbar2FfbarsW *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Sigma2ffbar2FfbarsW",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2ffbar2FfbarsW" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2ffbar2FfbarsW" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2ffbar2FfbarsW" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::Sigma2ffbar2FfbarsW *)new Pythia8::Sigma2ffbar2FfbarsW(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbar2FfbarsW, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2FfbarsW_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FfbarsW *arg1 = (Pythia8::Sigma2ffbar2FfbarsW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2FfbarsW_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FfbarsW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2FfbarsW_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FfbarsW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FfbarsW * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2FfbarsW_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FfbarsW *arg1 = (Pythia8::Sigma2ffbar2FfbarsW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2FfbarsW_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FfbarsW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2FfbarsW_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FfbarsW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FfbarsW * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2FfbarsW_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FfbarsW *arg1 = (Pythia8::Sigma2ffbar2FfbarsW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2FfbarsW_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FfbarsW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2FfbarsW_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FfbarsW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FfbarsW * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2FfbarsW_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FfbarsW *arg1 = (Pythia8::Sigma2ffbar2FfbarsW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2FfbarsW_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FfbarsW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2FfbarsW_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FfbarsW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FfbarsW * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2FfbarsW_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FfbarsW *arg1 = (Pythia8::Sigma2ffbar2FfbarsW *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2ffbar2FfbarsW_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FfbarsW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2FfbarsW_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FfbarsW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FfbarsW * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2ffbar2FfbarsW_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2ffbar2FfbarsW_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2ffbar2FfbarsW_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2ffbar2FfbarsW_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2FfbarsW_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FfbarsW *arg1 = (Pythia8::Sigma2ffbar2FfbarsW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2FfbarsW_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FfbarsW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2FfbarsW_name" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FfbarsW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FfbarsW * >(argp1);
  result = ((Pythia8::Sigma2ffbar2FfbarsW const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2FfbarsW_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FfbarsW *arg1 = (Pythia8::Sigma2ffbar2FfbarsW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2FfbarsW_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FfbarsW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2FfbarsW_code" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FfbarsW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FfbarsW * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2FfbarsW const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2FfbarsW_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FfbarsW *arg1 = (Pythia8::Sigma2ffbar2FfbarsW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2FfbarsW_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FfbarsW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2FfbarsW_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FfbarsW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FfbarsW * >(argp1);
  result = ((Pythia8::Sigma2ffbar2FfbarsW const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2FfbarsW_isSChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FfbarsW *arg1 = (Pythia8::Sigma2ffbar2FfbarsW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2FfbarsW_isSChannel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FfbarsW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2FfbarsW_isSChannel" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FfbarsW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FfbarsW * >(argp1);
  result = (bool)((Pythia8::Sigma2ffbar2FfbarsW const *)arg1)->isSChannel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2FfbarsW_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FfbarsW *arg1 = (Pythia8::Sigma2ffbar2FfbarsW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2FfbarsW_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FfbarsW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2FfbarsW_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FfbarsW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FfbarsW * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2FfbarsW const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2FfbarsW_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FfbarsW *arg1 = (Pythia8::Sigma2ffbar2FfbarsW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2FfbarsW_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FfbarsW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2FfbarsW_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FfbarsW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FfbarsW * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2FfbarsW const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2FfbarsW_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FfbarsW *arg1 = (Pythia8::Sigma2ffbar2FfbarsW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2FfbarsW_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FfbarsW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2FfbarsW_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FfbarsW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FfbarsW * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2FfbarsW const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbar2FfbarsW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2FfbarsW *arg1 = (Pythia8::Sigma2ffbar2FfbarsW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbar2FfbarsW",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2FfbarsW, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbar2FfbarsW" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2FfbarsW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2FfbarsW * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbar2FfbarsW_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbar2FfbarsW, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbargmZWgmZW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbargmZWgmZW *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2ffbargmZWgmZW")) SWIG_fail;
  result = (Pythia8::Sigma2ffbargmZWgmZW *)new Pythia8::Sigma2ffbargmZWgmZW();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbargmZWgmZW, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbargmZWgmZW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbargmZWgmZW *arg1 = (Pythia8::Sigma2ffbargmZWgmZW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbargmZWgmZW",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbargmZWgmZW, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbargmZWgmZW" "', argument " "1"" of type '" "Pythia8::Sigma2ffbargmZWgmZW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbargmZWgmZW * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbargmZWgmZW_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbargmZWgmZW, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2gmZgmZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gmZgmZ *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2ffbar2gmZgmZ")) SWIG_fail;
  result = (Pythia8::Sigma2ffbar2gmZgmZ *)new Pythia8::Sigma2ffbar2gmZgmZ();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgmZ, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2gmZgmZ_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gmZgmZ *arg1 = (Pythia8::Sigma2ffbar2gmZgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2gmZgmZ_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2gmZgmZ_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gmZgmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gmZgmZ * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2gmZgmZ_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gmZgmZ *arg1 = (Pythia8::Sigma2ffbar2gmZgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2gmZgmZ_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2gmZgmZ_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gmZgmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gmZgmZ * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2gmZgmZ_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gmZgmZ *arg1 = (Pythia8::Sigma2ffbar2gmZgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2gmZgmZ_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2gmZgmZ_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gmZgmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gmZgmZ * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2gmZgmZ_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gmZgmZ *arg1 = (Pythia8::Sigma2ffbar2gmZgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2gmZgmZ_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2gmZgmZ_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gmZgmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gmZgmZ * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2gmZgmZ_weightDecayFlav(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gmZgmZ *arg1 = (Pythia8::Sigma2ffbar2gmZgmZ *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Sigma2ffbar2gmZgmZ_weightDecayFlav",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2gmZgmZ_weightDecayFlav" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gmZgmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gmZgmZ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2ffbar2gmZgmZ_weightDecayFlav" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2ffbar2gmZgmZ_weightDecayFlav" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (double)(arg1)->weightDecayFlav(*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2gmZgmZ_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gmZgmZ *arg1 = (Pythia8::Sigma2ffbar2gmZgmZ *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2ffbar2gmZgmZ_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2gmZgmZ_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gmZgmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gmZgmZ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2ffbar2gmZgmZ_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2ffbar2gmZgmZ_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2ffbar2gmZgmZ_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2ffbar2gmZgmZ_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2gmZgmZ_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gmZgmZ *arg1 = (Pythia8::Sigma2ffbar2gmZgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2gmZgmZ_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2gmZgmZ_name" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gmZgmZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gmZgmZ * >(argp1);
  result = ((Pythia8::Sigma2ffbar2gmZgmZ const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2gmZgmZ_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gmZgmZ *arg1 = (Pythia8::Sigma2ffbar2gmZgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2gmZgmZ_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2gmZgmZ_code" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gmZgmZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gmZgmZ * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2gmZgmZ const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2gmZgmZ_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gmZgmZ *arg1 = (Pythia8::Sigma2ffbar2gmZgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2gmZgmZ_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2gmZgmZ_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gmZgmZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gmZgmZ * >(argp1);
  result = ((Pythia8::Sigma2ffbar2gmZgmZ const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2gmZgmZ_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gmZgmZ *arg1 = (Pythia8::Sigma2ffbar2gmZgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2gmZgmZ_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2gmZgmZ_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gmZgmZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gmZgmZ * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2gmZgmZ const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2gmZgmZ_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gmZgmZ *arg1 = (Pythia8::Sigma2ffbar2gmZgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2gmZgmZ_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgmZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2gmZgmZ_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gmZgmZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gmZgmZ * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2gmZgmZ const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbar2gmZgmZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gmZgmZ *arg1 = (Pythia8::Sigma2ffbar2gmZgmZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbar2gmZgmZ",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgmZ, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbar2gmZgmZ" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gmZgmZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gmZgmZ * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbar2gmZgmZ_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgmZ, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2ZW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZW *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2ffbar2ZW")) SWIG_fail;
  result = (Pythia8::Sigma2ffbar2ZW *)new Pythia8::Sigma2ffbar2ZW();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbar2ZW, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ZW_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZW *arg1 = (Pythia8::Sigma2ffbar2ZW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ZW_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ZW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ZW_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ZW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ZW * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ZW_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZW *arg1 = (Pythia8::Sigma2ffbar2ZW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ZW_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ZW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ZW_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ZW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ZW * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ZW_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZW *arg1 = (Pythia8::Sigma2ffbar2ZW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ZW_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ZW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ZW_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ZW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ZW * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ZW_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZW *arg1 = (Pythia8::Sigma2ffbar2ZW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ZW_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ZW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ZW_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ZW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ZW * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ZW_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZW *arg1 = (Pythia8::Sigma2ffbar2ZW *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2ffbar2ZW_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ZW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ZW_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ZW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ZW * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2ffbar2ZW_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2ffbar2ZW_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2ffbar2ZW_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2ffbar2ZW_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ZW_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZW *arg1 = (Pythia8::Sigma2ffbar2ZW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ZW_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ZW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ZW_name" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ZW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ZW * >(argp1);
  result = ((Pythia8::Sigma2ffbar2ZW const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ZW_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZW *arg1 = (Pythia8::Sigma2ffbar2ZW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ZW_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ZW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ZW_code" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ZW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ZW * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2ZW const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ZW_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZW *arg1 = (Pythia8::Sigma2ffbar2ZW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ZW_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ZW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ZW_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ZW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ZW * >(argp1);
  result = ((Pythia8::Sigma2ffbar2ZW const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ZW_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZW *arg1 = (Pythia8::Sigma2ffbar2ZW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ZW_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ZW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ZW_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ZW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ZW * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2ZW const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ZW_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZW *arg1 = (Pythia8::Sigma2ffbar2ZW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ZW_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ZW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ZW_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ZW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ZW * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2ZW const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2ZW_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZW *arg1 = (Pythia8::Sigma2ffbar2ZW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2ZW_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ZW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2ZW_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ZW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ZW * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2ZW const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbar2ZW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2ZW *arg1 = (Pythia8::Sigma2ffbar2ZW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbar2ZW",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2ZW, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbar2ZW" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2ZW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2ZW * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbar2ZW_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbar2ZW, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2WW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2WW *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2ffbar2WW")) SWIG_fail;
  result = (Pythia8::Sigma2ffbar2WW *)new Pythia8::Sigma2ffbar2WW();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbar2WW, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2WW_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2WW *arg1 = (Pythia8::Sigma2ffbar2WW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2WW_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2WW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2WW_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2WW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2WW * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2WW_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2WW *arg1 = (Pythia8::Sigma2ffbar2WW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2WW_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2WW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2WW_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2WW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2WW * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2WW_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2WW *arg1 = (Pythia8::Sigma2ffbar2WW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2WW_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2WW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2WW_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2WW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2WW * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2WW_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2WW *arg1 = (Pythia8::Sigma2ffbar2WW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2WW_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2WW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2WW_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2WW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2WW * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2WW_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2WW *arg1 = (Pythia8::Sigma2ffbar2WW *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2ffbar2WW_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2WW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2WW_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2WW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2WW * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2ffbar2WW_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2ffbar2WW_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2ffbar2WW_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2ffbar2WW_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2WW_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2WW *arg1 = (Pythia8::Sigma2ffbar2WW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2WW_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2WW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2WW_name" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2WW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2WW * >(argp1);
  result = ((Pythia8::Sigma2ffbar2WW const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2WW_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2WW *arg1 = (Pythia8::Sigma2ffbar2WW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2WW_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2WW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2WW_code" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2WW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2WW * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2WW const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2WW_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2WW *arg1 = (Pythia8::Sigma2ffbar2WW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2WW_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2WW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2WW_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2WW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2WW * >(argp1);
  result = ((Pythia8::Sigma2ffbar2WW const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2WW_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2WW *arg1 = (Pythia8::Sigma2ffbar2WW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2WW_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2WW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2WW_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2WW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2WW * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2WW const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2WW_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2WW *arg1 = (Pythia8::Sigma2ffbar2WW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2WW_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2WW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2WW_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2WW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2WW * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2WW const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2WW_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2WW *arg1 = (Pythia8::Sigma2ffbar2WW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2WW_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2WW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2WW_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2WW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2WW * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2WW const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbar2WW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2WW *arg1 = (Pythia8::Sigma2ffbar2WW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbar2WW",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2WW, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbar2WW" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2WW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2WW * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbar2WW_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbar2WW, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbargmZggm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbargmZggm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2ffbargmZggm")) SWIG_fail;
  result = (Pythia8::Sigma2ffbargmZggm *)new Pythia8::Sigma2ffbargmZggm();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbargmZggm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbargmZggm_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbargmZggm *arg1 = (Pythia8::Sigma2ffbargmZggm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbargmZggm_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbargmZggm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbargmZggm_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2ffbargmZggm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbargmZggm * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbargmZggm_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbargmZggm *arg1 = (Pythia8::Sigma2ffbargmZggm *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2ffbargmZggm_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbargmZggm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbargmZggm_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2ffbargmZggm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbargmZggm * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2ffbargmZggm_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2ffbargmZggm_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2ffbargmZggm_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2ffbargmZggm_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbargmZggm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbargmZggm *arg1 = (Pythia8::Sigma2ffbargmZggm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbargmZggm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbargmZggm, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbargmZggm" "', argument " "1"" of type '" "Pythia8::Sigma2ffbargmZggm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbargmZggm * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbargmZggm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbargmZggm, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2gmZg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gmZg *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qqbar2gmZg")) SWIG_fail;
  result = (Pythia8::Sigma2qqbar2gmZg *)new Pythia8::Sigma2qqbar2gmZg();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2gmZg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2gmZg_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gmZg *arg1 = (Pythia8::Sigma2qqbar2gmZg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2gmZg_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gmZg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2gmZg_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gmZg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gmZg * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2gmZg_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gmZg *arg1 = (Pythia8::Sigma2qqbar2gmZg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2gmZg_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gmZg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2gmZg_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gmZg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gmZg * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2gmZg_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gmZg *arg1 = (Pythia8::Sigma2qqbar2gmZg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2gmZg_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gmZg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2gmZg_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gmZg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gmZg * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2gmZg_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gmZg *arg1 = (Pythia8::Sigma2qqbar2gmZg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2gmZg_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gmZg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2gmZg_name" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gmZg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gmZg * >(argp1);
  result = ((Pythia8::Sigma2qqbar2gmZg const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2gmZg_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gmZg *arg1 = (Pythia8::Sigma2qqbar2gmZg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2gmZg_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gmZg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2gmZg_code" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gmZg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gmZg * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2gmZg const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2gmZg_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gmZg *arg1 = (Pythia8::Sigma2qqbar2gmZg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2gmZg_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gmZg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2gmZg_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gmZg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gmZg * >(argp1);
  result = ((Pythia8::Sigma2qqbar2gmZg const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2gmZg_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gmZg *arg1 = (Pythia8::Sigma2qqbar2gmZg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2gmZg_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gmZg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2gmZg_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gmZg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gmZg * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2gmZg const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2gmZg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gmZg *arg1 = (Pythia8::Sigma2qqbar2gmZg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2gmZg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gmZg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2gmZg" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gmZg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gmZg * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2gmZg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2gmZg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qg2gmZq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2gmZq *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qg2gmZq")) SWIG_fail;
  result = (Pythia8::Sigma2qg2gmZq *)new Pythia8::Sigma2qg2gmZq();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qg2gmZq, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2gmZq_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2gmZq *arg1 = (Pythia8::Sigma2qg2gmZq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2gmZq_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2gmZq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2gmZq_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qg2gmZq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2gmZq * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2gmZq_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2gmZq *arg1 = (Pythia8::Sigma2qg2gmZq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2gmZq_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2gmZq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2gmZq_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qg2gmZq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2gmZq * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2gmZq_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2gmZq *arg1 = (Pythia8::Sigma2qg2gmZq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2gmZq_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2gmZq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2gmZq_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qg2gmZq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2gmZq * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2gmZq_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2gmZq *arg1 = (Pythia8::Sigma2qg2gmZq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2gmZq_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2gmZq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2gmZq_name" "', argument " "1"" of type '" "Pythia8::Sigma2qg2gmZq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2gmZq * >(argp1);
  result = ((Pythia8::Sigma2qg2gmZq const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2gmZq_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2gmZq *arg1 = (Pythia8::Sigma2qg2gmZq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2gmZq_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2gmZq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2gmZq_code" "', argument " "1"" of type '" "Pythia8::Sigma2qg2gmZq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2gmZq * >(argp1);
  result = (int)((Pythia8::Sigma2qg2gmZq const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2gmZq_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2gmZq *arg1 = (Pythia8::Sigma2qg2gmZq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2gmZq_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2gmZq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2gmZq_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qg2gmZq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2gmZq * >(argp1);
  result = ((Pythia8::Sigma2qg2gmZq const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2gmZq_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2gmZq *arg1 = (Pythia8::Sigma2qg2gmZq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2gmZq_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2gmZq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2gmZq_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qg2gmZq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2gmZq * >(argp1);
  result = (int)((Pythia8::Sigma2qg2gmZq const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qg2gmZq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2gmZq *arg1 = (Pythia8::Sigma2qg2gmZq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qg2gmZq",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2gmZq, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qg2gmZq" "', argument " "1"" of type '" "Pythia8::Sigma2qg2gmZq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2gmZq * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qg2gmZq_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qg2gmZq, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2gmZgm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gmZgm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2ffbar2gmZgm")) SWIG_fail;
  result = (Pythia8::Sigma2ffbar2gmZgm *)new Pythia8::Sigma2ffbar2gmZgm();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2gmZgm_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gmZgm *arg1 = (Pythia8::Sigma2ffbar2gmZgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2gmZgm_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2gmZgm_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gmZgm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gmZgm * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2gmZgm_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gmZgm *arg1 = (Pythia8::Sigma2ffbar2gmZgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2gmZgm_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2gmZgm_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gmZgm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gmZgm * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2gmZgm_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gmZgm *arg1 = (Pythia8::Sigma2ffbar2gmZgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2gmZgm_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2gmZgm_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gmZgm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gmZgm * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2gmZgm_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gmZgm *arg1 = (Pythia8::Sigma2ffbar2gmZgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2gmZgm_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2gmZgm_name" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gmZgm const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gmZgm * >(argp1);
  result = ((Pythia8::Sigma2ffbar2gmZgm const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2gmZgm_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gmZgm *arg1 = (Pythia8::Sigma2ffbar2gmZgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2gmZgm_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2gmZgm_code" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gmZgm const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gmZgm * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2gmZgm const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2gmZgm_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gmZgm *arg1 = (Pythia8::Sigma2ffbar2gmZgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2gmZgm_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2gmZgm_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gmZgm const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gmZgm * >(argp1);
  result = ((Pythia8::Sigma2ffbar2gmZgm const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2gmZgm_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gmZgm *arg1 = (Pythia8::Sigma2ffbar2gmZgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2gmZgm_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2gmZgm_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gmZgm const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gmZgm * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2gmZgm const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbar2gmZgm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2gmZgm *arg1 = (Pythia8::Sigma2ffbar2gmZgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbar2gmZgm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgm, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbar2gmZgm" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2gmZgm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2gmZgm * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbar2gmZgm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbar2gmZgm, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2fgm2gmZf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2fgm2gmZf *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2fgm2gmZf")) SWIG_fail;
  result = (Pythia8::Sigma2fgm2gmZf *)new Pythia8::Sigma2fgm2gmZf();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2fgm2gmZf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2fgm2gmZf_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2fgm2gmZf *arg1 = (Pythia8::Sigma2fgm2gmZf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2fgm2gmZf_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2fgm2gmZf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2fgm2gmZf_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2fgm2gmZf *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2fgm2gmZf * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2fgm2gmZf_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2fgm2gmZf *arg1 = (Pythia8::Sigma2fgm2gmZf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2fgm2gmZf_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2fgm2gmZf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2fgm2gmZf_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2fgm2gmZf *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2fgm2gmZf * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2fgm2gmZf_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2fgm2gmZf *arg1 = (Pythia8::Sigma2fgm2gmZf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2fgm2gmZf_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2fgm2gmZf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2fgm2gmZf_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2fgm2gmZf *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2fgm2gmZf * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2fgm2gmZf_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2fgm2gmZf *arg1 = (Pythia8::Sigma2fgm2gmZf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2fgm2gmZf_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2fgm2gmZf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2fgm2gmZf_name" "', argument " "1"" of type '" "Pythia8::Sigma2fgm2gmZf const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2fgm2gmZf * >(argp1);
  result = ((Pythia8::Sigma2fgm2gmZf const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2fgm2gmZf_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2fgm2gmZf *arg1 = (Pythia8::Sigma2fgm2gmZf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2fgm2gmZf_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2fgm2gmZf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2fgm2gmZf_code" "', argument " "1"" of type '" "Pythia8::Sigma2fgm2gmZf const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2fgm2gmZf * >(argp1);
  result = (int)((Pythia8::Sigma2fgm2gmZf const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2fgm2gmZf_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2fgm2gmZf *arg1 = (Pythia8::Sigma2fgm2gmZf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2fgm2gmZf_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2fgm2gmZf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2fgm2gmZf_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2fgm2gmZf const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2fgm2gmZf * >(argp1);
  result = ((Pythia8::Sigma2fgm2gmZf const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2fgm2gmZf_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2fgm2gmZf *arg1 = (Pythia8::Sigma2fgm2gmZf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2fgm2gmZf_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2fgm2gmZf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2fgm2gmZf_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2fgm2gmZf const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2fgm2gmZf * >(argp1);
  result = (int)((Pythia8::Sigma2fgm2gmZf const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2fgm2gmZf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2fgm2gmZf *arg1 = (Pythia8::Sigma2fgm2gmZf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2fgm2gmZf",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2fgm2gmZf, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2fgm2gmZf" "', argument " "1"" of type '" "Pythia8::Sigma2fgm2gmZf *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2fgm2gmZf * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2fgm2gmZf_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2fgm2gmZf, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbarWggm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbarWggm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2ffbarWggm")) SWIG_fail;
  result = (Pythia8::Sigma2ffbarWggm *)new Pythia8::Sigma2ffbarWggm();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbarWggm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbarWggm_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbarWggm *arg1 = (Pythia8::Sigma2ffbarWggm *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2ffbarWggm_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbarWggm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbarWggm_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2ffbarWggm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbarWggm * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2ffbarWggm_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2ffbarWggm_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2ffbarWggm_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2ffbarWggm_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbarWggm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbarWggm *arg1 = (Pythia8::Sigma2ffbarWggm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbarWggm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbarWggm, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbarWggm" "', argument " "1"" of type '" "Pythia8::Sigma2ffbarWggm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbarWggm * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbarWggm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbarWggm, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2Wg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Wg *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qqbar2Wg")) SWIG_fail;
  result = (Pythia8::Sigma2qqbar2Wg *)new Pythia8::Sigma2qqbar2Wg();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2Wg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Wg_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Wg *arg1 = (Pythia8::Sigma2qqbar2Wg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Wg_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Wg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Wg_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Wg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Wg * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Wg_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Wg *arg1 = (Pythia8::Sigma2qqbar2Wg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Wg_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Wg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Wg_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Wg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Wg * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Wg_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Wg *arg1 = (Pythia8::Sigma2qqbar2Wg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Wg_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Wg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Wg_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Wg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Wg * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Wg_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Wg *arg1 = (Pythia8::Sigma2qqbar2Wg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Wg_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Wg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Wg_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Wg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Wg * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Wg_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Wg *arg1 = (Pythia8::Sigma2qqbar2Wg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Wg_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Wg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Wg_name" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Wg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Wg * >(argp1);
  result = ((Pythia8::Sigma2qqbar2Wg const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Wg_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Wg *arg1 = (Pythia8::Sigma2qqbar2Wg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Wg_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Wg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Wg_code" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Wg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Wg * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2Wg const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Wg_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Wg *arg1 = (Pythia8::Sigma2qqbar2Wg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Wg_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Wg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Wg_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Wg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Wg * >(argp1);
  result = ((Pythia8::Sigma2qqbar2Wg const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Wg_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Wg *arg1 = (Pythia8::Sigma2qqbar2Wg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Wg_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Wg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Wg_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Wg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Wg * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2Wg const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2Wg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Wg *arg1 = (Pythia8::Sigma2qqbar2Wg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2Wg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Wg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2Wg" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Wg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Wg * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2Wg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2Wg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qg2Wq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Wq *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qg2Wq")) SWIG_fail;
  result = (Pythia8::Sigma2qg2Wq *)new Pythia8::Sigma2qg2Wq();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qg2Wq, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Wq_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Wq *arg1 = (Pythia8::Sigma2qg2Wq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Wq_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Wq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Wq_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Wq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Wq * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Wq_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Wq *arg1 = (Pythia8::Sigma2qg2Wq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Wq_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Wq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Wq_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Wq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Wq * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Wq_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Wq *arg1 = (Pythia8::Sigma2qg2Wq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Wq_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Wq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Wq_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Wq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Wq * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Wq_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Wq *arg1 = (Pythia8::Sigma2qg2Wq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Wq_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Wq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Wq_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Wq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Wq * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Wq_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Wq *arg1 = (Pythia8::Sigma2qg2Wq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Wq_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Wq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Wq_name" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Wq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Wq * >(argp1);
  result = ((Pythia8::Sigma2qg2Wq const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Wq_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Wq *arg1 = (Pythia8::Sigma2qg2Wq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Wq_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Wq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Wq_code" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Wq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Wq * >(argp1);
  result = (int)((Pythia8::Sigma2qg2Wq const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Wq_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Wq *arg1 = (Pythia8::Sigma2qg2Wq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Wq_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Wq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Wq_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Wq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Wq * >(argp1);
  result = ((Pythia8::Sigma2qg2Wq const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Wq_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Wq *arg1 = (Pythia8::Sigma2qg2Wq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Wq_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Wq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Wq_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Wq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Wq * >(argp1);
  result = (int)((Pythia8::Sigma2qg2Wq const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qg2Wq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Wq *arg1 = (Pythia8::Sigma2qg2Wq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qg2Wq",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Wq, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qg2Wq" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Wq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Wq * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qg2Wq_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qg2Wq, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2Wgm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2Wgm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2ffbar2Wgm")) SWIG_fail;
  result = (Pythia8::Sigma2ffbar2Wgm *)new Pythia8::Sigma2ffbar2Wgm();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbar2Wgm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2Wgm_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2Wgm *arg1 = (Pythia8::Sigma2ffbar2Wgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2Wgm_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2Wgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2Wgm_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2Wgm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2Wgm * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2Wgm_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2Wgm *arg1 = (Pythia8::Sigma2ffbar2Wgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2Wgm_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2Wgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2Wgm_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2Wgm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2Wgm * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2Wgm_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2Wgm *arg1 = (Pythia8::Sigma2ffbar2Wgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2Wgm_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2Wgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2Wgm_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2Wgm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2Wgm * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2Wgm_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2Wgm *arg1 = (Pythia8::Sigma2ffbar2Wgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2Wgm_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2Wgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2Wgm_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2Wgm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2Wgm * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2Wgm_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2Wgm *arg1 = (Pythia8::Sigma2ffbar2Wgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2Wgm_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2Wgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2Wgm_name" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2Wgm const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2Wgm * >(argp1);
  result = ((Pythia8::Sigma2ffbar2Wgm const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2Wgm_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2Wgm *arg1 = (Pythia8::Sigma2ffbar2Wgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2Wgm_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2Wgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2Wgm_code" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2Wgm const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2Wgm * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2Wgm const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2Wgm_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2Wgm *arg1 = (Pythia8::Sigma2ffbar2Wgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2Wgm_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2Wgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2Wgm_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2Wgm const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2Wgm * >(argp1);
  result = ((Pythia8::Sigma2ffbar2Wgm const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2Wgm_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2Wgm *arg1 = (Pythia8::Sigma2ffbar2Wgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2Wgm_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2Wgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2Wgm_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2Wgm const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2Wgm * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2Wgm const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbar2Wgm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2Wgm *arg1 = (Pythia8::Sigma2ffbar2Wgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbar2Wgm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2Wgm, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbar2Wgm" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2Wgm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2Wgm * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbar2Wgm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbar2Wgm, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2fgm2Wf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2fgm2Wf *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2fgm2Wf")) SWIG_fail;
  result = (Pythia8::Sigma2fgm2Wf *)new Pythia8::Sigma2fgm2Wf();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2fgm2Wf, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2fgm2Wf_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2fgm2Wf *arg1 = (Pythia8::Sigma2fgm2Wf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2fgm2Wf_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2fgm2Wf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2fgm2Wf_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2fgm2Wf *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2fgm2Wf * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2fgm2Wf_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2fgm2Wf *arg1 = (Pythia8::Sigma2fgm2Wf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2fgm2Wf_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2fgm2Wf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2fgm2Wf_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2fgm2Wf *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2fgm2Wf * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2fgm2Wf_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2fgm2Wf *arg1 = (Pythia8::Sigma2fgm2Wf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2fgm2Wf_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2fgm2Wf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2fgm2Wf_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2fgm2Wf *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2fgm2Wf * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2fgm2Wf_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2fgm2Wf *arg1 = (Pythia8::Sigma2fgm2Wf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2fgm2Wf_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2fgm2Wf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2fgm2Wf_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2fgm2Wf *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2fgm2Wf * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2fgm2Wf_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2fgm2Wf *arg1 = (Pythia8::Sigma2fgm2Wf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2fgm2Wf_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2fgm2Wf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2fgm2Wf_name" "', argument " "1"" of type '" "Pythia8::Sigma2fgm2Wf const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2fgm2Wf * >(argp1);
  result = ((Pythia8::Sigma2fgm2Wf const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2fgm2Wf_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2fgm2Wf *arg1 = (Pythia8::Sigma2fgm2Wf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2fgm2Wf_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2fgm2Wf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2fgm2Wf_code" "', argument " "1"" of type '" "Pythia8::Sigma2fgm2Wf const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2fgm2Wf * >(argp1);
  result = (int)((Pythia8::Sigma2fgm2Wf const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2fgm2Wf_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2fgm2Wf *arg1 = (Pythia8::Sigma2fgm2Wf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2fgm2Wf_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2fgm2Wf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2fgm2Wf_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2fgm2Wf const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2fgm2Wf * >(argp1);
  result = ((Pythia8::Sigma2fgm2Wf const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2fgm2Wf_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2fgm2Wf *arg1 = (Pythia8::Sigma2fgm2Wf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2fgm2Wf_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2fgm2Wf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2fgm2Wf_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2fgm2Wf const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2fgm2Wf * >(argp1);
  result = (int)((Pythia8::Sigma2fgm2Wf const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2fgm2Wf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2fgm2Wf *arg1 = (Pythia8::Sigma2fgm2Wf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2fgm2Wf",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2fgm2Wf, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2fgm2Wf" "', argument " "1"" of type '" "Pythia8::Sigma2fgm2Wf *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2fgm2Wf * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2fgm2Wf_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2fgm2Wf, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2gmgm2ffbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Sigma2gmgm2ffbar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Sigma2gmgm2ffbar",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2gmgm2ffbar" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2gmgm2ffbar" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::Sigma2gmgm2ffbar *)new Pythia8::Sigma2gmgm2ffbar(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gmgm2ffbar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gmgm2ffbar_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gmgm2ffbar *arg1 = (Pythia8::Sigma2gmgm2ffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gmgm2ffbar_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gmgm2ffbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gmgm2ffbar_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2gmgm2ffbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gmgm2ffbar * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gmgm2ffbar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gmgm2ffbar *arg1 = (Pythia8::Sigma2gmgm2ffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gmgm2ffbar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gmgm2ffbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gmgm2ffbar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2gmgm2ffbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gmgm2ffbar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gmgm2ffbar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gmgm2ffbar *arg1 = (Pythia8::Sigma2gmgm2ffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gmgm2ffbar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gmgm2ffbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gmgm2ffbar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2gmgm2ffbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gmgm2ffbar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gmgm2ffbar_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gmgm2ffbar *arg1 = (Pythia8::Sigma2gmgm2ffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gmgm2ffbar_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gmgm2ffbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gmgm2ffbar_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2gmgm2ffbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gmgm2ffbar * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gmgm2ffbar_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gmgm2ffbar *arg1 = (Pythia8::Sigma2gmgm2ffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gmgm2ffbar_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gmgm2ffbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gmgm2ffbar_name" "', argument " "1"" of type '" "Pythia8::Sigma2gmgm2ffbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gmgm2ffbar * >(argp1);
  result = ((Pythia8::Sigma2gmgm2ffbar const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gmgm2ffbar_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gmgm2ffbar *arg1 = (Pythia8::Sigma2gmgm2ffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gmgm2ffbar_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gmgm2ffbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gmgm2ffbar_code" "', argument " "1"" of type '" "Pythia8::Sigma2gmgm2ffbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gmgm2ffbar * >(argp1);
  result = (int)((Pythia8::Sigma2gmgm2ffbar const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gmgm2ffbar_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gmgm2ffbar *arg1 = (Pythia8::Sigma2gmgm2ffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gmgm2ffbar_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gmgm2ffbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gmgm2ffbar_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2gmgm2ffbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gmgm2ffbar * >(argp1);
  result = ((Pythia8::Sigma2gmgm2ffbar const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gmgm2ffbar_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gmgm2ffbar *arg1 = (Pythia8::Sigma2gmgm2ffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gmgm2ffbar_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gmgm2ffbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gmgm2ffbar_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2gmgm2ffbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gmgm2ffbar * >(argp1);
  result = (int)((Pythia8::Sigma2gmgm2ffbar const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gmgm2ffbar_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gmgm2ffbar *arg1 = (Pythia8::Sigma2gmgm2ffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gmgm2ffbar_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gmgm2ffbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gmgm2ffbar_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2gmgm2ffbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gmgm2ffbar * >(argp1);
  result = (int)((Pythia8::Sigma2gmgm2ffbar const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2gmgm2ffbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gmgm2ffbar *arg1 = (Pythia8::Sigma2gmgm2ffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2gmgm2ffbar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gmgm2ffbar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2gmgm2ffbar" "', argument " "1"" of type '" "Pythia8::Sigma2gmgm2ffbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gmgm2ffbar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2gmgm2ffbar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2gmgm2ffbar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ggm2qqbar__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  std::string arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Sigma2ggm2qqbar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Sigma2ggm2qqbar",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2ggm2qqbar" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2ggm2qqbar" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Sigma2ggm2qqbar" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::Sigma2ggm2qqbar *)new Pythia8::Sigma2ggm2qqbar(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ggm2qqbar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2ggm2qqbar__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Sigma2ggm2qqbar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Sigma2ggm2qqbar",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2ggm2qqbar" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2ggm2qqbar" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::Sigma2ggm2qqbar *)new Pythia8::Sigma2ggm2qqbar(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ggm2qqbar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2ggm2qqbar(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Sigma2ggm2qqbar__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_Sigma2ggm2qqbar__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Sigma2ggm2qqbar'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Sigma2ggm2qqbar::Sigma2ggm2qqbar(int,int,std::string)\n"
    "    Pythia8::Sigma2ggm2qqbar::Sigma2ggm2qqbar(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Sigma2ggm2qqbar_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ggm2qqbar *arg1 = (Pythia8::Sigma2ggm2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ggm2qqbar_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ggm2qqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ggm2qqbar_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2ggm2qqbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ggm2qqbar * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ggm2qqbar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ggm2qqbar *arg1 = (Pythia8::Sigma2ggm2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ggm2qqbar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ggm2qqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ggm2qqbar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ggm2qqbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ggm2qqbar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ggm2qqbar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ggm2qqbar *arg1 = (Pythia8::Sigma2ggm2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ggm2qqbar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ggm2qqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ggm2qqbar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ggm2qqbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ggm2qqbar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ggm2qqbar_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ggm2qqbar *arg1 = (Pythia8::Sigma2ggm2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ggm2qqbar_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ggm2qqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ggm2qqbar_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ggm2qqbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ggm2qqbar * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ggm2qqbar_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ggm2qqbar *arg1 = (Pythia8::Sigma2ggm2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ggm2qqbar_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ggm2qqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ggm2qqbar_name" "', argument " "1"" of type '" "Pythia8::Sigma2ggm2qqbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ggm2qqbar * >(argp1);
  result = ((Pythia8::Sigma2ggm2qqbar const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ggm2qqbar_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ggm2qqbar *arg1 = (Pythia8::Sigma2ggm2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ggm2qqbar_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ggm2qqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ggm2qqbar_code" "', argument " "1"" of type '" "Pythia8::Sigma2ggm2qqbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ggm2qqbar * >(argp1);
  result = (int)((Pythia8::Sigma2ggm2qqbar const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ggm2qqbar_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ggm2qqbar *arg1 = (Pythia8::Sigma2ggm2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ggm2qqbar_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ggm2qqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ggm2qqbar_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ggm2qqbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ggm2qqbar * >(argp1);
  result = ((Pythia8::Sigma2ggm2qqbar const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ggm2qqbar_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ggm2qqbar *arg1 = (Pythia8::Sigma2ggm2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ggm2qqbar_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ggm2qqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ggm2qqbar_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ggm2qqbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ggm2qqbar * >(argp1);
  result = (int)((Pythia8::Sigma2ggm2qqbar const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ggm2qqbar_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ggm2qqbar *arg1 = (Pythia8::Sigma2ggm2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ggm2qqbar_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ggm2qqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ggm2qqbar_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ggm2qqbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ggm2qqbar * >(argp1);
  result = (int)((Pythia8::Sigma2ggm2qqbar const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ggm2qqbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ggm2qqbar *arg1 = (Pythia8::Sigma2ggm2qqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ggm2qqbar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ggm2qqbar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ggm2qqbar" "', argument " "1"" of type '" "Pythia8::Sigma2ggm2qqbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ggm2qqbar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ggm2qqbar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ggm2qqbar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qgm2qg__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Sigma2qgm2qg *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Sigma2qgm2qg",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qgm2qg" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Sigma2qgm2qg" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::Sigma2qgm2qg *)new Pythia8::Sigma2qgm2qg(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qgm2qg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2qgm2qg__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma2qgm2qg *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma2qgm2qg",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qgm2qg" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Sigma2qgm2qg *)new Pythia8::Sigma2qgm2qg(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qgm2qg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2qgm2qg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Sigma2qgm2qg__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Sigma2qgm2qg__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Sigma2qgm2qg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Sigma2qgm2qg::Sigma2qgm2qg(int,std::string)\n"
    "    Pythia8::Sigma2qgm2qg::Sigma2qgm2qg(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Sigma2qgm2qg_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qgm2qg *arg1 = (Pythia8::Sigma2qgm2qg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qgm2qg_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qgm2qg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qgm2qg_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qgm2qg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qgm2qg * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qgm2qg_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qgm2qg *arg1 = (Pythia8::Sigma2qgm2qg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qgm2qg_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qgm2qg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qgm2qg_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qgm2qg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qgm2qg * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qgm2qg_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qgm2qg *arg1 = (Pythia8::Sigma2qgm2qg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qgm2qg_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qgm2qg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qgm2qg_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qgm2qg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qgm2qg * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qgm2qg_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qgm2qg *arg1 = (Pythia8::Sigma2qgm2qg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qgm2qg_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qgm2qg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qgm2qg_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qgm2qg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qgm2qg * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qgm2qg_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qgm2qg *arg1 = (Pythia8::Sigma2qgm2qg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qgm2qg_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qgm2qg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qgm2qg_name" "', argument " "1"" of type '" "Pythia8::Sigma2qgm2qg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qgm2qg * >(argp1);
  result = ((Pythia8::Sigma2qgm2qg const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qgm2qg_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qgm2qg *arg1 = (Pythia8::Sigma2qgm2qg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qgm2qg_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qgm2qg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qgm2qg_code" "', argument " "1"" of type '" "Pythia8::Sigma2qgm2qg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qgm2qg * >(argp1);
  result = (int)((Pythia8::Sigma2qgm2qg const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qgm2qg_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qgm2qg *arg1 = (Pythia8::Sigma2qgm2qg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qgm2qg_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qgm2qg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qgm2qg_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qgm2qg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qgm2qg * >(argp1);
  result = ((Pythia8::Sigma2qgm2qg const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qgm2qg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qgm2qg *arg1 = (Pythia8::Sigma2qgm2qg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qgm2qg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qgm2qg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qgm2qg" "', argument " "1"" of type '" "Pythia8::Sigma2qgm2qg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qgm2qg * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qgm2qg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qgm2qg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qgm2qgm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Sigma2qgm2qgm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Sigma2qgm2qgm",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qgm2qgm" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Sigma2qgm2qgm" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::Sigma2qgm2qgm *)new Pythia8::Sigma2qgm2qgm(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qgm2qgm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2qgm2qgm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma2qgm2qgm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma2qgm2qgm",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qgm2qgm" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Sigma2qgm2qgm *)new Pythia8::Sigma2qgm2qgm(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qgm2qgm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2qgm2qgm(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Sigma2qgm2qgm__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Sigma2qgm2qgm__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Sigma2qgm2qgm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Sigma2qgm2qgm::Sigma2qgm2qgm(int,std::string)\n"
    "    Pythia8::Sigma2qgm2qgm::Sigma2qgm2qgm(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Sigma2qgm2qgm_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qgm2qgm *arg1 = (Pythia8::Sigma2qgm2qgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qgm2qgm_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qgm2qgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qgm2qgm_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qgm2qgm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qgm2qgm * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qgm2qgm_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qgm2qgm *arg1 = (Pythia8::Sigma2qgm2qgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qgm2qgm_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qgm2qgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qgm2qgm_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qgm2qgm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qgm2qgm * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qgm2qgm_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qgm2qgm *arg1 = (Pythia8::Sigma2qgm2qgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qgm2qgm_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qgm2qgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qgm2qgm_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qgm2qgm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qgm2qgm * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qgm2qgm_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qgm2qgm *arg1 = (Pythia8::Sigma2qgm2qgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qgm2qgm_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qgm2qgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qgm2qgm_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qgm2qgm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qgm2qgm * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qgm2qgm_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qgm2qgm *arg1 = (Pythia8::Sigma2qgm2qgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qgm2qgm_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qgm2qgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qgm2qgm_name" "', argument " "1"" of type '" "Pythia8::Sigma2qgm2qgm const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qgm2qgm * >(argp1);
  result = ((Pythia8::Sigma2qgm2qgm const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qgm2qgm_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qgm2qgm *arg1 = (Pythia8::Sigma2qgm2qgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qgm2qgm_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qgm2qgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qgm2qgm_code" "', argument " "1"" of type '" "Pythia8::Sigma2qgm2qgm const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qgm2qgm * >(argp1);
  result = (int)((Pythia8::Sigma2qgm2qgm const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qgm2qgm_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qgm2qgm *arg1 = (Pythia8::Sigma2qgm2qgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qgm2qgm_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qgm2qgm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qgm2qgm_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qgm2qgm const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qgm2qgm * >(argp1);
  result = ((Pythia8::Sigma2qgm2qgm const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qgm2qgm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qgm2qgm *arg1 = (Pythia8::Sigma2qgm2qgm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qgm2qgm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qgm2qgm, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qgm2qgm" "', argument " "1"" of type '" "Pythia8::Sigma2qgm2qgm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qgm2qgm * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qgm2qgm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qgm2qgm, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma1gg2GravitonStar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2GravitonStar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma1gg2GravitonStar")) SWIG_fail;
  result = (Pythia8::Sigma1gg2GravitonStar *)new Pythia8::Sigma1gg2GravitonStar();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma1gg2GravitonStar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2GravitonStar_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2GravitonStar *arg1 = (Pythia8::Sigma1gg2GravitonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gg2GravitonStar_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2GravitonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2GravitonStar_initProc" "', argument " "1"" of type '" "Pythia8::Sigma1gg2GravitonStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2GravitonStar * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2GravitonStar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2GravitonStar *arg1 = (Pythia8::Sigma1gg2GravitonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gg2GravitonStar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2GravitonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2GravitonStar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma1gg2GravitonStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2GravitonStar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2GravitonStar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2GravitonStar *arg1 = (Pythia8::Sigma1gg2GravitonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gg2GravitonStar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2GravitonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2GravitonStar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma1gg2GravitonStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2GravitonStar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2GravitonStar_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2GravitonStar *arg1 = (Pythia8::Sigma1gg2GravitonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gg2GravitonStar_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2GravitonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2GravitonStar_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma1gg2GravitonStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2GravitonStar * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2GravitonStar_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2GravitonStar *arg1 = (Pythia8::Sigma1gg2GravitonStar *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma1gg2GravitonStar_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2GravitonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2GravitonStar_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma1gg2GravitonStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2GravitonStar * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma1gg2GravitonStar_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma1gg2GravitonStar_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma1gg2GravitonStar_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma1gg2GravitonStar_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2GravitonStar_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2GravitonStar *arg1 = (Pythia8::Sigma1gg2GravitonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gg2GravitonStar_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2GravitonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2GravitonStar_name" "', argument " "1"" of type '" "Pythia8::Sigma1gg2GravitonStar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2GravitonStar * >(argp1);
  result = ((Pythia8::Sigma1gg2GravitonStar const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2GravitonStar_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2GravitonStar *arg1 = (Pythia8::Sigma1gg2GravitonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gg2GravitonStar_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2GravitonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2GravitonStar_code" "', argument " "1"" of type '" "Pythia8::Sigma1gg2GravitonStar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2GravitonStar * >(argp1);
  result = (int)((Pythia8::Sigma1gg2GravitonStar const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2GravitonStar_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2GravitonStar *arg1 = (Pythia8::Sigma1gg2GravitonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gg2GravitonStar_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2GravitonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2GravitonStar_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma1gg2GravitonStar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2GravitonStar * >(argp1);
  result = ((Pythia8::Sigma1gg2GravitonStar const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2GravitonStar_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2GravitonStar *arg1 = (Pythia8::Sigma1gg2GravitonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gg2GravitonStar_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2GravitonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2GravitonStar_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma1gg2GravitonStar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2GravitonStar * >(argp1);
  result = (int)((Pythia8::Sigma1gg2GravitonStar const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma1gg2GravitonStar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2GravitonStar *arg1 = (Pythia8::Sigma1gg2GravitonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma1gg2GravitonStar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2GravitonStar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma1gg2GravitonStar" "', argument " "1"" of type '" "Pythia8::Sigma1gg2GravitonStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2GravitonStar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma1gg2GravitonStar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma1gg2GravitonStar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma1ffbar2GravitonStar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2GravitonStar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma1ffbar2GravitonStar")) SWIG_fail;
  result = (Pythia8::Sigma1ffbar2GravitonStar *)new Pythia8::Sigma1ffbar2GravitonStar();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma1ffbar2GravitonStar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2GravitonStar_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2GravitonStar *arg1 = (Pythia8::Sigma1ffbar2GravitonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2GravitonStar_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2GravitonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2GravitonStar_initProc" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2GravitonStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2GravitonStar * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2GravitonStar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2GravitonStar *arg1 = (Pythia8::Sigma1ffbar2GravitonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2GravitonStar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2GravitonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2GravitonStar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2GravitonStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2GravitonStar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2GravitonStar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2GravitonStar *arg1 = (Pythia8::Sigma1ffbar2GravitonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2GravitonStar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2GravitonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2GravitonStar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2GravitonStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2GravitonStar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2GravitonStar_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2GravitonStar *arg1 = (Pythia8::Sigma1ffbar2GravitonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2GravitonStar_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2GravitonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2GravitonStar_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2GravitonStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2GravitonStar * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2GravitonStar_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2GravitonStar *arg1 = (Pythia8::Sigma1ffbar2GravitonStar *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma1ffbar2GravitonStar_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2GravitonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2GravitonStar_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2GravitonStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2GravitonStar * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma1ffbar2GravitonStar_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma1ffbar2GravitonStar_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma1ffbar2GravitonStar_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma1ffbar2GravitonStar_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2GravitonStar_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2GravitonStar *arg1 = (Pythia8::Sigma1ffbar2GravitonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2GravitonStar_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2GravitonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2GravitonStar_name" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2GravitonStar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2GravitonStar * >(argp1);
  result = ((Pythia8::Sigma1ffbar2GravitonStar const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2GravitonStar_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2GravitonStar *arg1 = (Pythia8::Sigma1ffbar2GravitonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2GravitonStar_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2GravitonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2GravitonStar_code" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2GravitonStar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2GravitonStar * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2GravitonStar const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2GravitonStar_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2GravitonStar *arg1 = (Pythia8::Sigma1ffbar2GravitonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2GravitonStar_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2GravitonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2GravitonStar_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2GravitonStar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2GravitonStar * >(argp1);
  result = ((Pythia8::Sigma1ffbar2GravitonStar const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2GravitonStar_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2GravitonStar *arg1 = (Pythia8::Sigma1ffbar2GravitonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2GravitonStar_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2GravitonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2GravitonStar_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2GravitonStar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2GravitonStar * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2GravitonStar const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma1ffbar2GravitonStar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2GravitonStar *arg1 = (Pythia8::Sigma1ffbar2GravitonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma1ffbar2GravitonStar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2GravitonStar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma1ffbar2GravitonStar" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2GravitonStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2GravitonStar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma1ffbar2GravitonStar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma1ffbar2GravitonStar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma1qqbar2KKgluonStar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qqbar2KKgluonStar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma1qqbar2KKgluonStar")) SWIG_fail;
  result = (Pythia8::Sigma1qqbar2KKgluonStar *)new Pythia8::Sigma1qqbar2KKgluonStar();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma1qqbar2KKgluonStar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qqbar2KKgluonStar_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qqbar2KKgluonStar *arg1 = (Pythia8::Sigma1qqbar2KKgluonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qqbar2KKgluonStar_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qqbar2KKgluonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qqbar2KKgluonStar_initProc" "', argument " "1"" of type '" "Pythia8::Sigma1qqbar2KKgluonStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qqbar2KKgluonStar * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qqbar2KKgluonStar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qqbar2KKgluonStar *arg1 = (Pythia8::Sigma1qqbar2KKgluonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qqbar2KKgluonStar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qqbar2KKgluonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qqbar2KKgluonStar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma1qqbar2KKgluonStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qqbar2KKgluonStar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qqbar2KKgluonStar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qqbar2KKgluonStar *arg1 = (Pythia8::Sigma1qqbar2KKgluonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qqbar2KKgluonStar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qqbar2KKgluonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qqbar2KKgluonStar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma1qqbar2KKgluonStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qqbar2KKgluonStar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qqbar2KKgluonStar_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qqbar2KKgluonStar *arg1 = (Pythia8::Sigma1qqbar2KKgluonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qqbar2KKgluonStar_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qqbar2KKgluonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qqbar2KKgluonStar_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma1qqbar2KKgluonStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qqbar2KKgluonStar * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qqbar2KKgluonStar_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qqbar2KKgluonStar *arg1 = (Pythia8::Sigma1qqbar2KKgluonStar *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma1qqbar2KKgluonStar_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qqbar2KKgluonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qqbar2KKgluonStar_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma1qqbar2KKgluonStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qqbar2KKgluonStar * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma1qqbar2KKgluonStar_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma1qqbar2KKgluonStar_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma1qqbar2KKgluonStar_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma1qqbar2KKgluonStar_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qqbar2KKgluonStar_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qqbar2KKgluonStar *arg1 = (Pythia8::Sigma1qqbar2KKgluonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qqbar2KKgluonStar_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qqbar2KKgluonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qqbar2KKgluonStar_name" "', argument " "1"" of type '" "Pythia8::Sigma1qqbar2KKgluonStar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qqbar2KKgluonStar * >(argp1);
  result = ((Pythia8::Sigma1qqbar2KKgluonStar const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qqbar2KKgluonStar_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qqbar2KKgluonStar *arg1 = (Pythia8::Sigma1qqbar2KKgluonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qqbar2KKgluonStar_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qqbar2KKgluonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qqbar2KKgluonStar_code" "', argument " "1"" of type '" "Pythia8::Sigma1qqbar2KKgluonStar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qqbar2KKgluonStar * >(argp1);
  result = (int)((Pythia8::Sigma1qqbar2KKgluonStar const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qqbar2KKgluonStar_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qqbar2KKgluonStar *arg1 = (Pythia8::Sigma1qqbar2KKgluonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qqbar2KKgluonStar_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qqbar2KKgluonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qqbar2KKgluonStar_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma1qqbar2KKgluonStar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qqbar2KKgluonStar * >(argp1);
  result = ((Pythia8::Sigma1qqbar2KKgluonStar const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qqbar2KKgluonStar_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qqbar2KKgluonStar *arg1 = (Pythia8::Sigma1qqbar2KKgluonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qqbar2KKgluonStar_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qqbar2KKgluonStar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qqbar2KKgluonStar_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma1qqbar2KKgluonStar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qqbar2KKgluonStar * >(argp1);
  result = (int)((Pythia8::Sigma1qqbar2KKgluonStar const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma1qqbar2KKgluonStar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qqbar2KKgluonStar *arg1 = (Pythia8::Sigma1qqbar2KKgluonStar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma1qqbar2KKgluonStar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qqbar2KKgluonStar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma1qqbar2KKgluonStar" "', argument " "1"" of type '" "Pythia8::Sigma1qqbar2KKgluonStar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qqbar2KKgluonStar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma1qqbar2KKgluonStar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma1qqbar2KKgluonStar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2gg2GravitonStarg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2GravitonStarg *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2gg2GravitonStarg")) SWIG_fail;
  result = (Pythia8::Sigma2gg2GravitonStarg *)new Pythia8::Sigma2gg2GravitonStarg();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gg2GravitonStarg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2GravitonStarg_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2GravitonStarg *arg1 = (Pythia8::Sigma2gg2GravitonStarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2GravitonStarg_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2GravitonStarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2GravitonStarg_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2gg2GravitonStarg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2GravitonStarg * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2GravitonStarg_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2GravitonStarg *arg1 = (Pythia8::Sigma2gg2GravitonStarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2GravitonStarg_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2GravitonStarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2GravitonStarg_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2gg2GravitonStarg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2GravitonStarg * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2GravitonStarg_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2GravitonStarg *arg1 = (Pythia8::Sigma2gg2GravitonStarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2GravitonStarg_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2GravitonStarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2GravitonStarg_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2gg2GravitonStarg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2GravitonStarg * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2GravitonStarg_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2GravitonStarg *arg1 = (Pythia8::Sigma2gg2GravitonStarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2GravitonStarg_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2GravitonStarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2GravitonStarg_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2gg2GravitonStarg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2GravitonStarg * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2GravitonStarg_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2GravitonStarg *arg1 = (Pythia8::Sigma2gg2GravitonStarg *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2gg2GravitonStarg_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2GravitonStarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2GravitonStarg_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2gg2GravitonStarg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2GravitonStarg * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2gg2GravitonStarg_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2gg2GravitonStarg_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2gg2GravitonStarg_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2gg2GravitonStarg_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2GravitonStarg_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2GravitonStarg *arg1 = (Pythia8::Sigma2gg2GravitonStarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2GravitonStarg_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2GravitonStarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2GravitonStarg_name" "', argument " "1"" of type '" "Pythia8::Sigma2gg2GravitonStarg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2GravitonStarg * >(argp1);
  result = ((Pythia8::Sigma2gg2GravitonStarg const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2GravitonStarg_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2GravitonStarg *arg1 = (Pythia8::Sigma2gg2GravitonStarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2GravitonStarg_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2GravitonStarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2GravitonStarg_code" "', argument " "1"" of type '" "Pythia8::Sigma2gg2GravitonStarg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2GravitonStarg * >(argp1);
  result = (int)((Pythia8::Sigma2gg2GravitonStarg const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2GravitonStarg_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2GravitonStarg *arg1 = (Pythia8::Sigma2gg2GravitonStarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2GravitonStarg_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2GravitonStarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2GravitonStarg_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2gg2GravitonStarg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2GravitonStarg * >(argp1);
  result = ((Pythia8::Sigma2gg2GravitonStarg const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2GravitonStarg_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2GravitonStarg *arg1 = (Pythia8::Sigma2gg2GravitonStarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2GravitonStarg_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2GravitonStarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2GravitonStarg_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2gg2GravitonStarg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2GravitonStarg * >(argp1);
  result = (int)((Pythia8::Sigma2gg2GravitonStarg const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2gg2GravitonStarg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2GravitonStarg *arg1 = (Pythia8::Sigma2gg2GravitonStarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2gg2GravitonStarg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2GravitonStarg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2gg2GravitonStarg" "', argument " "1"" of type '" "Pythia8::Sigma2gg2GravitonStarg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2GravitonStarg * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2gg2GravitonStarg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2gg2GravitonStarg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qg2GravitonStarq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2GravitonStarq *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qg2GravitonStarq")) SWIG_fail;
  result = (Pythia8::Sigma2qg2GravitonStarq *)new Pythia8::Sigma2qg2GravitonStarq();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qg2GravitonStarq, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2GravitonStarq_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2GravitonStarq *arg1 = (Pythia8::Sigma2qg2GravitonStarq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2GravitonStarq_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2GravitonStarq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2GravitonStarq_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qg2GravitonStarq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2GravitonStarq * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2GravitonStarq_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2GravitonStarq *arg1 = (Pythia8::Sigma2qg2GravitonStarq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2GravitonStarq_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2GravitonStarq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2GravitonStarq_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qg2GravitonStarq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2GravitonStarq * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2GravitonStarq_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2GravitonStarq *arg1 = (Pythia8::Sigma2qg2GravitonStarq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2GravitonStarq_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2GravitonStarq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2GravitonStarq_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qg2GravitonStarq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2GravitonStarq * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2GravitonStarq_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2GravitonStarq *arg1 = (Pythia8::Sigma2qg2GravitonStarq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2GravitonStarq_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2GravitonStarq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2GravitonStarq_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qg2GravitonStarq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2GravitonStarq * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2GravitonStarq_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2GravitonStarq *arg1 = (Pythia8::Sigma2qg2GravitonStarq *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2qg2GravitonStarq_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2GravitonStarq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2GravitonStarq_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2qg2GravitonStarq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2GravitonStarq * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2qg2GravitonStarq_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2qg2GravitonStarq_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2qg2GravitonStarq_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2qg2GravitonStarq_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2GravitonStarq_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2GravitonStarq *arg1 = (Pythia8::Sigma2qg2GravitonStarq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2GravitonStarq_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2GravitonStarq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2GravitonStarq_name" "', argument " "1"" of type '" "Pythia8::Sigma2qg2GravitonStarq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2GravitonStarq * >(argp1);
  result = ((Pythia8::Sigma2qg2GravitonStarq const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2GravitonStarq_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2GravitonStarq *arg1 = (Pythia8::Sigma2qg2GravitonStarq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2GravitonStarq_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2GravitonStarq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2GravitonStarq_code" "', argument " "1"" of type '" "Pythia8::Sigma2qg2GravitonStarq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2GravitonStarq * >(argp1);
  result = (int)((Pythia8::Sigma2qg2GravitonStarq const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2GravitonStarq_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2GravitonStarq *arg1 = (Pythia8::Sigma2qg2GravitonStarq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2GravitonStarq_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2GravitonStarq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2GravitonStarq_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qg2GravitonStarq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2GravitonStarq * >(argp1);
  result = ((Pythia8::Sigma2qg2GravitonStarq const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2GravitonStarq_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2GravitonStarq *arg1 = (Pythia8::Sigma2qg2GravitonStarq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2GravitonStarq_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2GravitonStarq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2GravitonStarq_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qg2GravitonStarq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2GravitonStarq * >(argp1);
  result = (int)((Pythia8::Sigma2qg2GravitonStarq const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qg2GravitonStarq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2GravitonStarq *arg1 = (Pythia8::Sigma2qg2GravitonStarq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qg2GravitonStarq",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2GravitonStarq, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qg2GravitonStarq" "', argument " "1"" of type '" "Pythia8::Sigma2qg2GravitonStarq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2GravitonStarq * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qg2GravitonStarq_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qg2GravitonStarq, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2GravitonStarg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2GravitonStarg *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qqbar2GravitonStarg")) SWIG_fail;
  result = (Pythia8::Sigma2qqbar2GravitonStarg *)new Pythia8::Sigma2qqbar2GravitonStarg();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2GravitonStarg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2GravitonStarg_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2GravitonStarg *arg1 = (Pythia8::Sigma2qqbar2GravitonStarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2GravitonStarg_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2GravitonStarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2GravitonStarg_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2GravitonStarg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2GravitonStarg * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2GravitonStarg_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2GravitonStarg *arg1 = (Pythia8::Sigma2qqbar2GravitonStarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2GravitonStarg_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2GravitonStarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2GravitonStarg_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2GravitonStarg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2GravitonStarg * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2GravitonStarg_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2GravitonStarg *arg1 = (Pythia8::Sigma2qqbar2GravitonStarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2GravitonStarg_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2GravitonStarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2GravitonStarg_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2GravitonStarg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2GravitonStarg * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2GravitonStarg_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2GravitonStarg *arg1 = (Pythia8::Sigma2qqbar2GravitonStarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2GravitonStarg_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2GravitonStarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2GravitonStarg_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2GravitonStarg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2GravitonStarg * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2GravitonStarg_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2GravitonStarg *arg1 = (Pythia8::Sigma2qqbar2GravitonStarg *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2qqbar2GravitonStarg_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2GravitonStarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2GravitonStarg_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2GravitonStarg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2GravitonStarg * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2qqbar2GravitonStarg_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2qqbar2GravitonStarg_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2qqbar2GravitonStarg_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2qqbar2GravitonStarg_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2GravitonStarg_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2GravitonStarg *arg1 = (Pythia8::Sigma2qqbar2GravitonStarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2GravitonStarg_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2GravitonStarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2GravitonStarg_name" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2GravitonStarg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2GravitonStarg * >(argp1);
  result = ((Pythia8::Sigma2qqbar2GravitonStarg const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2GravitonStarg_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2GravitonStarg *arg1 = (Pythia8::Sigma2qqbar2GravitonStarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2GravitonStarg_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2GravitonStarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2GravitonStarg_code" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2GravitonStarg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2GravitonStarg * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2GravitonStarg const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2GravitonStarg_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2GravitonStarg *arg1 = (Pythia8::Sigma2qqbar2GravitonStarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2GravitonStarg_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2GravitonStarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2GravitonStarg_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2GravitonStarg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2GravitonStarg * >(argp1);
  result = ((Pythia8::Sigma2qqbar2GravitonStarg const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2GravitonStarg_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2GravitonStarg *arg1 = (Pythia8::Sigma2qqbar2GravitonStarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2GravitonStarg_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2GravitonStarg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2GravitonStarg_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2GravitonStarg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2GravitonStarg * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2GravitonStarg const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2GravitonStarg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2GravitonStarg *arg1 = (Pythia8::Sigma2qqbar2GravitonStarg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2GravitonStarg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2GravitonStarg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2GravitonStarg" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2GravitonStarg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2GravitonStarg * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2GravitonStarg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2GravitonStarg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2TEVffbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Sigma2ffbar2TEVffbar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Sigma2ffbar2TEVffbar",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2ffbar2TEVffbar" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2ffbar2TEVffbar" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::Sigma2ffbar2TEVffbar *)new Pythia8::Sigma2ffbar2TEVffbar(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2TEVffbar_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2TEVffbar *arg1 = (Pythia8::Sigma2ffbar2TEVffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2TEVffbar_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2TEVffbar_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2TEVffbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2TEVffbar * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2TEVffbar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2TEVffbar *arg1 = (Pythia8::Sigma2ffbar2TEVffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2TEVffbar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2TEVffbar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2TEVffbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2TEVffbar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2TEVffbar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2TEVffbar *arg1 = (Pythia8::Sigma2ffbar2TEVffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2TEVffbar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2TEVffbar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2TEVffbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2TEVffbar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2TEVffbar_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2TEVffbar *arg1 = (Pythia8::Sigma2ffbar2TEVffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2TEVffbar_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2TEVffbar_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2TEVffbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2TEVffbar * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2TEVffbar_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2TEVffbar *arg1 = (Pythia8::Sigma2ffbar2TEVffbar *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2ffbar2TEVffbar_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2TEVffbar_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2TEVffbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2TEVffbar * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2ffbar2TEVffbar_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2ffbar2TEVffbar_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2ffbar2TEVffbar_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2ffbar2TEVffbar_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2TEVffbar_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2TEVffbar *arg1 = (Pythia8::Sigma2ffbar2TEVffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2TEVffbar_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2TEVffbar_name" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2TEVffbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2TEVffbar * >(argp1);
  result = ((Pythia8::Sigma2ffbar2TEVffbar const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2TEVffbar_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2TEVffbar *arg1 = (Pythia8::Sigma2ffbar2TEVffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2TEVffbar_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2TEVffbar_code" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2TEVffbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2TEVffbar * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2TEVffbar const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2TEVffbar_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2TEVffbar *arg1 = (Pythia8::Sigma2ffbar2TEVffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2TEVffbar_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2TEVffbar_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2TEVffbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2TEVffbar * >(argp1);
  result = ((Pythia8::Sigma2ffbar2TEVffbar const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2TEVffbar_isSChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2TEVffbar *arg1 = (Pythia8::Sigma2ffbar2TEVffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2TEVffbar_isSChannel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2TEVffbar_isSChannel" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2TEVffbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2TEVffbar * >(argp1);
  result = (bool)((Pythia8::Sigma2ffbar2TEVffbar const *)arg1)->isSChannel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2TEVffbar_idSChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2TEVffbar *arg1 = (Pythia8::Sigma2ffbar2TEVffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2TEVffbar_idSChannel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2TEVffbar_idSChannel" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2TEVffbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2TEVffbar * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2TEVffbar const *)arg1)->idSChannel();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2TEVffbar_resonanceA__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2TEVffbar *arg1 = (Pythia8::Sigma2ffbar2TEVffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2TEVffbar_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2TEVffbar_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2TEVffbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2TEVffbar * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2TEVffbar const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2TEVffbar_resonanceB__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2TEVffbar *arg1 = (Pythia8::Sigma2ffbar2TEVffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2TEVffbar_resonanceB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2TEVffbar_resonanceB" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2TEVffbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2TEVffbar * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2TEVffbar const *)arg1)->resonanceB();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2TEVffbar_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2TEVffbar *arg1 = (Pythia8::Sigma2ffbar2TEVffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2TEVffbar_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2TEVffbar_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2TEVffbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2TEVffbar * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2TEVffbar const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2TEVffbar_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2TEVffbar *arg1 = (Pythia8::Sigma2ffbar2TEVffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2TEVffbar_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2TEVffbar_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2TEVffbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2TEVffbar * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2TEVffbar const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2TEVffbar_resonanceA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2TEVffbar *arg1 = (Pythia8::Sigma2ffbar2TEVffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2TEVffbar_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2TEVffbar_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2TEVffbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2TEVffbar * >(argp1);
  result = (int)(arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2TEVffbar_resonanceA(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Sigma2ffbar2TEVffbar_resonanceA__SWIG_1(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Sigma2ffbar2TEVffbar_resonanceA__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Sigma2ffbar2TEVffbar_resonanceA'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Sigma2ffbar2TEVffbar::resonanceA() const\n"
    "    Pythia8::Sigma2ffbar2TEVffbar::resonanceA()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2TEVffbar_resonanceB__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2TEVffbar *arg1 = (Pythia8::Sigma2ffbar2TEVffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2TEVffbar_resonanceB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2TEVffbar_resonanceB" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2TEVffbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2TEVffbar * >(argp1);
  result = (int)(arg1)->resonanceB();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2TEVffbar_resonanceB(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Sigma2ffbar2TEVffbar_resonanceB__SWIG_1(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Sigma2ffbar2TEVffbar_resonanceB__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Sigma2ffbar2TEVffbar_resonanceB'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Sigma2ffbar2TEVffbar::resonanceB() const\n"
    "    Pythia8::Sigma2ffbar2TEVffbar::resonanceB()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbar2TEVffbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2TEVffbar *arg1 = (Pythia8::Sigma2ffbar2TEVffbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbar2TEVffbar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbar2TEVffbar" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2TEVffbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2TEVffbar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbar2TEVffbar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbar2TEVffbar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2gg2LEDUnparticleg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma2gg2LEDUnparticleg *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma2gg2LEDUnparticleg",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2gg2LEDUnparticleg" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  result = (Pythia8::Sigma2gg2LEDUnparticleg *)new Pythia8::Sigma2gg2LEDUnparticleg(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gg2LEDUnparticleg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDUnparticleg_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDUnparticleg *arg1 = (Pythia8::Sigma2gg2LEDUnparticleg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDUnparticleg_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDUnparticleg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDUnparticleg_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDUnparticleg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDUnparticleg * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDUnparticleg_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDUnparticleg *arg1 = (Pythia8::Sigma2gg2LEDUnparticleg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDUnparticleg_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDUnparticleg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDUnparticleg_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDUnparticleg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDUnparticleg * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDUnparticleg_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDUnparticleg *arg1 = (Pythia8::Sigma2gg2LEDUnparticleg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDUnparticleg_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDUnparticleg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDUnparticleg_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDUnparticleg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDUnparticleg * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDUnparticleg_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDUnparticleg *arg1 = (Pythia8::Sigma2gg2LEDUnparticleg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDUnparticleg_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDUnparticleg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDUnparticleg_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDUnparticleg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDUnparticleg * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDUnparticleg_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDUnparticleg *arg1 = (Pythia8::Sigma2gg2LEDUnparticleg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDUnparticleg_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDUnparticleg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDUnparticleg_name" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDUnparticleg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDUnparticleg * >(argp1);
  result = ((Pythia8::Sigma2gg2LEDUnparticleg const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDUnparticleg_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDUnparticleg *arg1 = (Pythia8::Sigma2gg2LEDUnparticleg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDUnparticleg_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDUnparticleg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDUnparticleg_code" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDUnparticleg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDUnparticleg * >(argp1);
  result = (int)((Pythia8::Sigma2gg2LEDUnparticleg const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDUnparticleg_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDUnparticleg *arg1 = (Pythia8::Sigma2gg2LEDUnparticleg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDUnparticleg_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDUnparticleg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDUnparticleg_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDUnparticleg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDUnparticleg * >(argp1);
  result = ((Pythia8::Sigma2gg2LEDUnparticleg const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDUnparticleg_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDUnparticleg *arg1 = (Pythia8::Sigma2gg2LEDUnparticleg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDUnparticleg_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDUnparticleg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDUnparticleg_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDUnparticleg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDUnparticleg * >(argp1);
  result = (int)((Pythia8::Sigma2gg2LEDUnparticleg const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDUnparticleg_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDUnparticleg *arg1 = (Pythia8::Sigma2gg2LEDUnparticleg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDUnparticleg_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDUnparticleg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDUnparticleg_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDUnparticleg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDUnparticleg * >(argp1);
  result = (int)((Pythia8::Sigma2gg2LEDUnparticleg const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2gg2LEDUnparticleg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDUnparticleg *arg1 = (Pythia8::Sigma2gg2LEDUnparticleg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2gg2LEDUnparticleg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDUnparticleg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2gg2LEDUnparticleg" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDUnparticleg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDUnparticleg * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2gg2LEDUnparticleg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2gg2LEDUnparticleg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qg2LEDUnparticleq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma2qg2LEDUnparticleq *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma2qg2LEDUnparticleq",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qg2LEDUnparticleq" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  result = (Pythia8::Sigma2qg2LEDUnparticleq *)new Pythia8::Sigma2qg2LEDUnparticleq(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qg2LEDUnparticleq, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2LEDUnparticleq_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LEDUnparticleq *arg1 = (Pythia8::Sigma2qg2LEDUnparticleq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2LEDUnparticleq_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LEDUnparticleq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2LEDUnparticleq_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LEDUnparticleq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LEDUnparticleq * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2LEDUnparticleq_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LEDUnparticleq *arg1 = (Pythia8::Sigma2qg2LEDUnparticleq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2LEDUnparticleq_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LEDUnparticleq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2LEDUnparticleq_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LEDUnparticleq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LEDUnparticleq * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2LEDUnparticleq_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LEDUnparticleq *arg1 = (Pythia8::Sigma2qg2LEDUnparticleq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2LEDUnparticleq_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LEDUnparticleq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2LEDUnparticleq_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LEDUnparticleq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LEDUnparticleq * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2LEDUnparticleq_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LEDUnparticleq *arg1 = (Pythia8::Sigma2qg2LEDUnparticleq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2LEDUnparticleq_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LEDUnparticleq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2LEDUnparticleq_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LEDUnparticleq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LEDUnparticleq * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2LEDUnparticleq_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LEDUnparticleq *arg1 = (Pythia8::Sigma2qg2LEDUnparticleq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2LEDUnparticleq_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LEDUnparticleq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2LEDUnparticleq_name" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LEDUnparticleq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LEDUnparticleq * >(argp1);
  result = ((Pythia8::Sigma2qg2LEDUnparticleq const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2LEDUnparticleq_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LEDUnparticleq *arg1 = (Pythia8::Sigma2qg2LEDUnparticleq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2LEDUnparticleq_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LEDUnparticleq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2LEDUnparticleq_code" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LEDUnparticleq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LEDUnparticleq * >(argp1);
  result = (int)((Pythia8::Sigma2qg2LEDUnparticleq const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2LEDUnparticleq_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LEDUnparticleq *arg1 = (Pythia8::Sigma2qg2LEDUnparticleq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2LEDUnparticleq_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LEDUnparticleq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2LEDUnparticleq_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LEDUnparticleq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LEDUnparticleq * >(argp1);
  result = ((Pythia8::Sigma2qg2LEDUnparticleq const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2LEDUnparticleq_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LEDUnparticleq *arg1 = (Pythia8::Sigma2qg2LEDUnparticleq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2LEDUnparticleq_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LEDUnparticleq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2LEDUnparticleq_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LEDUnparticleq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LEDUnparticleq * >(argp1);
  result = (int)((Pythia8::Sigma2qg2LEDUnparticleq const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qg2LEDUnparticleq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LEDUnparticleq *arg1 = (Pythia8::Sigma2qg2LEDUnparticleq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qg2LEDUnparticleq",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LEDUnparticleq, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qg2LEDUnparticleq" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LEDUnparticleq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LEDUnparticleq * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qg2LEDUnparticleq_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qg2LEDUnparticleq, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2LEDUnparticleg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma2qqbar2LEDUnparticleg *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma2qqbar2LEDUnparticleg",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qqbar2LEDUnparticleg" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  result = (Pythia8::Sigma2qqbar2LEDUnparticleg *)new Pythia8::Sigma2qqbar2LEDUnparticleg(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDUnparticleg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LEDUnparticleg_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDUnparticleg *arg1 = (Pythia8::Sigma2qqbar2LEDUnparticleg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LEDUnparticleg_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDUnparticleg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LEDUnparticleg_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDUnparticleg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDUnparticleg * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LEDUnparticleg_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDUnparticleg *arg1 = (Pythia8::Sigma2qqbar2LEDUnparticleg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LEDUnparticleg_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDUnparticleg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LEDUnparticleg_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDUnparticleg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDUnparticleg * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LEDUnparticleg_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDUnparticleg *arg1 = (Pythia8::Sigma2qqbar2LEDUnparticleg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LEDUnparticleg_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDUnparticleg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LEDUnparticleg_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDUnparticleg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDUnparticleg * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LEDUnparticleg_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDUnparticleg *arg1 = (Pythia8::Sigma2qqbar2LEDUnparticleg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LEDUnparticleg_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDUnparticleg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LEDUnparticleg_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDUnparticleg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDUnparticleg * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LEDUnparticleg_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDUnparticleg *arg1 = (Pythia8::Sigma2qqbar2LEDUnparticleg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LEDUnparticleg_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDUnparticleg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LEDUnparticleg_name" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDUnparticleg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDUnparticleg * >(argp1);
  result = ((Pythia8::Sigma2qqbar2LEDUnparticleg const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LEDUnparticleg_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDUnparticleg *arg1 = (Pythia8::Sigma2qqbar2LEDUnparticleg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LEDUnparticleg_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDUnparticleg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LEDUnparticleg_code" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDUnparticleg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDUnparticleg * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2LEDUnparticleg const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LEDUnparticleg_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDUnparticleg *arg1 = (Pythia8::Sigma2qqbar2LEDUnparticleg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LEDUnparticleg_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDUnparticleg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LEDUnparticleg_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDUnparticleg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDUnparticleg * >(argp1);
  result = ((Pythia8::Sigma2qqbar2LEDUnparticleg const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LEDUnparticleg_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDUnparticleg *arg1 = (Pythia8::Sigma2qqbar2LEDUnparticleg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LEDUnparticleg_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDUnparticleg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LEDUnparticleg_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDUnparticleg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDUnparticleg * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2LEDUnparticleg const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LEDUnparticleg_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDUnparticleg *arg1 = (Pythia8::Sigma2qqbar2LEDUnparticleg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LEDUnparticleg_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDUnparticleg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LEDUnparticleg_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDUnparticleg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDUnparticleg * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2LEDUnparticleg const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2LEDUnparticleg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDUnparticleg *arg1 = (Pythia8::Sigma2qqbar2LEDUnparticleg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2LEDUnparticleg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDUnparticleg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2LEDUnparticleg" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDUnparticleg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDUnparticleg * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2LEDUnparticleg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDUnparticleg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2LEDUnparticleZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma2ffbar2LEDUnparticleZ *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma2ffbar2LEDUnparticleZ",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2ffbar2LEDUnparticleZ" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  result = (Pythia8::Sigma2ffbar2LEDUnparticleZ *)new Pythia8::Sigma2ffbar2LEDUnparticleZ(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticleZ, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDUnparticleZ_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDUnparticleZ *arg1 = (Pythia8::Sigma2ffbar2LEDUnparticleZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDUnparticleZ_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticleZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDUnparticleZ_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDUnparticleZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDUnparticleZ * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDUnparticleZ_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDUnparticleZ *arg1 = (Pythia8::Sigma2ffbar2LEDUnparticleZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDUnparticleZ_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticleZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDUnparticleZ_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDUnparticleZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDUnparticleZ * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDUnparticleZ_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDUnparticleZ *arg1 = (Pythia8::Sigma2ffbar2LEDUnparticleZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDUnparticleZ_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticleZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDUnparticleZ_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDUnparticleZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDUnparticleZ * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDUnparticleZ_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDUnparticleZ *arg1 = (Pythia8::Sigma2ffbar2LEDUnparticleZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDUnparticleZ_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticleZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDUnparticleZ_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDUnparticleZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDUnparticleZ * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDUnparticleZ_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDUnparticleZ *arg1 = (Pythia8::Sigma2ffbar2LEDUnparticleZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDUnparticleZ_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticleZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDUnparticleZ_name" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDUnparticleZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDUnparticleZ * >(argp1);
  result = ((Pythia8::Sigma2ffbar2LEDUnparticleZ const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDUnparticleZ_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDUnparticleZ *arg1 = (Pythia8::Sigma2ffbar2LEDUnparticleZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDUnparticleZ_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticleZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDUnparticleZ_code" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDUnparticleZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDUnparticleZ * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2LEDUnparticleZ const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDUnparticleZ_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDUnparticleZ *arg1 = (Pythia8::Sigma2ffbar2LEDUnparticleZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDUnparticleZ_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticleZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDUnparticleZ_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDUnparticleZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDUnparticleZ * >(argp1);
  result = ((Pythia8::Sigma2ffbar2LEDUnparticleZ const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDUnparticleZ_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDUnparticleZ *arg1 = (Pythia8::Sigma2ffbar2LEDUnparticleZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDUnparticleZ_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticleZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDUnparticleZ_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDUnparticleZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDUnparticleZ * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2LEDUnparticleZ const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDUnparticleZ_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDUnparticleZ *arg1 = (Pythia8::Sigma2ffbar2LEDUnparticleZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDUnparticleZ_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticleZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDUnparticleZ_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDUnparticleZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDUnparticleZ * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2LEDUnparticleZ const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDUnparticleZ_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDUnparticleZ *arg1 = (Pythia8::Sigma2ffbar2LEDUnparticleZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDUnparticleZ_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticleZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDUnparticleZ_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDUnparticleZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDUnparticleZ * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2LEDUnparticleZ const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDUnparticleZ_gmZmode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDUnparticleZ *arg1 = (Pythia8::Sigma2ffbar2LEDUnparticleZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDUnparticleZ_gmZmode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticleZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDUnparticleZ_gmZmode" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDUnparticleZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDUnparticleZ * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2LEDUnparticleZ const *)arg1)->gmZmode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbar2LEDUnparticleZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDUnparticleZ *arg1 = (Pythia8::Sigma2ffbar2LEDUnparticleZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbar2LEDUnparticleZ",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticleZ, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbar2LEDUnparticleZ" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDUnparticleZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDUnparticleZ * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbar2LEDUnparticleZ_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticleZ, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2LEDUnparticlegamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma2ffbar2LEDUnparticlegamma *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma2ffbar2LEDUnparticlegamma",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2ffbar2LEDUnparticlegamma" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  result = (Pythia8::Sigma2ffbar2LEDUnparticlegamma *)new Pythia8::Sigma2ffbar2LEDUnparticlegamma(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticlegamma, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDUnparticlegamma_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDUnparticlegamma *arg1 = (Pythia8::Sigma2ffbar2LEDUnparticlegamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDUnparticlegamma_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticlegamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDUnparticlegamma_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDUnparticlegamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDUnparticlegamma * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDUnparticlegamma_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDUnparticlegamma *arg1 = (Pythia8::Sigma2ffbar2LEDUnparticlegamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDUnparticlegamma_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticlegamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDUnparticlegamma_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDUnparticlegamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDUnparticlegamma * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDUnparticlegamma_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDUnparticlegamma *arg1 = (Pythia8::Sigma2ffbar2LEDUnparticlegamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDUnparticlegamma_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticlegamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDUnparticlegamma_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDUnparticlegamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDUnparticlegamma * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDUnparticlegamma_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDUnparticlegamma *arg1 = (Pythia8::Sigma2ffbar2LEDUnparticlegamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDUnparticlegamma_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticlegamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDUnparticlegamma_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDUnparticlegamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDUnparticlegamma * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDUnparticlegamma_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDUnparticlegamma *arg1 = (Pythia8::Sigma2ffbar2LEDUnparticlegamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDUnparticlegamma_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticlegamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDUnparticlegamma_name" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDUnparticlegamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDUnparticlegamma * >(argp1);
  result = ((Pythia8::Sigma2ffbar2LEDUnparticlegamma const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDUnparticlegamma_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDUnparticlegamma *arg1 = (Pythia8::Sigma2ffbar2LEDUnparticlegamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDUnparticlegamma_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticlegamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDUnparticlegamma_code" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDUnparticlegamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDUnparticlegamma * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2LEDUnparticlegamma const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDUnparticlegamma_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDUnparticlegamma *arg1 = (Pythia8::Sigma2ffbar2LEDUnparticlegamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDUnparticlegamma_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticlegamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDUnparticlegamma_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDUnparticlegamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDUnparticlegamma * >(argp1);
  result = ((Pythia8::Sigma2ffbar2LEDUnparticlegamma const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDUnparticlegamma_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDUnparticlegamma *arg1 = (Pythia8::Sigma2ffbar2LEDUnparticlegamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDUnparticlegamma_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticlegamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDUnparticlegamma_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDUnparticlegamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDUnparticlegamma * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2LEDUnparticlegamma const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDUnparticlegamma_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDUnparticlegamma *arg1 = (Pythia8::Sigma2ffbar2LEDUnparticlegamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDUnparticlegamma_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticlegamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDUnparticlegamma_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDUnparticlegamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDUnparticlegamma * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2LEDUnparticlegamma const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbar2LEDUnparticlegamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDUnparticlegamma *arg1 = (Pythia8::Sigma2ffbar2LEDUnparticlegamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbar2LEDUnparticlegamma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticlegamma, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbar2LEDUnparticlegamma" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDUnparticlegamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDUnparticlegamma * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbar2LEDUnparticlegamma_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDUnparticlegamma, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2LEDgammagamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma2ffbar2LEDgammagamma *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma2ffbar2LEDgammagamma",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2ffbar2LEDgammagamma" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  result = (Pythia8::Sigma2ffbar2LEDgammagamma *)new Pythia8::Sigma2ffbar2LEDgammagamma(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDgammagamma, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDgammagamma_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDgammagamma *arg1 = (Pythia8::Sigma2ffbar2LEDgammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDgammagamma_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDgammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDgammagamma_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDgammagamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDgammagamma * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDgammagamma_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDgammagamma *arg1 = (Pythia8::Sigma2ffbar2LEDgammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDgammagamma_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDgammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDgammagamma_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDgammagamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDgammagamma * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDgammagamma_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDgammagamma *arg1 = (Pythia8::Sigma2ffbar2LEDgammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDgammagamma_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDgammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDgammagamma_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDgammagamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDgammagamma * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDgammagamma_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDgammagamma *arg1 = (Pythia8::Sigma2ffbar2LEDgammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDgammagamma_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDgammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDgammagamma_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDgammagamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDgammagamma * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDgammagamma_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDgammagamma *arg1 = (Pythia8::Sigma2ffbar2LEDgammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDgammagamma_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDgammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDgammagamma_name" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDgammagamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDgammagamma * >(argp1);
  result = ((Pythia8::Sigma2ffbar2LEDgammagamma const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDgammagamma_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDgammagamma *arg1 = (Pythia8::Sigma2ffbar2LEDgammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDgammagamma_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDgammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDgammagamma_code" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDgammagamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDgammagamma * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2LEDgammagamma const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDgammagamma_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDgammagamma *arg1 = (Pythia8::Sigma2ffbar2LEDgammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDgammagamma_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDgammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDgammagamma_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDgammagamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDgammagamma * >(argp1);
  result = ((Pythia8::Sigma2ffbar2LEDgammagamma const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbar2LEDgammagamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDgammagamma *arg1 = (Pythia8::Sigma2ffbar2LEDgammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbar2LEDgammagamma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDgammagamma, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbar2LEDgammagamma" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDgammagamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDgammagamma * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbar2LEDgammagamma_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDgammagamma, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2gg2LEDgammagamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma2gg2LEDgammagamma *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma2gg2LEDgammagamma",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2gg2LEDgammagamma" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  result = (Pythia8::Sigma2gg2LEDgammagamma *)new Pythia8::Sigma2gg2LEDgammagamma(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gg2LEDgammagamma, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDgammagamma_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDgammagamma *arg1 = (Pythia8::Sigma2gg2LEDgammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDgammagamma_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDgammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDgammagamma_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDgammagamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDgammagamma * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDgammagamma_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDgammagamma *arg1 = (Pythia8::Sigma2gg2LEDgammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDgammagamma_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDgammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDgammagamma_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDgammagamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDgammagamma * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDgammagamma_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDgammagamma *arg1 = (Pythia8::Sigma2gg2LEDgammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDgammagamma_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDgammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDgammagamma_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDgammagamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDgammagamma * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDgammagamma_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDgammagamma *arg1 = (Pythia8::Sigma2gg2LEDgammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDgammagamma_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDgammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDgammagamma_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDgammagamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDgammagamma * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDgammagamma_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDgammagamma *arg1 = (Pythia8::Sigma2gg2LEDgammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDgammagamma_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDgammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDgammagamma_name" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDgammagamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDgammagamma * >(argp1);
  result = ((Pythia8::Sigma2gg2LEDgammagamma const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDgammagamma_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDgammagamma *arg1 = (Pythia8::Sigma2gg2LEDgammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDgammagamma_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDgammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDgammagamma_code" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDgammagamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDgammagamma * >(argp1);
  result = (int)((Pythia8::Sigma2gg2LEDgammagamma const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDgammagamma_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDgammagamma *arg1 = (Pythia8::Sigma2gg2LEDgammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDgammagamma_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDgammagamma, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDgammagamma_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDgammagamma const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDgammagamma * >(argp1);
  result = ((Pythia8::Sigma2gg2LEDgammagamma const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2gg2LEDgammagamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDgammagamma *arg1 = (Pythia8::Sigma2gg2LEDgammagamma *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2gg2LEDgammagamma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDgammagamma, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2gg2LEDgammagamma" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDgammagamma *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDgammagamma * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2gg2LEDgammagamma_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2gg2LEDgammagamma, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2LEDllbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma2ffbar2LEDllbar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma2ffbar2LEDllbar",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2ffbar2LEDllbar" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  result = (Pythia8::Sigma2ffbar2LEDllbar *)new Pythia8::Sigma2ffbar2LEDllbar(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDllbar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDllbar_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDllbar *arg1 = (Pythia8::Sigma2ffbar2LEDllbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDllbar_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDllbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDllbar_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDllbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDllbar * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDllbar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDllbar *arg1 = (Pythia8::Sigma2ffbar2LEDllbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDllbar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDllbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDllbar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDllbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDllbar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDllbar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDllbar *arg1 = (Pythia8::Sigma2ffbar2LEDllbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDllbar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDllbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDllbar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDllbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDllbar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDllbar_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDllbar *arg1 = (Pythia8::Sigma2ffbar2LEDllbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDllbar_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDllbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDllbar_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDllbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDllbar * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDllbar_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDllbar *arg1 = (Pythia8::Sigma2ffbar2LEDllbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDllbar_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDllbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDllbar_name" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDllbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDllbar * >(argp1);
  result = ((Pythia8::Sigma2ffbar2LEDllbar const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDllbar_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDllbar *arg1 = (Pythia8::Sigma2ffbar2LEDllbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDllbar_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDllbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDllbar_code" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDllbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDllbar * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2LEDllbar const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDllbar_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDllbar *arg1 = (Pythia8::Sigma2ffbar2LEDllbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDllbar_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDllbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDllbar_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDllbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDllbar * >(argp1);
  result = ((Pythia8::Sigma2ffbar2LEDllbar const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2LEDllbar_isSChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDllbar *arg1 = (Pythia8::Sigma2ffbar2LEDllbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2LEDllbar_isSChannel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDllbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2LEDllbar_isSChannel" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDllbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDllbar * >(argp1);
  result = (bool)((Pythia8::Sigma2ffbar2LEDllbar const *)arg1)->isSChannel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbar2LEDllbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2LEDllbar *arg1 = (Pythia8::Sigma2ffbar2LEDllbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbar2LEDllbar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDllbar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbar2LEDllbar" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2LEDllbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2LEDllbar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbar2LEDllbar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbar2LEDllbar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2gg2LEDllbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma2gg2LEDllbar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma2gg2LEDllbar",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2gg2LEDllbar" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  result = (Pythia8::Sigma2gg2LEDllbar *)new Pythia8::Sigma2gg2LEDllbar(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gg2LEDllbar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDllbar_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDllbar *arg1 = (Pythia8::Sigma2gg2LEDllbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDllbar_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDllbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDllbar_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDllbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDllbar * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDllbar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDllbar *arg1 = (Pythia8::Sigma2gg2LEDllbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDllbar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDllbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDllbar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDllbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDllbar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDllbar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDllbar *arg1 = (Pythia8::Sigma2gg2LEDllbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDllbar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDllbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDllbar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDllbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDllbar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDllbar_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDllbar *arg1 = (Pythia8::Sigma2gg2LEDllbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDllbar_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDllbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDllbar_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDllbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDllbar * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDllbar_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDllbar *arg1 = (Pythia8::Sigma2gg2LEDllbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDllbar_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDllbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDllbar_name" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDllbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDllbar * >(argp1);
  result = ((Pythia8::Sigma2gg2LEDllbar const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDllbar_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDllbar *arg1 = (Pythia8::Sigma2gg2LEDllbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDllbar_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDllbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDllbar_code" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDllbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDllbar * >(argp1);
  result = (int)((Pythia8::Sigma2gg2LEDllbar const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDllbar_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDllbar *arg1 = (Pythia8::Sigma2gg2LEDllbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDllbar_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDllbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDllbar_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDllbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDllbar * >(argp1);
  result = ((Pythia8::Sigma2gg2LEDllbar const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2gg2LEDllbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDllbar *arg1 = (Pythia8::Sigma2gg2LEDllbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2gg2LEDllbar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDllbar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2gg2LEDllbar" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDllbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDllbar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2gg2LEDllbar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2gg2LEDllbar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2gg2LEDgg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDgg *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2gg2LEDgg")) SWIG_fail;
  result = (Pythia8::Sigma2gg2LEDgg *)new Pythia8::Sigma2gg2LEDgg();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gg2LEDgg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDgg_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDgg *arg1 = (Pythia8::Sigma2gg2LEDgg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDgg_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDgg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDgg_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDgg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDgg * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDgg_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDgg *arg1 = (Pythia8::Sigma2gg2LEDgg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDgg_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDgg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDgg_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDgg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDgg * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDgg_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDgg *arg1 = (Pythia8::Sigma2gg2LEDgg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDgg_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDgg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDgg_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDgg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDgg * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDgg_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDgg *arg1 = (Pythia8::Sigma2gg2LEDgg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDgg_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDgg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDgg_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDgg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDgg * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDgg_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDgg *arg1 = (Pythia8::Sigma2gg2LEDgg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDgg_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDgg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDgg_name" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDgg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDgg * >(argp1);
  result = ((Pythia8::Sigma2gg2LEDgg const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDgg_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDgg *arg1 = (Pythia8::Sigma2gg2LEDgg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDgg_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDgg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDgg_code" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDgg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDgg * >(argp1);
  result = (int)((Pythia8::Sigma2gg2LEDgg const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDgg_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDgg *arg1 = (Pythia8::Sigma2gg2LEDgg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDgg_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDgg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDgg_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDgg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDgg * >(argp1);
  result = ((Pythia8::Sigma2gg2LEDgg const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2gg2LEDgg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDgg *arg1 = (Pythia8::Sigma2gg2LEDgg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2gg2LEDgg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDgg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2gg2LEDgg" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDgg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDgg * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2gg2LEDgg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2gg2LEDgg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2gg2LEDqqbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDqqbar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2gg2LEDqqbar")) SWIG_fail;
  result = (Pythia8::Sigma2gg2LEDqqbar *)new Pythia8::Sigma2gg2LEDqqbar();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gg2LEDqqbar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDqqbar_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDqqbar *arg1 = (Pythia8::Sigma2gg2LEDqqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDqqbar_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDqqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDqqbar_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDqqbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDqqbar * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDqqbar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDqqbar *arg1 = (Pythia8::Sigma2gg2LEDqqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDqqbar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDqqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDqqbar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDqqbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDqqbar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDqqbar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDqqbar *arg1 = (Pythia8::Sigma2gg2LEDqqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDqqbar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDqqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDqqbar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDqqbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDqqbar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDqqbar_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDqqbar *arg1 = (Pythia8::Sigma2gg2LEDqqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDqqbar_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDqqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDqqbar_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDqqbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDqqbar * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDqqbar_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDqqbar *arg1 = (Pythia8::Sigma2gg2LEDqqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDqqbar_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDqqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDqqbar_name" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDqqbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDqqbar * >(argp1);
  result = ((Pythia8::Sigma2gg2LEDqqbar const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDqqbar_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDqqbar *arg1 = (Pythia8::Sigma2gg2LEDqqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDqqbar_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDqqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDqqbar_code" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDqqbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDqqbar * >(argp1);
  result = (int)((Pythia8::Sigma2gg2LEDqqbar const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LEDqqbar_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDqqbar *arg1 = (Pythia8::Sigma2gg2LEDqqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LEDqqbar_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDqqbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LEDqqbar_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDqqbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDqqbar * >(argp1);
  result = ((Pythia8::Sigma2gg2LEDqqbar const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2gg2LEDqqbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LEDqqbar *arg1 = (Pythia8::Sigma2gg2LEDqqbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2gg2LEDqqbar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LEDqqbar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2gg2LEDqqbar" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LEDqqbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LEDqqbar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2gg2LEDqqbar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2gg2LEDqqbar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qg2LEDqg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LEDqg *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qg2LEDqg")) SWIG_fail;
  result = (Pythia8::Sigma2qg2LEDqg *)new Pythia8::Sigma2qg2LEDqg();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qg2LEDqg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2LEDqg_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LEDqg *arg1 = (Pythia8::Sigma2qg2LEDqg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2LEDqg_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LEDqg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2LEDqg_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LEDqg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LEDqg * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2LEDqg_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LEDqg *arg1 = (Pythia8::Sigma2qg2LEDqg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2LEDqg_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LEDqg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2LEDqg_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LEDqg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LEDqg * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2LEDqg_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LEDqg *arg1 = (Pythia8::Sigma2qg2LEDqg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2LEDqg_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LEDqg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2LEDqg_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LEDqg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LEDqg * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2LEDqg_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LEDqg *arg1 = (Pythia8::Sigma2qg2LEDqg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2LEDqg_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LEDqg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2LEDqg_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LEDqg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LEDqg * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2LEDqg_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LEDqg *arg1 = (Pythia8::Sigma2qg2LEDqg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2LEDqg_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LEDqg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2LEDqg_name" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LEDqg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LEDqg * >(argp1);
  result = ((Pythia8::Sigma2qg2LEDqg const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2LEDqg_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LEDqg *arg1 = (Pythia8::Sigma2qg2LEDqg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2LEDqg_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LEDqg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2LEDqg_code" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LEDqg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LEDqg * >(argp1);
  result = (int)((Pythia8::Sigma2qg2LEDqg const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2LEDqg_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LEDqg *arg1 = (Pythia8::Sigma2qg2LEDqg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2LEDqg_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LEDqg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2LEDqg_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LEDqg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LEDqg * >(argp1);
  result = ((Pythia8::Sigma2qg2LEDqg const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qg2LEDqg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LEDqg *arg1 = (Pythia8::Sigma2qg2LEDqg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qg2LEDqg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LEDqg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qg2LEDqg" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LEDqg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LEDqg * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qg2LEDqg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qg2LEDqg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qq2LEDqq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2LEDqq *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qq2LEDqq")) SWIG_fail;
  result = (Pythia8::Sigma2qq2LEDqq *)new Pythia8::Sigma2qq2LEDqq();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qq2LEDqq, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2LEDqq_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2LEDqq *arg1 = (Pythia8::Sigma2qq2LEDqq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2LEDqq_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2LEDqq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2LEDqq_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qq2LEDqq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2LEDqq * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2LEDqq_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2LEDqq *arg1 = (Pythia8::Sigma2qq2LEDqq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2LEDqq_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2LEDqq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2LEDqq_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qq2LEDqq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2LEDqq * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2LEDqq_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2LEDqq *arg1 = (Pythia8::Sigma2qq2LEDqq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2LEDqq_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2LEDqq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2LEDqq_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qq2LEDqq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2LEDqq * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2LEDqq_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2LEDqq *arg1 = (Pythia8::Sigma2qq2LEDqq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2LEDqq_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2LEDqq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2LEDqq_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qq2LEDqq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2LEDqq * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2LEDqq_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2LEDqq *arg1 = (Pythia8::Sigma2qq2LEDqq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2LEDqq_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2LEDqq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2LEDqq_name" "', argument " "1"" of type '" "Pythia8::Sigma2qq2LEDqq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2LEDqq * >(argp1);
  result = ((Pythia8::Sigma2qq2LEDqq const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2LEDqq_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2LEDqq *arg1 = (Pythia8::Sigma2qq2LEDqq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2LEDqq_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2LEDqq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2LEDqq_code" "', argument " "1"" of type '" "Pythia8::Sigma2qq2LEDqq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2LEDqq * >(argp1);
  result = (int)((Pythia8::Sigma2qq2LEDqq const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2LEDqq_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2LEDqq *arg1 = (Pythia8::Sigma2qq2LEDqq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2LEDqq_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2LEDqq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2LEDqq_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qq2LEDqq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2LEDqq * >(argp1);
  result = ((Pythia8::Sigma2qq2LEDqq const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qq2LEDqq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2LEDqq *arg1 = (Pythia8::Sigma2qq2LEDqq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qq2LEDqq",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2LEDqq, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qq2LEDqq" "', argument " "1"" of type '" "Pythia8::Sigma2qq2LEDqq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2LEDqq * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qq2LEDqq_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qq2LEDqq, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2LEDgg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDgg *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qqbar2LEDgg")) SWIG_fail;
  result = (Pythia8::Sigma2qqbar2LEDgg *)new Pythia8::Sigma2qqbar2LEDgg();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDgg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LEDgg_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDgg *arg1 = (Pythia8::Sigma2qqbar2LEDgg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LEDgg_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDgg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LEDgg_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDgg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDgg * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LEDgg_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDgg *arg1 = (Pythia8::Sigma2qqbar2LEDgg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LEDgg_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDgg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LEDgg_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDgg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDgg * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LEDgg_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDgg *arg1 = (Pythia8::Sigma2qqbar2LEDgg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LEDgg_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDgg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LEDgg_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDgg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDgg * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LEDgg_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDgg *arg1 = (Pythia8::Sigma2qqbar2LEDgg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LEDgg_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDgg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LEDgg_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDgg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDgg * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LEDgg_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDgg *arg1 = (Pythia8::Sigma2qqbar2LEDgg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LEDgg_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDgg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LEDgg_name" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDgg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDgg * >(argp1);
  result = ((Pythia8::Sigma2qqbar2LEDgg const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LEDgg_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDgg *arg1 = (Pythia8::Sigma2qqbar2LEDgg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LEDgg_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDgg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LEDgg_code" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDgg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDgg * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2LEDgg const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LEDgg_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDgg *arg1 = (Pythia8::Sigma2qqbar2LEDgg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LEDgg_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDgg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LEDgg_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDgg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDgg * >(argp1);
  result = ((Pythia8::Sigma2qqbar2LEDgg const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2LEDgg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDgg *arg1 = (Pythia8::Sigma2qqbar2LEDgg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2LEDgg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDgg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2LEDgg" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDgg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDgg * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2LEDgg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDgg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2LEDqqbarNew(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDqqbarNew *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qqbar2LEDqqbarNew")) SWIG_fail;
  result = (Pythia8::Sigma2qqbar2LEDqqbarNew *)new Pythia8::Sigma2qqbar2LEDqqbarNew();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDqqbarNew, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LEDqqbarNew_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDqqbarNew *arg1 = (Pythia8::Sigma2qqbar2LEDqqbarNew *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LEDqqbarNew_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDqqbarNew, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LEDqqbarNew_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDqqbarNew *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDqqbarNew * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LEDqqbarNew_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDqqbarNew *arg1 = (Pythia8::Sigma2qqbar2LEDqqbarNew *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LEDqqbarNew_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDqqbarNew, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LEDqqbarNew_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDqqbarNew *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDqqbarNew * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LEDqqbarNew_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDqqbarNew *arg1 = (Pythia8::Sigma2qqbar2LEDqqbarNew *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LEDqqbarNew_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDqqbarNew, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LEDqqbarNew_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDqqbarNew *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDqqbarNew * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LEDqqbarNew_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDqqbarNew *arg1 = (Pythia8::Sigma2qqbar2LEDqqbarNew *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LEDqqbarNew_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDqqbarNew, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LEDqqbarNew_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDqqbarNew *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDqqbarNew * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LEDqqbarNew_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDqqbarNew *arg1 = (Pythia8::Sigma2qqbar2LEDqqbarNew *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LEDqqbarNew_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDqqbarNew, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LEDqqbarNew_name" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDqqbarNew const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDqqbarNew * >(argp1);
  result = ((Pythia8::Sigma2qqbar2LEDqqbarNew const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LEDqqbarNew_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDqqbarNew *arg1 = (Pythia8::Sigma2qqbar2LEDqqbarNew *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LEDqqbarNew_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDqqbarNew, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LEDqqbarNew_code" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDqqbarNew const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDqqbarNew * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2LEDqqbarNew const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LEDqqbarNew_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDqqbarNew *arg1 = (Pythia8::Sigma2qqbar2LEDqqbarNew *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LEDqqbarNew_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDqqbarNew, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LEDqqbarNew_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDqqbarNew const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDqqbarNew * >(argp1);
  result = ((Pythia8::Sigma2qqbar2LEDqqbarNew const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2LEDqqbarNew(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LEDqqbarNew *arg1 = (Pythia8::Sigma2qqbar2LEDqqbarNew *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2LEDqqbarNew",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDqqbarNew, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2LEDqqbarNew" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LEDqqbarNew *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LEDqqbarNew * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2LEDqqbarNew_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2LEDqqbarNew, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2gg2qGqGbar__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  std::string arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::Sigma2gg2qGqGbar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Sigma2gg2qGqGbar",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2gg2qGqGbar" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2gg2qGqGbar" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2gg2qGqGbar" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Sigma2gg2qGqGbar" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::Sigma2gg2qGqGbar *)new Pythia8::Sigma2gg2qGqGbar(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gg2qGqGbar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2gg2qGqGbar__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Sigma2gg2qGqGbar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Sigma2gg2qGqGbar",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2gg2qGqGbar" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2gg2qGqGbar" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2gg2qGqGbar" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::Sigma2gg2qGqGbar *)new Pythia8::Sigma2gg2qGqGbar(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gg2qGqGbar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2gg2qGqGbar(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Sigma2gg2qGqGbar__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_Sigma2gg2qGqGbar__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Sigma2gg2qGqGbar'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Sigma2gg2qGqGbar::Sigma2gg2qGqGbar(int,int,int,std::string)\n"
    "    Pythia8::Sigma2gg2qGqGbar::Sigma2gg2qGqGbar(int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2qGqGbar_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2qGqGbar *arg1 = (Pythia8::Sigma2gg2qGqGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2qGqGbar_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2qGqGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2qGqGbar_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2gg2qGqGbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2qGqGbar * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2qGqGbar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2qGqGbar *arg1 = (Pythia8::Sigma2gg2qGqGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2qGqGbar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2qGqGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2qGqGbar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2gg2qGqGbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2qGqGbar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2qGqGbar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2qGqGbar *arg1 = (Pythia8::Sigma2gg2qGqGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2qGqGbar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2qGqGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2qGqGbar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2gg2qGqGbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2qGqGbar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2qGqGbar_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2qGqGbar *arg1 = (Pythia8::Sigma2gg2qGqGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2qGqGbar_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2qGqGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2qGqGbar_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2gg2qGqGbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2qGqGbar * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2qGqGbar_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2qGqGbar *arg1 = (Pythia8::Sigma2gg2qGqGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2qGqGbar_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2qGqGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2qGqGbar_name" "', argument " "1"" of type '" "Pythia8::Sigma2gg2qGqGbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2qGqGbar * >(argp1);
  result = ((Pythia8::Sigma2gg2qGqGbar const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2qGqGbar_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2qGqGbar *arg1 = (Pythia8::Sigma2gg2qGqGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2qGqGbar_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2qGqGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2qGqGbar_code" "', argument " "1"" of type '" "Pythia8::Sigma2gg2qGqGbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2qGqGbar * >(argp1);
  result = (int)((Pythia8::Sigma2gg2qGqGbar const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2qGqGbar_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2qGqGbar *arg1 = (Pythia8::Sigma2gg2qGqGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2qGqGbar_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2qGqGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2qGqGbar_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2gg2qGqGbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2qGqGbar * >(argp1);
  result = ((Pythia8::Sigma2gg2qGqGbar const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2qGqGbar_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2qGqGbar *arg1 = (Pythia8::Sigma2gg2qGqGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2qGqGbar_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2qGqGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2qGqGbar_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2gg2qGqGbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2qGqGbar * >(argp1);
  result = (int)((Pythia8::Sigma2gg2qGqGbar const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2qGqGbar_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2qGqGbar *arg1 = (Pythia8::Sigma2gg2qGqGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2qGqGbar_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2qGqGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2qGqGbar_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2gg2qGqGbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2qGqGbar * >(argp1);
  result = (int)((Pythia8::Sigma2gg2qGqGbar const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2gg2qGqGbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2qGqGbar *arg1 = (Pythia8::Sigma2gg2qGqGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2gg2qGqGbar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2qGqGbar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2gg2qGqGbar" "', argument " "1"" of type '" "Pythia8::Sigma2gg2qGqGbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2qGqGbar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2gg2qGqGbar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2gg2qGqGbar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2qGqGbar__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  std::string arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::Sigma2qqbar2qGqGbar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Sigma2qqbar2qGqGbar",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qqbar2qGqGbar" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2qqbar2qGqGbar" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2qqbar2qGqGbar" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Sigma2qqbar2qGqGbar" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::Sigma2qqbar2qGqGbar *)new Pythia8::Sigma2qqbar2qGqGbar(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2qGqGbar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2qGqGbar__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Sigma2qqbar2qGqGbar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Sigma2qqbar2qGqGbar",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qqbar2qGqGbar" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2qqbar2qGqGbar" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2qqbar2qGqGbar" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::Sigma2qqbar2qGqGbar *)new Pythia8::Sigma2qqbar2qGqGbar(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2qGqGbar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2qGqGbar(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Sigma2qqbar2qGqGbar__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_Sigma2qqbar2qGqGbar__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Sigma2qqbar2qGqGbar'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Sigma2qqbar2qGqGbar::Sigma2qqbar2qGqGbar(int,int,int,std::string)\n"
    "    Pythia8::Sigma2qqbar2qGqGbar::Sigma2qqbar2qGqGbar(int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2qGqGbar_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2qGqGbar *arg1 = (Pythia8::Sigma2qqbar2qGqGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2qGqGbar_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2qGqGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2qGqGbar_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2qGqGbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2qGqGbar * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2qGqGbar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2qGqGbar *arg1 = (Pythia8::Sigma2qqbar2qGqGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2qGqGbar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2qGqGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2qGqGbar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2qGqGbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2qGqGbar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2qGqGbar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2qGqGbar *arg1 = (Pythia8::Sigma2qqbar2qGqGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2qGqGbar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2qGqGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2qGqGbar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2qGqGbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2qGqGbar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2qGqGbar_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2qGqGbar *arg1 = (Pythia8::Sigma2qqbar2qGqGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2qGqGbar_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2qGqGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2qGqGbar_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2qGqGbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2qGqGbar * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2qGqGbar_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2qGqGbar *arg1 = (Pythia8::Sigma2qqbar2qGqGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2qGqGbar_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2qGqGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2qGqGbar_name" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2qGqGbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2qGqGbar * >(argp1);
  result = ((Pythia8::Sigma2qqbar2qGqGbar const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2qGqGbar_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2qGqGbar *arg1 = (Pythia8::Sigma2qqbar2qGqGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2qGqGbar_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2qGqGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2qGqGbar_code" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2qGqGbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2qGqGbar * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2qGqGbar const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2qGqGbar_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2qGqGbar *arg1 = (Pythia8::Sigma2qqbar2qGqGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2qGqGbar_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2qGqGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2qGqGbar_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2qGqGbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2qGqGbar * >(argp1);
  result = ((Pythia8::Sigma2qqbar2qGqGbar const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2qGqGbar_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2qGqGbar *arg1 = (Pythia8::Sigma2qqbar2qGqGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2qGqGbar_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2qGqGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2qGqGbar_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2qGqGbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2qGqGbar * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2qGqGbar const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2qGqGbar_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2qGqGbar *arg1 = (Pythia8::Sigma2qqbar2qGqGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2qGqGbar_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2qGqGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2qGqGbar_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2qGqGbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2qGqGbar * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2qGqGbar const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2qGqGbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2qGqGbar *arg1 = (Pythia8::Sigma2qqbar2qGqGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2qGqGbar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2qGqGbar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2qGqGbar" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2qGqGbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2qGqGbar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2qGqGbar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2qGqGbar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2fGfGbar__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  std::string arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::Sigma2ffbar2fGfGbar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Sigma2ffbar2fGfGbar",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2ffbar2fGfGbar" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2ffbar2fGfGbar" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2ffbar2fGfGbar" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Sigma2ffbar2fGfGbar" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::Sigma2ffbar2fGfGbar *)new Pythia8::Sigma2ffbar2fGfGbar(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbar2fGfGbar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2fGfGbar__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Sigma2ffbar2fGfGbar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Sigma2ffbar2fGfGbar",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2ffbar2fGfGbar" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2ffbar2fGfGbar" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2ffbar2fGfGbar" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::Sigma2ffbar2fGfGbar *)new Pythia8::Sigma2ffbar2fGfGbar(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbar2fGfGbar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2fGfGbar(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Sigma2ffbar2fGfGbar__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_Sigma2ffbar2fGfGbar__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Sigma2ffbar2fGfGbar'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Sigma2ffbar2fGfGbar::Sigma2ffbar2fGfGbar(int,int,int,std::string)\n"
    "    Pythia8::Sigma2ffbar2fGfGbar::Sigma2ffbar2fGfGbar(int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2fGfGbar_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2fGfGbar *arg1 = (Pythia8::Sigma2ffbar2fGfGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2fGfGbar_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2fGfGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2fGfGbar_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2fGfGbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2fGfGbar * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2fGfGbar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2fGfGbar *arg1 = (Pythia8::Sigma2ffbar2fGfGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2fGfGbar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2fGfGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2fGfGbar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2fGfGbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2fGfGbar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2fGfGbar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2fGfGbar *arg1 = (Pythia8::Sigma2ffbar2fGfGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2fGfGbar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2fGfGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2fGfGbar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2fGfGbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2fGfGbar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2fGfGbar_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2fGfGbar *arg1 = (Pythia8::Sigma2ffbar2fGfGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2fGfGbar_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2fGfGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2fGfGbar_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2fGfGbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2fGfGbar * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2fGfGbar_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2fGfGbar *arg1 = (Pythia8::Sigma2ffbar2fGfGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2fGfGbar_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2fGfGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2fGfGbar_name" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2fGfGbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2fGfGbar * >(argp1);
  result = ((Pythia8::Sigma2ffbar2fGfGbar const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2fGfGbar_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2fGfGbar *arg1 = (Pythia8::Sigma2ffbar2fGfGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2fGfGbar_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2fGfGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2fGfGbar_code" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2fGfGbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2fGfGbar * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2fGfGbar const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2fGfGbar_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2fGfGbar *arg1 = (Pythia8::Sigma2ffbar2fGfGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2fGfGbar_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2fGfGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2fGfGbar_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2fGfGbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2fGfGbar * >(argp1);
  result = ((Pythia8::Sigma2ffbar2fGfGbar const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2fGfGbar_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2fGfGbar *arg1 = (Pythia8::Sigma2ffbar2fGfGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2fGfGbar_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2fGfGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2fGfGbar_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2fGfGbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2fGfGbar * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2fGfGbar const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2fGfGbar_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2fGfGbar *arg1 = (Pythia8::Sigma2ffbar2fGfGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2fGfGbar_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2fGfGbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2fGfGbar_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2fGfGbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2fGfGbar * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2fGfGbar const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbar2fGfGbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2fGfGbar *arg1 = (Pythia8::Sigma2ffbar2fGfGbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbar2fGfGbar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2fGfGbar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbar2fGfGbar" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2fGfGbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2fGfGbar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbar2fGfGbar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbar2fGfGbar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma1ffbar2Zv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Zv *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma1ffbar2Zv")) SWIG_fail;
  result = (Pythia8::Sigma1ffbar2Zv *)new Pythia8::Sigma1ffbar2Zv();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma1ffbar2Zv, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Zv_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Zv *arg1 = (Pythia8::Sigma1ffbar2Zv *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Zv_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Zv, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Zv_initProc" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Zv *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Zv * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Zv_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Zv *arg1 = (Pythia8::Sigma1ffbar2Zv *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Zv_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Zv, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Zv_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Zv *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Zv * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Zv_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Zv *arg1 = (Pythia8::Sigma1ffbar2Zv *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Zv_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Zv, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Zv_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Zv *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Zv * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Zv_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Zv *arg1 = (Pythia8::Sigma1ffbar2Zv *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Zv_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Zv, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Zv_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Zv *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Zv * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Zv_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Zv *arg1 = (Pythia8::Sigma1ffbar2Zv *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma1ffbar2Zv_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Zv, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Zv_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Zv *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Zv * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma1ffbar2Zv_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma1ffbar2Zv_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma1ffbar2Zv_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma1ffbar2Zv_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Zv_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Zv *arg1 = (Pythia8::Sigma1ffbar2Zv *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Zv_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Zv, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Zv_name" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Zv const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Zv * >(argp1);
  result = ((Pythia8::Sigma1ffbar2Zv const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Zv_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Zv *arg1 = (Pythia8::Sigma1ffbar2Zv *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Zv_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Zv, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Zv_code" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Zv const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Zv * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2Zv const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Zv_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Zv *arg1 = (Pythia8::Sigma1ffbar2Zv *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Zv_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Zv, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Zv_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Zv const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Zv * >(argp1);
  result = ((Pythia8::Sigma1ffbar2Zv const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Zv_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Zv *arg1 = (Pythia8::Sigma1ffbar2Zv *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Zv_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Zv, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Zv_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Zv const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Zv * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2Zv const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma1ffbar2Zv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Zv *arg1 = (Pythia8::Sigma1ffbar2Zv *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma1ffbar2Zv",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Zv, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma1ffbar2Zv" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Zv *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Zv * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma1ffbar2Zv_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma1ffbar2Zv, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma1ffbar2H(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma1ffbar2H *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma1ffbar2H",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma1ffbar2H" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Sigma1ffbar2H *)new Pythia8::Sigma1ffbar2H(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma1ffbar2H, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2H_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2H *arg1 = (Pythia8::Sigma1ffbar2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2H_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2H_initProc" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2H *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2H * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2H_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2H *arg1 = (Pythia8::Sigma1ffbar2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2H_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2H_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2H *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2H * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2H_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2H *arg1 = (Pythia8::Sigma1ffbar2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2H_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2H_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2H *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2H * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2H_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2H *arg1 = (Pythia8::Sigma1ffbar2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2H_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2H_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2H *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2H * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2H_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2H *arg1 = (Pythia8::Sigma1ffbar2H *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma1ffbar2H_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2H_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2H *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2H * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma1ffbar2H_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma1ffbar2H_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma1ffbar2H_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma1ffbar2H_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2H_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2H *arg1 = (Pythia8::Sigma1ffbar2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2H_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2H_name" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2H const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2H * >(argp1);
  result = ((Pythia8::Sigma1ffbar2H const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2H_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2H *arg1 = (Pythia8::Sigma1ffbar2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2H_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2H_code" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2H const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2H * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2H const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2H_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2H *arg1 = (Pythia8::Sigma1ffbar2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2H_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2H_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2H const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2H * >(argp1);
  result = ((Pythia8::Sigma1ffbar2H const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2H_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2H *arg1 = (Pythia8::Sigma1ffbar2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2H_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2H_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2H const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2H * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2H const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma1ffbar2H(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2H *arg1 = (Pythia8::Sigma1ffbar2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma1ffbar2H",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2H, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma1ffbar2H" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2H *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2H * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma1ffbar2H_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma1ffbar2H, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma1gg2H(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma1gg2H *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma1gg2H",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma1gg2H" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Sigma1gg2H *)new Pythia8::Sigma1gg2H(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma1gg2H, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2H_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2H *arg1 = (Pythia8::Sigma1gg2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gg2H_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2H_initProc" "', argument " "1"" of type '" "Pythia8::Sigma1gg2H *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2H * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2H_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2H *arg1 = (Pythia8::Sigma1gg2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gg2H_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2H_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma1gg2H *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2H * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2H_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2H *arg1 = (Pythia8::Sigma1gg2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gg2H_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2H_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma1gg2H *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2H * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2H_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2H *arg1 = (Pythia8::Sigma1gg2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gg2H_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2H_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma1gg2H *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2H * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2H_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2H *arg1 = (Pythia8::Sigma1gg2H *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma1gg2H_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2H_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma1gg2H *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2H * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma1gg2H_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma1gg2H_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma1gg2H_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma1gg2H_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2H_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2H *arg1 = (Pythia8::Sigma1gg2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gg2H_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2H_name" "', argument " "1"" of type '" "Pythia8::Sigma1gg2H const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2H * >(argp1);
  result = ((Pythia8::Sigma1gg2H const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2H_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2H *arg1 = (Pythia8::Sigma1gg2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gg2H_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2H_code" "', argument " "1"" of type '" "Pythia8::Sigma1gg2H const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2H * >(argp1);
  result = (int)((Pythia8::Sigma1gg2H const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2H_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2H *arg1 = (Pythia8::Sigma1gg2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gg2H_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2H_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma1gg2H const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2H * >(argp1);
  result = ((Pythia8::Sigma1gg2H const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gg2H_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2H *arg1 = (Pythia8::Sigma1gg2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gg2H_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gg2H_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma1gg2H const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2H * >(argp1);
  result = (int)((Pythia8::Sigma1gg2H const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma1gg2H(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gg2H *arg1 = (Pythia8::Sigma1gg2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma1gg2H",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gg2H, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma1gg2H" "', argument " "1"" of type '" "Pythia8::Sigma1gg2H *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gg2H * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma1gg2H_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma1gg2H, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma1gmgm2H(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma1gmgm2H *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma1gmgm2H",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma1gmgm2H" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Sigma1gmgm2H *)new Pythia8::Sigma1gmgm2H(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma1gmgm2H, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gmgm2H_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gmgm2H *arg1 = (Pythia8::Sigma1gmgm2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gmgm2H_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gmgm2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gmgm2H_initProc" "', argument " "1"" of type '" "Pythia8::Sigma1gmgm2H *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gmgm2H * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gmgm2H_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gmgm2H *arg1 = (Pythia8::Sigma1gmgm2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gmgm2H_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gmgm2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gmgm2H_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma1gmgm2H *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gmgm2H * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gmgm2H_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gmgm2H *arg1 = (Pythia8::Sigma1gmgm2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gmgm2H_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gmgm2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gmgm2H_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma1gmgm2H *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gmgm2H * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gmgm2H_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gmgm2H *arg1 = (Pythia8::Sigma1gmgm2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gmgm2H_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gmgm2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gmgm2H_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma1gmgm2H *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gmgm2H * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gmgm2H_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gmgm2H *arg1 = (Pythia8::Sigma1gmgm2H *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma1gmgm2H_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gmgm2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gmgm2H_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma1gmgm2H *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gmgm2H * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma1gmgm2H_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma1gmgm2H_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma1gmgm2H_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma1gmgm2H_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gmgm2H_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gmgm2H *arg1 = (Pythia8::Sigma1gmgm2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gmgm2H_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gmgm2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gmgm2H_name" "', argument " "1"" of type '" "Pythia8::Sigma1gmgm2H const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gmgm2H * >(argp1);
  result = ((Pythia8::Sigma1gmgm2H const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gmgm2H_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gmgm2H *arg1 = (Pythia8::Sigma1gmgm2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gmgm2H_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gmgm2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gmgm2H_code" "', argument " "1"" of type '" "Pythia8::Sigma1gmgm2H const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gmgm2H * >(argp1);
  result = (int)((Pythia8::Sigma1gmgm2H const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gmgm2H_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gmgm2H *arg1 = (Pythia8::Sigma1gmgm2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gmgm2H_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gmgm2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gmgm2H_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma1gmgm2H const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gmgm2H * >(argp1);
  result = ((Pythia8::Sigma1gmgm2H const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1gmgm2H_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gmgm2H *arg1 = (Pythia8::Sigma1gmgm2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1gmgm2H_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gmgm2H, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1gmgm2H_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma1gmgm2H const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gmgm2H * >(argp1);
  result = (int)((Pythia8::Sigma1gmgm2H const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma1gmgm2H(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1gmgm2H *arg1 = (Pythia8::Sigma1gmgm2H *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma1gmgm2H",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1gmgm2H, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma1gmgm2H" "', argument " "1"" of type '" "Pythia8::Sigma1gmgm2H *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1gmgm2H * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma1gmgm2H_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma1gmgm2H, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2HZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma2ffbar2HZ *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma2ffbar2HZ",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2ffbar2HZ" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Sigma2ffbar2HZ *)new Pythia8::Sigma2ffbar2HZ(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbar2HZ, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HZ_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HZ *arg1 = (Pythia8::Sigma2ffbar2HZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HZ_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HZ_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HZ * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HZ_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HZ *arg1 = (Pythia8::Sigma2ffbar2HZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HZ_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HZ_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HZ * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HZ_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HZ *arg1 = (Pythia8::Sigma2ffbar2HZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HZ_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HZ_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HZ * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HZ_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HZ *arg1 = (Pythia8::Sigma2ffbar2HZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HZ_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HZ_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HZ * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HZ_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HZ *arg1 = (Pythia8::Sigma2ffbar2HZ *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2ffbar2HZ_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HZ_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HZ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2ffbar2HZ_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2ffbar2HZ_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2ffbar2HZ_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2ffbar2HZ_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HZ_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HZ *arg1 = (Pythia8::Sigma2ffbar2HZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HZ_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HZ_name" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HZ * >(argp1);
  result = ((Pythia8::Sigma2ffbar2HZ const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HZ_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HZ *arg1 = (Pythia8::Sigma2ffbar2HZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HZ_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HZ_code" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HZ * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2HZ const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HZ_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HZ *arg1 = (Pythia8::Sigma2ffbar2HZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HZ_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HZ_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HZ * >(argp1);
  result = ((Pythia8::Sigma2ffbar2HZ const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HZ_isSChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HZ *arg1 = (Pythia8::Sigma2ffbar2HZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HZ_isSChannel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HZ_isSChannel" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HZ * >(argp1);
  result = (bool)((Pythia8::Sigma2ffbar2HZ const *)arg1)->isSChannel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HZ_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HZ *arg1 = (Pythia8::Sigma2ffbar2HZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HZ_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HZ_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HZ * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2HZ const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HZ_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HZ *arg1 = (Pythia8::Sigma2ffbar2HZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HZ_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HZ_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HZ * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2HZ const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HZ_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HZ *arg1 = (Pythia8::Sigma2ffbar2HZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HZ_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HZ_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HZ * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2HZ const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HZ_gmZmode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HZ *arg1 = (Pythia8::Sigma2ffbar2HZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HZ_gmZmode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HZ_gmZmode" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HZ * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2HZ const *)arg1)->gmZmode();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbar2HZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HZ *arg1 = (Pythia8::Sigma2ffbar2HZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbar2HZ",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HZ, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbar2HZ" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HZ * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbar2HZ_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbar2HZ, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2HW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma2ffbar2HW *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma2ffbar2HW",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2ffbar2HW" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Sigma2ffbar2HW *)new Pythia8::Sigma2ffbar2HW(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbar2HW, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HW_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HW *arg1 = (Pythia8::Sigma2ffbar2HW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HW_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HW_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HW * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HW_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HW *arg1 = (Pythia8::Sigma2ffbar2HW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HW_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HW_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HW * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HW_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HW *arg1 = (Pythia8::Sigma2ffbar2HW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HW_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HW_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HW * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HW_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HW *arg1 = (Pythia8::Sigma2ffbar2HW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HW_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HW_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HW * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HW_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HW *arg1 = (Pythia8::Sigma2ffbar2HW *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2ffbar2HW_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HW_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HW * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2ffbar2HW_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2ffbar2HW_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2ffbar2HW_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2ffbar2HW_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HW_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HW *arg1 = (Pythia8::Sigma2ffbar2HW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HW_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HW_name" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HW * >(argp1);
  result = ((Pythia8::Sigma2ffbar2HW const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HW_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HW *arg1 = (Pythia8::Sigma2ffbar2HW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HW_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HW_code" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HW * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2HW const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HW_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HW *arg1 = (Pythia8::Sigma2ffbar2HW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HW_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HW_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HW * >(argp1);
  result = ((Pythia8::Sigma2ffbar2HW const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HW_isSChannel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HW *arg1 = (Pythia8::Sigma2ffbar2HW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HW_isSChannel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HW_isSChannel" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HW * >(argp1);
  result = (bool)((Pythia8::Sigma2ffbar2HW const *)arg1)->isSChannel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HW_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HW *arg1 = (Pythia8::Sigma2ffbar2HW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HW_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HW_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HW * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2HW const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HW_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HW *arg1 = (Pythia8::Sigma2ffbar2HW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HW_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HW_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HW * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2HW const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HW_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HW *arg1 = (Pythia8::Sigma2ffbar2HW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HW_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HW_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HW * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2HW const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbar2HW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HW *arg1 = (Pythia8::Sigma2ffbar2HW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbar2HW",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HW, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbar2HW" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HW * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbar2HW_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbar2HW, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma3ff2HfftZZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma3ff2HfftZZ *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma3ff2HfftZZ",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma3ff2HfftZZ" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Sigma3ff2HfftZZ *)new Pythia8::Sigma3ff2HfftZZ(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma3ff2HfftZZ, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftZZ_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftZZ *arg1 = (Pythia8::Sigma3ff2HfftZZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftZZ_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftZZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftZZ_initProc" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftZZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftZZ * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftZZ_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftZZ *arg1 = (Pythia8::Sigma3ff2HfftZZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftZZ_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftZZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftZZ_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftZZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftZZ * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftZZ_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftZZ *arg1 = (Pythia8::Sigma3ff2HfftZZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftZZ_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftZZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftZZ_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftZZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftZZ * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftZZ_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftZZ *arg1 = (Pythia8::Sigma3ff2HfftZZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftZZ_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftZZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftZZ_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftZZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftZZ * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftZZ_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftZZ *arg1 = (Pythia8::Sigma3ff2HfftZZ *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma3ff2HfftZZ_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftZZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftZZ_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftZZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftZZ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma3ff2HfftZZ_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma3ff2HfftZZ_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma3ff2HfftZZ_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma3ff2HfftZZ_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftZZ_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftZZ *arg1 = (Pythia8::Sigma3ff2HfftZZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftZZ_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftZZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftZZ_name" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftZZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftZZ * >(argp1);
  result = ((Pythia8::Sigma3ff2HfftZZ const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftZZ_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftZZ *arg1 = (Pythia8::Sigma3ff2HfftZZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftZZ_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftZZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftZZ_code" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftZZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftZZ * >(argp1);
  result = (int)((Pythia8::Sigma3ff2HfftZZ const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftZZ_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftZZ *arg1 = (Pythia8::Sigma3ff2HfftZZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftZZ_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftZZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftZZ_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftZZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftZZ * >(argp1);
  result = ((Pythia8::Sigma3ff2HfftZZ const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftZZ_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftZZ *arg1 = (Pythia8::Sigma3ff2HfftZZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftZZ_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftZZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftZZ_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftZZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftZZ * >(argp1);
  result = (int)((Pythia8::Sigma3ff2HfftZZ const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftZZ_idTchan1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftZZ *arg1 = (Pythia8::Sigma3ff2HfftZZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftZZ_idTchan1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftZZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftZZ_idTchan1" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftZZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftZZ * >(argp1);
  result = (int)((Pythia8::Sigma3ff2HfftZZ const *)arg1)->idTchan1();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftZZ_idTchan2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftZZ *arg1 = (Pythia8::Sigma3ff2HfftZZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftZZ_idTchan2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftZZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftZZ_idTchan2" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftZZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftZZ * >(argp1);
  result = (int)((Pythia8::Sigma3ff2HfftZZ const *)arg1)->idTchan2();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftZZ_tChanFracPow1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftZZ *arg1 = (Pythia8::Sigma3ff2HfftZZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftZZ_tChanFracPow1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftZZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftZZ_tChanFracPow1" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftZZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftZZ * >(argp1);
  result = (double)((Pythia8::Sigma3ff2HfftZZ const *)arg1)->tChanFracPow1();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftZZ_tChanFracPow2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftZZ *arg1 = (Pythia8::Sigma3ff2HfftZZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftZZ_tChanFracPow2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftZZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftZZ_tChanFracPow2" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftZZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftZZ * >(argp1);
  result = (double)((Pythia8::Sigma3ff2HfftZZ const *)arg1)->tChanFracPow2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftZZ_useMirrorWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftZZ *arg1 = (Pythia8::Sigma3ff2HfftZZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftZZ_useMirrorWeight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftZZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftZZ_useMirrorWeight" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftZZ const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftZZ * >(argp1);
  result = (bool)((Pythia8::Sigma3ff2HfftZZ const *)arg1)->useMirrorWeight();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma3ff2HfftZZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftZZ *arg1 = (Pythia8::Sigma3ff2HfftZZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma3ff2HfftZZ",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftZZ, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma3ff2HfftZZ" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftZZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftZZ * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma3ff2HfftZZ_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma3ff2HfftZZ, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma3ff2HfftWW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma3ff2HfftWW *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma3ff2HfftWW",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma3ff2HfftWW" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Sigma3ff2HfftWW *)new Pythia8::Sigma3ff2HfftWW(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma3ff2HfftWW, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftWW_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftWW *arg1 = (Pythia8::Sigma3ff2HfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftWW_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftWW_initProc" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftWW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftWW * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftWW_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftWW *arg1 = (Pythia8::Sigma3ff2HfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftWW_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftWW_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftWW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftWW * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftWW_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftWW *arg1 = (Pythia8::Sigma3ff2HfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftWW_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftWW_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftWW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftWW * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftWW_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftWW *arg1 = (Pythia8::Sigma3ff2HfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftWW_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftWW_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftWW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftWW * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftWW_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftWW *arg1 = (Pythia8::Sigma3ff2HfftWW *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma3ff2HfftWW_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftWW_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftWW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftWW * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma3ff2HfftWW_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma3ff2HfftWW_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma3ff2HfftWW_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma3ff2HfftWW_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftWW_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftWW *arg1 = (Pythia8::Sigma3ff2HfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftWW_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftWW_name" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftWW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftWW * >(argp1);
  result = ((Pythia8::Sigma3ff2HfftWW const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftWW_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftWW *arg1 = (Pythia8::Sigma3ff2HfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftWW_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftWW_code" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftWW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftWW * >(argp1);
  result = (int)((Pythia8::Sigma3ff2HfftWW const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftWW_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftWW *arg1 = (Pythia8::Sigma3ff2HfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftWW_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftWW_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftWW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftWW * >(argp1);
  result = ((Pythia8::Sigma3ff2HfftWW const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftWW_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftWW *arg1 = (Pythia8::Sigma3ff2HfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftWW_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftWW_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftWW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftWW * >(argp1);
  result = (int)((Pythia8::Sigma3ff2HfftWW const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftWW_idTchan1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftWW *arg1 = (Pythia8::Sigma3ff2HfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftWW_idTchan1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftWW_idTchan1" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftWW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftWW * >(argp1);
  result = (int)((Pythia8::Sigma3ff2HfftWW const *)arg1)->idTchan1();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftWW_idTchan2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftWW *arg1 = (Pythia8::Sigma3ff2HfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftWW_idTchan2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftWW_idTchan2" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftWW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftWW * >(argp1);
  result = (int)((Pythia8::Sigma3ff2HfftWW const *)arg1)->idTchan2();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftWW_tChanFracPow1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftWW *arg1 = (Pythia8::Sigma3ff2HfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftWW_tChanFracPow1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftWW_tChanFracPow1" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftWW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftWW * >(argp1);
  result = (double)((Pythia8::Sigma3ff2HfftWW const *)arg1)->tChanFracPow1();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftWW_tChanFracPow2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftWW *arg1 = (Pythia8::Sigma3ff2HfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftWW_tChanFracPow2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftWW_tChanFracPow2" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftWW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftWW * >(argp1);
  result = (double)((Pythia8::Sigma3ff2HfftWW const *)arg1)->tChanFracPow2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HfftWW_useMirrorWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftWW *arg1 = (Pythia8::Sigma3ff2HfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HfftWW_useMirrorWeight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HfftWW_useMirrorWeight" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftWW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftWW * >(argp1);
  result = (bool)((Pythia8::Sigma3ff2HfftWW const *)arg1)->useMirrorWeight();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma3ff2HfftWW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HfftWW *arg1 = (Pythia8::Sigma3ff2HfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma3ff2HfftWW",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HfftWW, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma3ff2HfftWW" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HfftWW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HfftWW * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma3ff2HfftWW_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma3ff2HfftWW, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma3gg2HQQbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Sigma3gg2HQQbar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Sigma3gg2HQQbar",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma3gg2HQQbar" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma3gg2HQQbar" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::Sigma3gg2HQQbar *)new Pythia8::Sigma3gg2HQQbar(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma3gg2HQQbar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2HQQbar_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2HQQbar *arg1 = (Pythia8::Sigma3gg2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2HQQbar_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2HQQbar_initProc" "', argument " "1"" of type '" "Pythia8::Sigma3gg2HQQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2HQQbar * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2HQQbar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2HQQbar *arg1 = (Pythia8::Sigma3gg2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2HQQbar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2HQQbar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma3gg2HQQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2HQQbar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2HQQbar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2HQQbar *arg1 = (Pythia8::Sigma3gg2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2HQQbar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2HQQbar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma3gg2HQQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2HQQbar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2HQQbar_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2HQQbar *arg1 = (Pythia8::Sigma3gg2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2HQQbar_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2HQQbar_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma3gg2HQQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2HQQbar * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2HQQbar_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2HQQbar *arg1 = (Pythia8::Sigma3gg2HQQbar *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma3gg2HQQbar_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2HQQbar_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma3gg2HQQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2HQQbar * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma3gg2HQQbar_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma3gg2HQQbar_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma3gg2HQQbar_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma3gg2HQQbar_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2HQQbar_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2HQQbar *arg1 = (Pythia8::Sigma3gg2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2HQQbar_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2HQQbar_name" "', argument " "1"" of type '" "Pythia8::Sigma3gg2HQQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2HQQbar * >(argp1);
  result = ((Pythia8::Sigma3gg2HQQbar const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2HQQbar_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2HQQbar *arg1 = (Pythia8::Sigma3gg2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2HQQbar_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2HQQbar_code" "', argument " "1"" of type '" "Pythia8::Sigma3gg2HQQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2HQQbar * >(argp1);
  result = (int)((Pythia8::Sigma3gg2HQQbar const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2HQQbar_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2HQQbar *arg1 = (Pythia8::Sigma3gg2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2HQQbar_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2HQQbar_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma3gg2HQQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2HQQbar * >(argp1);
  result = ((Pythia8::Sigma3gg2HQQbar const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2HQQbar_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2HQQbar *arg1 = (Pythia8::Sigma3gg2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2HQQbar_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2HQQbar_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma3gg2HQQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2HQQbar * >(argp1);
  result = (int)((Pythia8::Sigma3gg2HQQbar const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2HQQbar_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2HQQbar *arg1 = (Pythia8::Sigma3gg2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2HQQbar_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2HQQbar_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma3gg2HQQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2HQQbar * >(argp1);
  result = (int)((Pythia8::Sigma3gg2HQQbar const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2HQQbar_id5Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2HQQbar *arg1 = (Pythia8::Sigma3gg2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2HQQbar_id5Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2HQQbar_id5Mass" "', argument " "1"" of type '" "Pythia8::Sigma3gg2HQQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2HQQbar * >(argp1);
  result = (int)((Pythia8::Sigma3gg2HQQbar const *)arg1)->id5Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2HQQbar_idTchan1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2HQQbar *arg1 = (Pythia8::Sigma3gg2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2HQQbar_idTchan1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2HQQbar_idTchan1" "', argument " "1"" of type '" "Pythia8::Sigma3gg2HQQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2HQQbar * >(argp1);
  result = (int)((Pythia8::Sigma3gg2HQQbar const *)arg1)->idTchan1();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2HQQbar_idTchan2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2HQQbar *arg1 = (Pythia8::Sigma3gg2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2HQQbar_idTchan2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2HQQbar_idTchan2" "', argument " "1"" of type '" "Pythia8::Sigma3gg2HQQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2HQQbar * >(argp1);
  result = (int)((Pythia8::Sigma3gg2HQQbar const *)arg1)->idTchan2();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2HQQbar_tChanFracPow1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2HQQbar *arg1 = (Pythia8::Sigma3gg2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2HQQbar_tChanFracPow1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2HQQbar_tChanFracPow1" "', argument " "1"" of type '" "Pythia8::Sigma3gg2HQQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2HQQbar * >(argp1);
  result = (double)((Pythia8::Sigma3gg2HQQbar const *)arg1)->tChanFracPow1();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2HQQbar_tChanFracPow2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2HQQbar *arg1 = (Pythia8::Sigma3gg2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2HQQbar_tChanFracPow2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2HQQbar_tChanFracPow2" "', argument " "1"" of type '" "Pythia8::Sigma3gg2HQQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2HQQbar * >(argp1);
  result = (double)((Pythia8::Sigma3gg2HQQbar const *)arg1)->tChanFracPow2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3gg2HQQbar_useMirrorWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2HQQbar *arg1 = (Pythia8::Sigma3gg2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3gg2HQQbar_useMirrorWeight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3gg2HQQbar_useMirrorWeight" "', argument " "1"" of type '" "Pythia8::Sigma3gg2HQQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2HQQbar * >(argp1);
  result = (bool)((Pythia8::Sigma3gg2HQQbar const *)arg1)->useMirrorWeight();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma3gg2HQQbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3gg2HQQbar *arg1 = (Pythia8::Sigma3gg2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma3gg2HQQbar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3gg2HQQbar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma3gg2HQQbar" "', argument " "1"" of type '" "Pythia8::Sigma3gg2HQQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3gg2HQQbar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma3gg2HQQbar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma3gg2HQQbar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma3qqbar2HQQbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Sigma3qqbar2HQQbar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Sigma3qqbar2HQQbar",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma3qqbar2HQQbar" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma3qqbar2HQQbar" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::Sigma3qqbar2HQQbar *)new Pythia8::Sigma3qqbar2HQQbar(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma3qqbar2HQQbar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2HQQbar_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2HQQbar *arg1 = (Pythia8::Sigma3qqbar2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2HQQbar_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2HQQbar_initProc" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2HQQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2HQQbar * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2HQQbar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2HQQbar *arg1 = (Pythia8::Sigma3qqbar2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2HQQbar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2HQQbar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2HQQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2HQQbar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2HQQbar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2HQQbar *arg1 = (Pythia8::Sigma3qqbar2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2HQQbar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2HQQbar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2HQQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2HQQbar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2HQQbar_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2HQQbar *arg1 = (Pythia8::Sigma3qqbar2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2HQQbar_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2HQQbar_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2HQQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2HQQbar * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2HQQbar_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2HQQbar *arg1 = (Pythia8::Sigma3qqbar2HQQbar *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma3qqbar2HQQbar_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2HQQbar_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2HQQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2HQQbar * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma3qqbar2HQQbar_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma3qqbar2HQQbar_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma3qqbar2HQQbar_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma3qqbar2HQQbar_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2HQQbar_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2HQQbar *arg1 = (Pythia8::Sigma3qqbar2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2HQQbar_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2HQQbar_name" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2HQQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2HQQbar * >(argp1);
  result = ((Pythia8::Sigma3qqbar2HQQbar const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2HQQbar_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2HQQbar *arg1 = (Pythia8::Sigma3qqbar2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2HQQbar_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2HQQbar_code" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2HQQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2HQQbar * >(argp1);
  result = (int)((Pythia8::Sigma3qqbar2HQQbar const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2HQQbar_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2HQQbar *arg1 = (Pythia8::Sigma3qqbar2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2HQQbar_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2HQQbar_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2HQQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2HQQbar * >(argp1);
  result = ((Pythia8::Sigma3qqbar2HQQbar const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2HQQbar_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2HQQbar *arg1 = (Pythia8::Sigma3qqbar2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2HQQbar_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2HQQbar_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2HQQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2HQQbar * >(argp1);
  result = (int)((Pythia8::Sigma3qqbar2HQQbar const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2HQQbar_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2HQQbar *arg1 = (Pythia8::Sigma3qqbar2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2HQQbar_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2HQQbar_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2HQQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2HQQbar * >(argp1);
  result = (int)((Pythia8::Sigma3qqbar2HQQbar const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2HQQbar_id5Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2HQQbar *arg1 = (Pythia8::Sigma3qqbar2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2HQQbar_id5Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2HQQbar_id5Mass" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2HQQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2HQQbar * >(argp1);
  result = (int)((Pythia8::Sigma3qqbar2HQQbar const *)arg1)->id5Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2HQQbar_idTchan1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2HQQbar *arg1 = (Pythia8::Sigma3qqbar2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2HQQbar_idTchan1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2HQQbar_idTchan1" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2HQQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2HQQbar * >(argp1);
  result = (int)((Pythia8::Sigma3qqbar2HQQbar const *)arg1)->idTchan1();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2HQQbar_idTchan2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2HQQbar *arg1 = (Pythia8::Sigma3qqbar2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2HQQbar_idTchan2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2HQQbar_idTchan2" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2HQQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2HQQbar * >(argp1);
  result = (int)((Pythia8::Sigma3qqbar2HQQbar const *)arg1)->idTchan2();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2HQQbar_tChanFracPow1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2HQQbar *arg1 = (Pythia8::Sigma3qqbar2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2HQQbar_tChanFracPow1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2HQQbar_tChanFracPow1" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2HQQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2HQQbar * >(argp1);
  result = (double)((Pythia8::Sigma3qqbar2HQQbar const *)arg1)->tChanFracPow1();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2HQQbar_tChanFracPow2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2HQQbar *arg1 = (Pythia8::Sigma3qqbar2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2HQQbar_tChanFracPow2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2HQQbar_tChanFracPow2" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2HQQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2HQQbar * >(argp1);
  result = (double)((Pythia8::Sigma3qqbar2HQQbar const *)arg1)->tChanFracPow2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3qqbar2HQQbar_useMirrorWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2HQQbar *arg1 = (Pythia8::Sigma3qqbar2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3qqbar2HQQbar_useMirrorWeight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2HQQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3qqbar2HQQbar_useMirrorWeight" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2HQQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2HQQbar * >(argp1);
  result = (bool)((Pythia8::Sigma3qqbar2HQQbar const *)arg1)->useMirrorWeight();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma3qqbar2HQQbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3qqbar2HQQbar *arg1 = (Pythia8::Sigma3qqbar2HQQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma3qqbar2HQQbar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3qqbar2HQQbar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma3qqbar2HQQbar" "', argument " "1"" of type '" "Pythia8::Sigma3qqbar2HQQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3qqbar2HQQbar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma3qqbar2HQQbar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma3qqbar2HQQbar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qg2Hq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Sigma2qg2Hq *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Sigma2qg2Hq",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qg2Hq" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2qg2Hq" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::Sigma2qg2Hq *)new Pythia8::Sigma2qg2Hq(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qg2Hq, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hq_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hq *arg1 = (Pythia8::Sigma2qg2Hq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hq_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hq_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hq * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hq_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hq *arg1 = (Pythia8::Sigma2qg2Hq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hq_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hq_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hq * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hq_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hq *arg1 = (Pythia8::Sigma2qg2Hq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hq_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hq_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hq * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hq_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hq *arg1 = (Pythia8::Sigma2qg2Hq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hq_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hq_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hq * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hq_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hq *arg1 = (Pythia8::Sigma2qg2Hq *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2qg2Hq_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hq_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hq * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2qg2Hq_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2qg2Hq_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2qg2Hq_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2qg2Hq_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hq_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hq *arg1 = (Pythia8::Sigma2qg2Hq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hq_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hq_name" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hq * >(argp1);
  result = ((Pythia8::Sigma2qg2Hq const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hq_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hq *arg1 = (Pythia8::Sigma2qg2Hq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hq_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hq_code" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hq * >(argp1);
  result = (int)((Pythia8::Sigma2qg2Hq const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hq_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hq *arg1 = (Pythia8::Sigma2qg2Hq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hq_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hq_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hq * >(argp1);
  result = ((Pythia8::Sigma2qg2Hq const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hq_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hq *arg1 = (Pythia8::Sigma2qg2Hq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hq_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hq_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hq * >(argp1);
  result = (int)((Pythia8::Sigma2qg2Hq const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hq_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hq *arg1 = (Pythia8::Sigma2qg2Hq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hq_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hq_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hq * >(argp1);
  result = (int)((Pythia8::Sigma2qg2Hq const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qg2Hq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hq *arg1 = (Pythia8::Sigma2qg2Hq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qg2Hq",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hq, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qg2Hq" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hq * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qg2Hq_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qg2Hq, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2gg2Hglt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma2gg2Hglt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma2gg2Hglt",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2gg2Hglt" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Sigma2gg2Hglt *)new Pythia8::Sigma2gg2Hglt(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gg2Hglt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2Hglt_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2Hglt *arg1 = (Pythia8::Sigma2gg2Hglt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2Hglt_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2Hglt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2Hglt_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2gg2Hglt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2Hglt * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2Hglt_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2Hglt *arg1 = (Pythia8::Sigma2gg2Hglt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2Hglt_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2Hglt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2Hglt_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2gg2Hglt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2Hglt * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2Hglt_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2Hglt *arg1 = (Pythia8::Sigma2gg2Hglt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2Hglt_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2Hglt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2Hglt_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2gg2Hglt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2Hglt * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2Hglt_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2Hglt *arg1 = (Pythia8::Sigma2gg2Hglt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2Hglt_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2Hglt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2Hglt_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2gg2Hglt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2Hglt * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2Hglt_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2Hglt *arg1 = (Pythia8::Sigma2gg2Hglt *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2gg2Hglt_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2Hglt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2Hglt_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2gg2Hglt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2Hglt * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2gg2Hglt_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2gg2Hglt_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2gg2Hglt_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2gg2Hglt_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2Hglt_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2Hglt *arg1 = (Pythia8::Sigma2gg2Hglt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2Hglt_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2Hglt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2Hglt_name" "', argument " "1"" of type '" "Pythia8::Sigma2gg2Hglt const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2Hglt * >(argp1);
  result = ((Pythia8::Sigma2gg2Hglt const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2Hglt_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2Hglt *arg1 = (Pythia8::Sigma2gg2Hglt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2Hglt_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2Hglt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2Hglt_code" "', argument " "1"" of type '" "Pythia8::Sigma2gg2Hglt const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2Hglt * >(argp1);
  result = (int)((Pythia8::Sigma2gg2Hglt const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2Hglt_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2Hglt *arg1 = (Pythia8::Sigma2gg2Hglt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2Hglt_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2Hglt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2Hglt_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2gg2Hglt const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2Hglt * >(argp1);
  result = ((Pythia8::Sigma2gg2Hglt const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2Hglt_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2Hglt *arg1 = (Pythia8::Sigma2gg2Hglt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2Hglt_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2Hglt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2Hglt_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2gg2Hglt const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2Hglt * >(argp1);
  result = (int)((Pythia8::Sigma2gg2Hglt const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2gg2Hglt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2Hglt *arg1 = (Pythia8::Sigma2gg2Hglt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2gg2Hglt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2Hglt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2gg2Hglt" "', argument " "1"" of type '" "Pythia8::Sigma2gg2Hglt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2Hglt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2gg2Hglt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2gg2Hglt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qg2Hqlt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma2qg2Hqlt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma2qg2Hqlt",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qg2Hqlt" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Sigma2qg2Hqlt *)new Pythia8::Sigma2qg2Hqlt(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qg2Hqlt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hqlt_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hqlt *arg1 = (Pythia8::Sigma2qg2Hqlt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hqlt_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hqlt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hqlt_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hqlt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hqlt * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hqlt_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hqlt *arg1 = (Pythia8::Sigma2qg2Hqlt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hqlt_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hqlt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hqlt_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hqlt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hqlt * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hqlt_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hqlt *arg1 = (Pythia8::Sigma2qg2Hqlt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hqlt_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hqlt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hqlt_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hqlt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hqlt * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hqlt_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hqlt *arg1 = (Pythia8::Sigma2qg2Hqlt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hqlt_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hqlt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hqlt_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hqlt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hqlt * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hqlt_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hqlt *arg1 = (Pythia8::Sigma2qg2Hqlt *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2qg2Hqlt_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hqlt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hqlt_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hqlt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hqlt * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2qg2Hqlt_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2qg2Hqlt_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2qg2Hqlt_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2qg2Hqlt_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hqlt_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hqlt *arg1 = (Pythia8::Sigma2qg2Hqlt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hqlt_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hqlt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hqlt_name" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hqlt const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hqlt * >(argp1);
  result = ((Pythia8::Sigma2qg2Hqlt const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hqlt_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hqlt *arg1 = (Pythia8::Sigma2qg2Hqlt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hqlt_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hqlt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hqlt_code" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hqlt const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hqlt * >(argp1);
  result = (int)((Pythia8::Sigma2qg2Hqlt const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hqlt_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hqlt *arg1 = (Pythia8::Sigma2qg2Hqlt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hqlt_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hqlt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hqlt_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hqlt const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hqlt * >(argp1);
  result = ((Pythia8::Sigma2qg2Hqlt const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hqlt_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hqlt *arg1 = (Pythia8::Sigma2qg2Hqlt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hqlt_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hqlt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hqlt_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hqlt const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hqlt * >(argp1);
  result = (int)((Pythia8::Sigma2qg2Hqlt const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qg2Hqlt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hqlt *arg1 = (Pythia8::Sigma2qg2Hqlt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qg2Hqlt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hqlt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qg2Hqlt" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hqlt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hqlt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qg2Hqlt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qg2Hqlt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2Hglt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma2qqbar2Hglt *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma2qqbar2Hglt",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qqbar2Hglt" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Sigma2qqbar2Hglt *)new Pythia8::Sigma2qqbar2Hglt(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2Hglt, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Hglt_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Hglt *arg1 = (Pythia8::Sigma2qqbar2Hglt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Hglt_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Hglt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Hglt_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Hglt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Hglt * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Hglt_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Hglt *arg1 = (Pythia8::Sigma2qqbar2Hglt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Hglt_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Hglt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Hglt_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Hglt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Hglt * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Hglt_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Hglt *arg1 = (Pythia8::Sigma2qqbar2Hglt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Hglt_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Hglt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Hglt_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Hglt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Hglt * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Hglt_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Hglt *arg1 = (Pythia8::Sigma2qqbar2Hglt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Hglt_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Hglt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Hglt_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Hglt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Hglt * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Hglt_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Hglt *arg1 = (Pythia8::Sigma2qqbar2Hglt *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2qqbar2Hglt_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Hglt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Hglt_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Hglt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Hglt * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2qqbar2Hglt_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2qqbar2Hglt_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2qqbar2Hglt_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2qqbar2Hglt_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Hglt_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Hglt *arg1 = (Pythia8::Sigma2qqbar2Hglt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Hglt_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Hglt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Hglt_name" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Hglt const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Hglt * >(argp1);
  result = ((Pythia8::Sigma2qqbar2Hglt const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Hglt_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Hglt *arg1 = (Pythia8::Sigma2qqbar2Hglt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Hglt_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Hglt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Hglt_code" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Hglt const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Hglt * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2Hglt const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Hglt_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Hglt *arg1 = (Pythia8::Sigma2qqbar2Hglt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Hglt_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Hglt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Hglt_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Hglt const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Hglt * >(argp1);
  result = ((Pythia8::Sigma2qqbar2Hglt const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2Hglt_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Hglt *arg1 = (Pythia8::Sigma2qqbar2Hglt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2Hglt_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Hglt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2Hglt_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Hglt const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Hglt * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2Hglt const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2Hglt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2Hglt *arg1 = (Pythia8::Sigma2qqbar2Hglt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2Hglt",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2Hglt, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2Hglt" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2Hglt *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2Hglt * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2Hglt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2Hglt, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma1ffbar2Hchg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Hchg *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma1ffbar2Hchg")) SWIG_fail;
  result = (Pythia8::Sigma1ffbar2Hchg *)new Pythia8::Sigma1ffbar2Hchg();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma1ffbar2Hchg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Hchg_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Hchg *arg1 = (Pythia8::Sigma1ffbar2Hchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Hchg_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Hchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Hchg_initProc" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Hchg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Hchg * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Hchg_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Hchg *arg1 = (Pythia8::Sigma1ffbar2Hchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Hchg_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Hchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Hchg_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Hchg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Hchg * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Hchg_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Hchg *arg1 = (Pythia8::Sigma1ffbar2Hchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Hchg_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Hchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Hchg_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Hchg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Hchg * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Hchg_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Hchg *arg1 = (Pythia8::Sigma1ffbar2Hchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Hchg_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Hchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Hchg_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Hchg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Hchg * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Hchg_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Hchg *arg1 = (Pythia8::Sigma1ffbar2Hchg *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma1ffbar2Hchg_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Hchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Hchg_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Hchg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Hchg * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma1ffbar2Hchg_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma1ffbar2Hchg_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma1ffbar2Hchg_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma1ffbar2Hchg_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Hchg_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Hchg *arg1 = (Pythia8::Sigma1ffbar2Hchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Hchg_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Hchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Hchg_name" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Hchg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Hchg * >(argp1);
  result = ((Pythia8::Sigma1ffbar2Hchg const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Hchg_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Hchg *arg1 = (Pythia8::Sigma1ffbar2Hchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Hchg_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Hchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Hchg_code" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Hchg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Hchg * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2Hchg const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Hchg_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Hchg *arg1 = (Pythia8::Sigma1ffbar2Hchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Hchg_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Hchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Hchg_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Hchg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Hchg * >(argp1);
  result = ((Pythia8::Sigma1ffbar2Hchg const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Hchg_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Hchg *arg1 = (Pythia8::Sigma1ffbar2Hchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Hchg_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Hchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Hchg_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Hchg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Hchg * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2Hchg const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma1ffbar2Hchg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Hchg *arg1 = (Pythia8::Sigma1ffbar2Hchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma1ffbar2Hchg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Hchg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma1ffbar2Hchg" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Hchg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Hchg * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma1ffbar2Hchg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma1ffbar2Hchg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qg2Hchgq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  std::string arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Sigma2qg2Hchgq *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Sigma2qg2Hchgq",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qg2Hchgq" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2qg2Hchgq" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Sigma2qg2Hchgq" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::Sigma2qg2Hchgq *)new Pythia8::Sigma2qg2Hchgq(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qg2Hchgq, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hchgq_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hchgq *arg1 = (Pythia8::Sigma2qg2Hchgq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hchgq_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hchgq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hchgq_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hchgq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hchgq * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hchgq_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hchgq *arg1 = (Pythia8::Sigma2qg2Hchgq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hchgq_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hchgq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hchgq_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hchgq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hchgq * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hchgq_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hchgq *arg1 = (Pythia8::Sigma2qg2Hchgq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hchgq_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hchgq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hchgq_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hchgq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hchgq * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hchgq_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hchgq *arg1 = (Pythia8::Sigma2qg2Hchgq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hchgq_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hchgq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hchgq_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hchgq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hchgq * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hchgq_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hchgq *arg1 = (Pythia8::Sigma2qg2Hchgq *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2qg2Hchgq_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hchgq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hchgq_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hchgq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hchgq * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2qg2Hchgq_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2qg2Hchgq_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2qg2Hchgq_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2qg2Hchgq_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hchgq_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hchgq *arg1 = (Pythia8::Sigma2qg2Hchgq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hchgq_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hchgq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hchgq_name" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hchgq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hchgq * >(argp1);
  result = ((Pythia8::Sigma2qg2Hchgq const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hchgq_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hchgq *arg1 = (Pythia8::Sigma2qg2Hchgq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hchgq_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hchgq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hchgq_code" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hchgq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hchgq * >(argp1);
  result = (int)((Pythia8::Sigma2qg2Hchgq const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hchgq_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hchgq *arg1 = (Pythia8::Sigma2qg2Hchgq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hchgq_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hchgq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hchgq_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hchgq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hchgq * >(argp1);
  result = ((Pythia8::Sigma2qg2Hchgq const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hchgq_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hchgq *arg1 = (Pythia8::Sigma2qg2Hchgq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hchgq_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hchgq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hchgq_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hchgq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hchgq * >(argp1);
  result = (int)((Pythia8::Sigma2qg2Hchgq const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2Hchgq_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hchgq *arg1 = (Pythia8::Sigma2qg2Hchgq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2Hchgq_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hchgq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2Hchgq_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hchgq const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hchgq * >(argp1);
  result = (int)((Pythia8::Sigma2qg2Hchgq const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qg2Hchgq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2Hchgq *arg1 = (Pythia8::Sigma2qg2Hchgq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qg2Hchgq",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2Hchgq, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qg2Hchgq" "', argument " "1"" of type '" "Pythia8::Sigma2qg2Hchgq *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2Hchgq * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qg2Hchgq_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qg2Hchgq, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2A3H12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma2ffbar2A3H12 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma2ffbar2A3H12",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2ffbar2A3H12" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Sigma2ffbar2A3H12 *)new Pythia8::Sigma2ffbar2A3H12(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbar2A3H12, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2A3H12_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2A3H12 *arg1 = (Pythia8::Sigma2ffbar2A3H12 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2A3H12_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2A3H12, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2A3H12_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2A3H12 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2A3H12 * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2A3H12_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2A3H12 *arg1 = (Pythia8::Sigma2ffbar2A3H12 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2A3H12_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2A3H12, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2A3H12_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2A3H12 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2A3H12 * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2A3H12_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2A3H12 *arg1 = (Pythia8::Sigma2ffbar2A3H12 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2A3H12_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2A3H12, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2A3H12_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2A3H12 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2A3H12 * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2A3H12_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2A3H12 *arg1 = (Pythia8::Sigma2ffbar2A3H12 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2A3H12_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2A3H12, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2A3H12_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2A3H12 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2A3H12 * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2A3H12_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2A3H12 *arg1 = (Pythia8::Sigma2ffbar2A3H12 *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2ffbar2A3H12_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2A3H12, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2A3H12_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2A3H12 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2A3H12 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2ffbar2A3H12_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2ffbar2A3H12_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2ffbar2A3H12_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2ffbar2A3H12_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2A3H12_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2A3H12 *arg1 = (Pythia8::Sigma2ffbar2A3H12 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2A3H12_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2A3H12, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2A3H12_name" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2A3H12 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2A3H12 * >(argp1);
  result = ((Pythia8::Sigma2ffbar2A3H12 const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2A3H12_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2A3H12 *arg1 = (Pythia8::Sigma2ffbar2A3H12 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2A3H12_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2A3H12, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2A3H12_code" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2A3H12 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2A3H12 * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2A3H12 const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2A3H12_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2A3H12 *arg1 = (Pythia8::Sigma2ffbar2A3H12 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2A3H12_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2A3H12, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2A3H12_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2A3H12 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2A3H12 * >(argp1);
  result = ((Pythia8::Sigma2ffbar2A3H12 const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2A3H12_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2A3H12 *arg1 = (Pythia8::Sigma2ffbar2A3H12 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2A3H12_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2A3H12, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2A3H12_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2A3H12 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2A3H12 * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2A3H12 const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2A3H12_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2A3H12 *arg1 = (Pythia8::Sigma2ffbar2A3H12 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2A3H12_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2A3H12, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2A3H12_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2A3H12 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2A3H12 * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2A3H12 const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbar2A3H12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2A3H12 *arg1 = (Pythia8::Sigma2ffbar2A3H12 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbar2A3H12",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2A3H12, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbar2A3H12" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2A3H12 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2A3H12 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbar2A3H12_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbar2A3H12, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2HchgH12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma2ffbar2HchgH12 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma2ffbar2HchgH12",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2ffbar2HchgH12" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Sigma2ffbar2HchgH12 *)new Pythia8::Sigma2ffbar2HchgH12(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgH12, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HchgH12_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HchgH12 *arg1 = (Pythia8::Sigma2ffbar2HchgH12 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HchgH12_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgH12, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HchgH12_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HchgH12 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HchgH12 * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HchgH12_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HchgH12 *arg1 = (Pythia8::Sigma2ffbar2HchgH12 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HchgH12_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgH12, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HchgH12_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HchgH12 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HchgH12 * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HchgH12_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HchgH12 *arg1 = (Pythia8::Sigma2ffbar2HchgH12 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HchgH12_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgH12, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HchgH12_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HchgH12 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HchgH12 * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HchgH12_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HchgH12 *arg1 = (Pythia8::Sigma2ffbar2HchgH12 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HchgH12_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgH12, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HchgH12_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HchgH12 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HchgH12 * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HchgH12_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HchgH12 *arg1 = (Pythia8::Sigma2ffbar2HchgH12 *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2ffbar2HchgH12_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgH12, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HchgH12_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HchgH12 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HchgH12 * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2ffbar2HchgH12_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2ffbar2HchgH12_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2ffbar2HchgH12_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2ffbar2HchgH12_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HchgH12_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HchgH12 *arg1 = (Pythia8::Sigma2ffbar2HchgH12 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HchgH12_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgH12, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HchgH12_name" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HchgH12 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HchgH12 * >(argp1);
  result = ((Pythia8::Sigma2ffbar2HchgH12 const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HchgH12_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HchgH12 *arg1 = (Pythia8::Sigma2ffbar2HchgH12 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HchgH12_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgH12, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HchgH12_code" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HchgH12 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HchgH12 * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2HchgH12 const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HchgH12_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HchgH12 *arg1 = (Pythia8::Sigma2ffbar2HchgH12 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HchgH12_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgH12, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HchgH12_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HchgH12 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HchgH12 * >(argp1);
  result = ((Pythia8::Sigma2ffbar2HchgH12 const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HchgH12_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HchgH12 *arg1 = (Pythia8::Sigma2ffbar2HchgH12 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HchgH12_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgH12, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HchgH12_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HchgH12 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HchgH12 * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2HchgH12 const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HchgH12_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HchgH12 *arg1 = (Pythia8::Sigma2ffbar2HchgH12 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HchgH12_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgH12, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HchgH12_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HchgH12 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HchgH12 * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2HchgH12 const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbar2HchgH12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HchgH12 *arg1 = (Pythia8::Sigma2ffbar2HchgH12 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbar2HchgH12",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgH12, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbar2HchgH12" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HchgH12 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HchgH12 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbar2HchgH12_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgH12, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2HposHneg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HposHneg *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2ffbar2HposHneg")) SWIG_fail;
  result = (Pythia8::Sigma2ffbar2HposHneg *)new Pythia8::Sigma2ffbar2HposHneg();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbar2HposHneg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HposHneg_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HposHneg *arg1 = (Pythia8::Sigma2ffbar2HposHneg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HposHneg_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HposHneg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HposHneg_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HposHneg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HposHneg * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HposHneg_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HposHneg *arg1 = (Pythia8::Sigma2ffbar2HposHneg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HposHneg_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HposHneg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HposHneg_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HposHneg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HposHneg * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HposHneg_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HposHneg *arg1 = (Pythia8::Sigma2ffbar2HposHneg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HposHneg_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HposHneg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HposHneg_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HposHneg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HposHneg * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HposHneg_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HposHneg *arg1 = (Pythia8::Sigma2ffbar2HposHneg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HposHneg_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HposHneg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HposHneg_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HposHneg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HposHneg * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HposHneg_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HposHneg *arg1 = (Pythia8::Sigma2ffbar2HposHneg *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2ffbar2HposHneg_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HposHneg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HposHneg_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HposHneg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HposHneg * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2ffbar2HposHneg_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2ffbar2HposHneg_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2ffbar2HposHneg_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2ffbar2HposHneg_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HposHneg_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HposHneg *arg1 = (Pythia8::Sigma2ffbar2HposHneg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HposHneg_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HposHneg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HposHneg_name" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HposHneg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HposHneg * >(argp1);
  result = ((Pythia8::Sigma2ffbar2HposHneg const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HposHneg_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HposHneg *arg1 = (Pythia8::Sigma2ffbar2HposHneg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HposHneg_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HposHneg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HposHneg_code" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HposHneg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HposHneg * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2HposHneg const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HposHneg_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HposHneg *arg1 = (Pythia8::Sigma2ffbar2HposHneg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HposHneg_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HposHneg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HposHneg_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HposHneg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HposHneg * >(argp1);
  result = ((Pythia8::Sigma2ffbar2HposHneg const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HposHneg_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HposHneg *arg1 = (Pythia8::Sigma2ffbar2HposHneg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HposHneg_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HposHneg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HposHneg_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HposHneg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HposHneg * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2HposHneg const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HposHneg_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HposHneg *arg1 = (Pythia8::Sigma2ffbar2HposHneg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HposHneg_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HposHneg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HposHneg_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HposHneg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HposHneg * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2HposHneg const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbar2HposHneg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HposHneg *arg1 = (Pythia8::Sigma2ffbar2HposHneg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbar2HposHneg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HposHneg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbar2HposHneg" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HposHneg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HposHneg * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbar2HposHneg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbar2HposHneg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma1ffbar2ZRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2ZRight *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma1ffbar2ZRight")) SWIG_fail;
  result = (Pythia8::Sigma1ffbar2ZRight *)new Pythia8::Sigma1ffbar2ZRight();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma1ffbar2ZRight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2ZRight_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2ZRight *arg1 = (Pythia8::Sigma1ffbar2ZRight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2ZRight_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2ZRight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2ZRight_initProc" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2ZRight *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2ZRight * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2ZRight_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2ZRight *arg1 = (Pythia8::Sigma1ffbar2ZRight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2ZRight_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2ZRight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2ZRight_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2ZRight *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2ZRight * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2ZRight_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2ZRight *arg1 = (Pythia8::Sigma1ffbar2ZRight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2ZRight_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2ZRight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2ZRight_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2ZRight *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2ZRight * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2ZRight_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2ZRight *arg1 = (Pythia8::Sigma1ffbar2ZRight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2ZRight_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2ZRight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2ZRight_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2ZRight *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2ZRight * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2ZRight_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2ZRight *arg1 = (Pythia8::Sigma1ffbar2ZRight *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma1ffbar2ZRight_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2ZRight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2ZRight_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2ZRight *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2ZRight * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma1ffbar2ZRight_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma1ffbar2ZRight_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma1ffbar2ZRight_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma1ffbar2ZRight_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2ZRight_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2ZRight *arg1 = (Pythia8::Sigma1ffbar2ZRight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2ZRight_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2ZRight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2ZRight_name" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2ZRight const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2ZRight * >(argp1);
  result = ((Pythia8::Sigma1ffbar2ZRight const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2ZRight_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2ZRight *arg1 = (Pythia8::Sigma1ffbar2ZRight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2ZRight_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2ZRight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2ZRight_code" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2ZRight const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2ZRight * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2ZRight const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2ZRight_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2ZRight *arg1 = (Pythia8::Sigma1ffbar2ZRight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2ZRight_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2ZRight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2ZRight_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2ZRight const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2ZRight * >(argp1);
  result = ((Pythia8::Sigma1ffbar2ZRight const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2ZRight_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2ZRight *arg1 = (Pythia8::Sigma1ffbar2ZRight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2ZRight_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2ZRight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2ZRight_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2ZRight const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2ZRight * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2ZRight const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma1ffbar2ZRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2ZRight *arg1 = (Pythia8::Sigma1ffbar2ZRight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma1ffbar2ZRight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2ZRight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma1ffbar2ZRight" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2ZRight *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2ZRight * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma1ffbar2ZRight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma1ffbar2ZRight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma1ffbar2WRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2WRight *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma1ffbar2WRight")) SWIG_fail;
  result = (Pythia8::Sigma1ffbar2WRight *)new Pythia8::Sigma1ffbar2WRight();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma1ffbar2WRight, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2WRight_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2WRight *arg1 = (Pythia8::Sigma1ffbar2WRight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2WRight_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2WRight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2WRight_initProc" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2WRight *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2WRight * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2WRight_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2WRight *arg1 = (Pythia8::Sigma1ffbar2WRight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2WRight_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2WRight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2WRight_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2WRight *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2WRight * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2WRight_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2WRight *arg1 = (Pythia8::Sigma1ffbar2WRight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2WRight_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2WRight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2WRight_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2WRight *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2WRight * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2WRight_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2WRight *arg1 = (Pythia8::Sigma1ffbar2WRight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2WRight_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2WRight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2WRight_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2WRight *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2WRight * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2WRight_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2WRight *arg1 = (Pythia8::Sigma1ffbar2WRight *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma1ffbar2WRight_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2WRight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2WRight_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2WRight *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2WRight * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma1ffbar2WRight_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma1ffbar2WRight_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma1ffbar2WRight_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma1ffbar2WRight_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2WRight_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2WRight *arg1 = (Pythia8::Sigma1ffbar2WRight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2WRight_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2WRight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2WRight_name" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2WRight const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2WRight * >(argp1);
  result = ((Pythia8::Sigma1ffbar2WRight const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2WRight_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2WRight *arg1 = (Pythia8::Sigma1ffbar2WRight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2WRight_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2WRight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2WRight_code" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2WRight const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2WRight * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2WRight const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2WRight_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2WRight *arg1 = (Pythia8::Sigma1ffbar2WRight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2WRight_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2WRight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2WRight_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2WRight const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2WRight * >(argp1);
  result = ((Pythia8::Sigma1ffbar2WRight const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2WRight_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2WRight *arg1 = (Pythia8::Sigma1ffbar2WRight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2WRight_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2WRight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2WRight_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2WRight const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2WRight * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2WRight const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma1ffbar2WRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2WRight *arg1 = (Pythia8::Sigma1ffbar2WRight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma1ffbar2WRight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2WRight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma1ffbar2WRight" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2WRight *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2WRight * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma1ffbar2WRight_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma1ffbar2WRight, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma1ll2Hchgchg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma1ll2Hchgchg *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma1ll2Hchgchg",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma1ll2Hchgchg" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Sigma1ll2Hchgchg *)new Pythia8::Sigma1ll2Hchgchg(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma1ll2Hchgchg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ll2Hchgchg_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ll2Hchgchg *arg1 = (Pythia8::Sigma1ll2Hchgchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ll2Hchgchg_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ll2Hchgchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ll2Hchgchg_initProc" "', argument " "1"" of type '" "Pythia8::Sigma1ll2Hchgchg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ll2Hchgchg * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ll2Hchgchg_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ll2Hchgchg *arg1 = (Pythia8::Sigma1ll2Hchgchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ll2Hchgchg_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ll2Hchgchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ll2Hchgchg_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma1ll2Hchgchg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ll2Hchgchg * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ll2Hchgchg_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ll2Hchgchg *arg1 = (Pythia8::Sigma1ll2Hchgchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ll2Hchgchg_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ll2Hchgchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ll2Hchgchg_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma1ll2Hchgchg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ll2Hchgchg * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ll2Hchgchg_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ll2Hchgchg *arg1 = (Pythia8::Sigma1ll2Hchgchg *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma1ll2Hchgchg_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ll2Hchgchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ll2Hchgchg_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma1ll2Hchgchg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ll2Hchgchg * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma1ll2Hchgchg_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma1ll2Hchgchg_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma1ll2Hchgchg_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma1ll2Hchgchg_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ll2Hchgchg_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ll2Hchgchg *arg1 = (Pythia8::Sigma1ll2Hchgchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ll2Hchgchg_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ll2Hchgchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ll2Hchgchg_name" "', argument " "1"" of type '" "Pythia8::Sigma1ll2Hchgchg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ll2Hchgchg * >(argp1);
  result = ((Pythia8::Sigma1ll2Hchgchg const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ll2Hchgchg_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ll2Hchgchg *arg1 = (Pythia8::Sigma1ll2Hchgchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ll2Hchgchg_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ll2Hchgchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ll2Hchgchg_code" "', argument " "1"" of type '" "Pythia8::Sigma1ll2Hchgchg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ll2Hchgchg * >(argp1);
  result = (int)((Pythia8::Sigma1ll2Hchgchg const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ll2Hchgchg_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ll2Hchgchg *arg1 = (Pythia8::Sigma1ll2Hchgchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ll2Hchgchg_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ll2Hchgchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ll2Hchgchg_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma1ll2Hchgchg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ll2Hchgchg * >(argp1);
  result = ((Pythia8::Sigma1ll2Hchgchg const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ll2Hchgchg_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ll2Hchgchg *arg1 = (Pythia8::Sigma1ll2Hchgchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ll2Hchgchg_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ll2Hchgchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ll2Hchgchg_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma1ll2Hchgchg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ll2Hchgchg * >(argp1);
  result = (int)((Pythia8::Sigma1ll2Hchgchg const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma1ll2Hchgchg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ll2Hchgchg *arg1 = (Pythia8::Sigma1ll2Hchgchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma1ll2Hchgchg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ll2Hchgchg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma1ll2Hchgchg" "', argument " "1"" of type '" "Pythia8::Sigma1ll2Hchgchg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ll2Hchgchg * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma1ll2Hchgchg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma1ll2Hchgchg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2lgm2Hchgchgl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Sigma2lgm2Hchgchgl *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Sigma2lgm2Hchgchgl",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2lgm2Hchgchgl" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2lgm2Hchgchgl" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::Sigma2lgm2Hchgchgl *)new Pythia8::Sigma2lgm2Hchgchgl(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2lgm2Hchgchgl, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2lgm2Hchgchgl_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2lgm2Hchgchgl *arg1 = (Pythia8::Sigma2lgm2Hchgchgl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2lgm2Hchgchgl_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2lgm2Hchgchgl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2lgm2Hchgchgl_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2lgm2Hchgchgl *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2lgm2Hchgchgl * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2lgm2Hchgchgl_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2lgm2Hchgchgl *arg1 = (Pythia8::Sigma2lgm2Hchgchgl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2lgm2Hchgchgl_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2lgm2Hchgchgl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2lgm2Hchgchgl_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2lgm2Hchgchgl *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2lgm2Hchgchgl * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2lgm2Hchgchgl_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2lgm2Hchgchgl *arg1 = (Pythia8::Sigma2lgm2Hchgchgl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2lgm2Hchgchgl_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2lgm2Hchgchgl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2lgm2Hchgchgl_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2lgm2Hchgchgl *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2lgm2Hchgchgl * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2lgm2Hchgchgl_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2lgm2Hchgchgl *arg1 = (Pythia8::Sigma2lgm2Hchgchgl *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2lgm2Hchgchgl_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2lgm2Hchgchgl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2lgm2Hchgchgl_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2lgm2Hchgchgl *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2lgm2Hchgchgl * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2lgm2Hchgchgl_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2lgm2Hchgchgl_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2lgm2Hchgchgl_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2lgm2Hchgchgl_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2lgm2Hchgchgl_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2lgm2Hchgchgl *arg1 = (Pythia8::Sigma2lgm2Hchgchgl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2lgm2Hchgchgl_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2lgm2Hchgchgl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2lgm2Hchgchgl_name" "', argument " "1"" of type '" "Pythia8::Sigma2lgm2Hchgchgl const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2lgm2Hchgchgl * >(argp1);
  result = ((Pythia8::Sigma2lgm2Hchgchgl const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2lgm2Hchgchgl_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2lgm2Hchgchgl *arg1 = (Pythia8::Sigma2lgm2Hchgchgl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2lgm2Hchgchgl_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2lgm2Hchgchgl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2lgm2Hchgchgl_code" "', argument " "1"" of type '" "Pythia8::Sigma2lgm2Hchgchgl const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2lgm2Hchgchgl * >(argp1);
  result = (int)((Pythia8::Sigma2lgm2Hchgchgl const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2lgm2Hchgchgl_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2lgm2Hchgchgl *arg1 = (Pythia8::Sigma2lgm2Hchgchgl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2lgm2Hchgchgl_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2lgm2Hchgchgl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2lgm2Hchgchgl_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2lgm2Hchgchgl const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2lgm2Hchgchgl * >(argp1);
  result = ((Pythia8::Sigma2lgm2Hchgchgl const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2lgm2Hchgchgl_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2lgm2Hchgchgl *arg1 = (Pythia8::Sigma2lgm2Hchgchgl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2lgm2Hchgchgl_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2lgm2Hchgchgl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2lgm2Hchgchgl_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma2lgm2Hchgchgl const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2lgm2Hchgchgl * >(argp1);
  result = (int)((Pythia8::Sigma2lgm2Hchgchgl const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2lgm2Hchgchgl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2lgm2Hchgchgl *arg1 = (Pythia8::Sigma2lgm2Hchgchgl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2lgm2Hchgchgl",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2lgm2Hchgchgl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2lgm2Hchgchgl" "', argument " "1"" of type '" "Pythia8::Sigma2lgm2Hchgchgl *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2lgm2Hchgchgl * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2lgm2Hchgchgl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2lgm2Hchgchgl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma3ff2HchgchgfftWW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma3ff2HchgchgfftWW *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma3ff2HchgchgfftWW",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma3ff2HchgchgfftWW" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Sigma3ff2HchgchgfftWW *)new Pythia8::Sigma3ff2HchgchgfftWW(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma3ff2HchgchgfftWW, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HchgchgfftWW_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HchgchgfftWW *arg1 = (Pythia8::Sigma3ff2HchgchgfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HchgchgfftWW_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HchgchgfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HchgchgfftWW_initProc" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HchgchgfftWW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HchgchgfftWW * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HchgchgfftWW_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HchgchgfftWW *arg1 = (Pythia8::Sigma3ff2HchgchgfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HchgchgfftWW_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HchgchgfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HchgchgfftWW_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HchgchgfftWW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HchgchgfftWW * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HchgchgfftWW_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HchgchgfftWW *arg1 = (Pythia8::Sigma3ff2HchgchgfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HchgchgfftWW_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HchgchgfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HchgchgfftWW_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HchgchgfftWW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HchgchgfftWW * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HchgchgfftWW_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HchgchgfftWW *arg1 = (Pythia8::Sigma3ff2HchgchgfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HchgchgfftWW_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HchgchgfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HchgchgfftWW_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HchgchgfftWW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HchgchgfftWW * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HchgchgfftWW_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HchgchgfftWW *arg1 = (Pythia8::Sigma3ff2HchgchgfftWW *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma3ff2HchgchgfftWW_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HchgchgfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HchgchgfftWW_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HchgchgfftWW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HchgchgfftWW * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma3ff2HchgchgfftWW_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma3ff2HchgchgfftWW_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma3ff2HchgchgfftWW_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma3ff2HchgchgfftWW_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HchgchgfftWW_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HchgchgfftWW *arg1 = (Pythia8::Sigma3ff2HchgchgfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HchgchgfftWW_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HchgchgfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HchgchgfftWW_name" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HchgchgfftWW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HchgchgfftWW * >(argp1);
  result = ((Pythia8::Sigma3ff2HchgchgfftWW const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HchgchgfftWW_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HchgchgfftWW *arg1 = (Pythia8::Sigma3ff2HchgchgfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HchgchgfftWW_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HchgchgfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HchgchgfftWW_code" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HchgchgfftWW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HchgchgfftWW * >(argp1);
  result = (int)((Pythia8::Sigma3ff2HchgchgfftWW const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HchgchgfftWW_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HchgchgfftWW *arg1 = (Pythia8::Sigma3ff2HchgchgfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HchgchgfftWW_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HchgchgfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HchgchgfftWW_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HchgchgfftWW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HchgchgfftWW * >(argp1);
  result = ((Pythia8::Sigma3ff2HchgchgfftWW const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HchgchgfftWW_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HchgchgfftWW *arg1 = (Pythia8::Sigma3ff2HchgchgfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HchgchgfftWW_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HchgchgfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HchgchgfftWW_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HchgchgfftWW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HchgchgfftWW * >(argp1);
  result = (int)((Pythia8::Sigma3ff2HchgchgfftWW const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HchgchgfftWW_idTchan1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HchgchgfftWW *arg1 = (Pythia8::Sigma3ff2HchgchgfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HchgchgfftWW_idTchan1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HchgchgfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HchgchgfftWW_idTchan1" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HchgchgfftWW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HchgchgfftWW * >(argp1);
  result = (int)((Pythia8::Sigma3ff2HchgchgfftWW const *)arg1)->idTchan1();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HchgchgfftWW_idTchan2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HchgchgfftWW *arg1 = (Pythia8::Sigma3ff2HchgchgfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HchgchgfftWW_idTchan2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HchgchgfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HchgchgfftWW_idTchan2" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HchgchgfftWW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HchgchgfftWW * >(argp1);
  result = (int)((Pythia8::Sigma3ff2HchgchgfftWW const *)arg1)->idTchan2();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HchgchgfftWW_tChanFracPow1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HchgchgfftWW *arg1 = (Pythia8::Sigma3ff2HchgchgfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HchgchgfftWW_tChanFracPow1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HchgchgfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HchgchgfftWW_tChanFracPow1" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HchgchgfftWW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HchgchgfftWW * >(argp1);
  result = (double)((Pythia8::Sigma3ff2HchgchgfftWW const *)arg1)->tChanFracPow1();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HchgchgfftWW_tChanFracPow2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HchgchgfftWW *arg1 = (Pythia8::Sigma3ff2HchgchgfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HchgchgfftWW_tChanFracPow2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HchgchgfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HchgchgfftWW_tChanFracPow2" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HchgchgfftWW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HchgchgfftWW * >(argp1);
  result = (double)((Pythia8::Sigma3ff2HchgchgfftWW const *)arg1)->tChanFracPow2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma3ff2HchgchgfftWW_useMirrorWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HchgchgfftWW *arg1 = (Pythia8::Sigma3ff2HchgchgfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma3ff2HchgchgfftWW_useMirrorWeight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HchgchgfftWW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma3ff2HchgchgfftWW_useMirrorWeight" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HchgchgfftWW const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HchgchgfftWW * >(argp1);
  result = (bool)((Pythia8::Sigma3ff2HchgchgfftWW const *)arg1)->useMirrorWeight();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma3ff2HchgchgfftWW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma3ff2HchgchgfftWW *arg1 = (Pythia8::Sigma3ff2HchgchgfftWW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma3ff2HchgchgfftWW",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma3ff2HchgchgfftWW, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma3ff2HchgchgfftWW" "', argument " "1"" of type '" "Pythia8::Sigma3ff2HchgchgfftWW *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma3ff2HchgchgfftWW * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma3ff2HchgchgfftWW_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma3ff2HchgchgfftWW, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2ffbar2HchgchgHchgchg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma2ffbar2HchgchgHchgchg *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma2ffbar2HchgchgHchgchg",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2ffbar2HchgchgHchgchg" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Sigma2ffbar2HchgchgHchgchg *)new Pythia8::Sigma2ffbar2HchgchgHchgchg(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgchgHchgchg, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HchgchgHchgchg_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HchgchgHchgchg *arg1 = (Pythia8::Sigma2ffbar2HchgchgHchgchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HchgchgHchgchg_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgchgHchgchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HchgchgHchgchg_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HchgchgHchgchg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HchgchgHchgchg * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HchgchgHchgchg_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HchgchgHchgchg *arg1 = (Pythia8::Sigma2ffbar2HchgchgHchgchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HchgchgHchgchg_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgchgHchgchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HchgchgHchgchg_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HchgchgHchgchg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HchgchgHchgchg * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HchgchgHchgchg_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HchgchgHchgchg *arg1 = (Pythia8::Sigma2ffbar2HchgchgHchgchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HchgchgHchgchg_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgchgHchgchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HchgchgHchgchg_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HchgchgHchgchg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HchgchgHchgchg * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HchgchgHchgchg_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HchgchgHchgchg *arg1 = (Pythia8::Sigma2ffbar2HchgchgHchgchg *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2ffbar2HchgchgHchgchg_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgchgHchgchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HchgchgHchgchg_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HchgchgHchgchg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HchgchgHchgchg * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2ffbar2HchgchgHchgchg_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2ffbar2HchgchgHchgchg_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2ffbar2HchgchgHchgchg_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2ffbar2HchgchgHchgchg_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HchgchgHchgchg_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HchgchgHchgchg *arg1 = (Pythia8::Sigma2ffbar2HchgchgHchgchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HchgchgHchgchg_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgchgHchgchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HchgchgHchgchg_name" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HchgchgHchgchg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HchgchgHchgchg * >(argp1);
  result = ((Pythia8::Sigma2ffbar2HchgchgHchgchg const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HchgchgHchgchg_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HchgchgHchgchg *arg1 = (Pythia8::Sigma2ffbar2HchgchgHchgchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HchgchgHchgchg_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgchgHchgchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HchgchgHchgchg_code" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HchgchgHchgchg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HchgchgHchgchg * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2HchgchgHchgchg const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HchgchgHchgchg_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HchgchgHchgchg *arg1 = (Pythia8::Sigma2ffbar2HchgchgHchgchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HchgchgHchgchg_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgchgHchgchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HchgchgHchgchg_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HchgchgHchgchg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HchgchgHchgchg * >(argp1);
  result = ((Pythia8::Sigma2ffbar2HchgchgHchgchg const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HchgchgHchgchg_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HchgchgHchgchg *arg1 = (Pythia8::Sigma2ffbar2HchgchgHchgchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HchgchgHchgchg_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgchgHchgchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HchgchgHchgchg_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HchgchgHchgchg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HchgchgHchgchg * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2HchgchgHchgchg const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HchgchgHchgchg_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HchgchgHchgchg *arg1 = (Pythia8::Sigma2ffbar2HchgchgHchgchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HchgchgHchgchg_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgchgHchgchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HchgchgHchgchg_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HchgchgHchgchg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HchgchgHchgchg * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2HchgchgHchgchg const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2ffbar2HchgchgHchgchg_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HchgchgHchgchg *arg1 = (Pythia8::Sigma2ffbar2HchgchgHchgchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2ffbar2HchgchgHchgchg_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgchgHchgchg, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2ffbar2HchgchgHchgchg_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HchgchgHchgchg const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HchgchgHchgchg * >(argp1);
  result = (int)((Pythia8::Sigma2ffbar2HchgchgHchgchg const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2ffbar2HchgchgHchgchg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2ffbar2HchgchgHchgchg *arg1 = (Pythia8::Sigma2ffbar2HchgchgHchgchg *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2ffbar2HchgchgHchgchg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgchgHchgchg, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2ffbar2HchgchgHchgchg" "', argument " "1"" of type '" "Pythia8::Sigma2ffbar2HchgchgHchgchg *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2ffbar2HchgchgHchgchg * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2ffbar2HchgchgHchgchg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2ffbar2HchgchgHchgchg, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma1ql2LeptoQuark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ql2LeptoQuark *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma1ql2LeptoQuark")) SWIG_fail;
  result = (Pythia8::Sigma1ql2LeptoQuark *)new Pythia8::Sigma1ql2LeptoQuark();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma1ql2LeptoQuark, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ql2LeptoQuark_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ql2LeptoQuark *arg1 = (Pythia8::Sigma1ql2LeptoQuark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ql2LeptoQuark_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ql2LeptoQuark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ql2LeptoQuark_initProc" "', argument " "1"" of type '" "Pythia8::Sigma1ql2LeptoQuark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ql2LeptoQuark * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ql2LeptoQuark_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ql2LeptoQuark *arg1 = (Pythia8::Sigma1ql2LeptoQuark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ql2LeptoQuark_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ql2LeptoQuark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ql2LeptoQuark_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma1ql2LeptoQuark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ql2LeptoQuark * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ql2LeptoQuark_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ql2LeptoQuark *arg1 = (Pythia8::Sigma1ql2LeptoQuark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ql2LeptoQuark_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ql2LeptoQuark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ql2LeptoQuark_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma1ql2LeptoQuark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ql2LeptoQuark * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ql2LeptoQuark_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ql2LeptoQuark *arg1 = (Pythia8::Sigma1ql2LeptoQuark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ql2LeptoQuark_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ql2LeptoQuark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ql2LeptoQuark_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma1ql2LeptoQuark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ql2LeptoQuark * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ql2LeptoQuark_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ql2LeptoQuark *arg1 = (Pythia8::Sigma1ql2LeptoQuark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ql2LeptoQuark_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ql2LeptoQuark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ql2LeptoQuark_name" "', argument " "1"" of type '" "Pythia8::Sigma1ql2LeptoQuark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ql2LeptoQuark * >(argp1);
  result = ((Pythia8::Sigma1ql2LeptoQuark const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ql2LeptoQuark_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ql2LeptoQuark *arg1 = (Pythia8::Sigma1ql2LeptoQuark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ql2LeptoQuark_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ql2LeptoQuark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ql2LeptoQuark_code" "', argument " "1"" of type '" "Pythia8::Sigma1ql2LeptoQuark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ql2LeptoQuark * >(argp1);
  result = (int)((Pythia8::Sigma1ql2LeptoQuark const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ql2LeptoQuark_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ql2LeptoQuark *arg1 = (Pythia8::Sigma1ql2LeptoQuark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ql2LeptoQuark_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ql2LeptoQuark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ql2LeptoQuark_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma1ql2LeptoQuark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ql2LeptoQuark * >(argp1);
  result = ((Pythia8::Sigma1ql2LeptoQuark const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ql2LeptoQuark_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ql2LeptoQuark *arg1 = (Pythia8::Sigma1ql2LeptoQuark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ql2LeptoQuark_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ql2LeptoQuark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ql2LeptoQuark_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma1ql2LeptoQuark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ql2LeptoQuark * >(argp1);
  result = (int)((Pythia8::Sigma1ql2LeptoQuark const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma1ql2LeptoQuark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ql2LeptoQuark *arg1 = (Pythia8::Sigma1ql2LeptoQuark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma1ql2LeptoQuark",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ql2LeptoQuark, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma1ql2LeptoQuark" "', argument " "1"" of type '" "Pythia8::Sigma1ql2LeptoQuark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ql2LeptoQuark * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma1ql2LeptoQuark_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma1ql2LeptoQuark, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qg2LeptoQuarkl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LeptoQuarkl *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qg2LeptoQuarkl")) SWIG_fail;
  result = (Pythia8::Sigma2qg2LeptoQuarkl *)new Pythia8::Sigma2qg2LeptoQuarkl();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qg2LeptoQuarkl, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2LeptoQuarkl_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LeptoQuarkl *arg1 = (Pythia8::Sigma2qg2LeptoQuarkl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2LeptoQuarkl_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LeptoQuarkl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2LeptoQuarkl_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LeptoQuarkl *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LeptoQuarkl * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2LeptoQuarkl_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LeptoQuarkl *arg1 = (Pythia8::Sigma2qg2LeptoQuarkl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2LeptoQuarkl_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LeptoQuarkl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2LeptoQuarkl_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LeptoQuarkl *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LeptoQuarkl * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2LeptoQuarkl_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LeptoQuarkl *arg1 = (Pythia8::Sigma2qg2LeptoQuarkl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2LeptoQuarkl_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LeptoQuarkl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2LeptoQuarkl_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LeptoQuarkl *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LeptoQuarkl * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2LeptoQuarkl_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LeptoQuarkl *arg1 = (Pythia8::Sigma2qg2LeptoQuarkl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2LeptoQuarkl_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LeptoQuarkl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2LeptoQuarkl_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LeptoQuarkl *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LeptoQuarkl * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2LeptoQuarkl_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LeptoQuarkl *arg1 = (Pythia8::Sigma2qg2LeptoQuarkl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2LeptoQuarkl_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LeptoQuarkl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2LeptoQuarkl_name" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LeptoQuarkl const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LeptoQuarkl * >(argp1);
  result = ((Pythia8::Sigma2qg2LeptoQuarkl const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2LeptoQuarkl_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LeptoQuarkl *arg1 = (Pythia8::Sigma2qg2LeptoQuarkl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2LeptoQuarkl_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LeptoQuarkl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2LeptoQuarkl_code" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LeptoQuarkl const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LeptoQuarkl * >(argp1);
  result = (int)((Pythia8::Sigma2qg2LeptoQuarkl const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2LeptoQuarkl_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LeptoQuarkl *arg1 = (Pythia8::Sigma2qg2LeptoQuarkl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2LeptoQuarkl_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LeptoQuarkl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2LeptoQuarkl_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LeptoQuarkl const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LeptoQuarkl * >(argp1);
  result = ((Pythia8::Sigma2qg2LeptoQuarkl const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2LeptoQuarkl_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LeptoQuarkl *arg1 = (Pythia8::Sigma2qg2LeptoQuarkl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2LeptoQuarkl_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LeptoQuarkl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2LeptoQuarkl_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LeptoQuarkl const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LeptoQuarkl * >(argp1);
  result = (int)((Pythia8::Sigma2qg2LeptoQuarkl const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qg2LeptoQuarkl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2LeptoQuarkl *arg1 = (Pythia8::Sigma2qg2LeptoQuarkl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qg2LeptoQuarkl",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2LeptoQuarkl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qg2LeptoQuarkl" "', argument " "1"" of type '" "Pythia8::Sigma2qg2LeptoQuarkl *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2LeptoQuarkl * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qg2LeptoQuarkl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qg2LeptoQuarkl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2gg2LQLQbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LQLQbar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2gg2LQLQbar")) SWIG_fail;
  result = (Pythia8::Sigma2gg2LQLQbar *)new Pythia8::Sigma2gg2LQLQbar();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gg2LQLQbar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LQLQbar_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LQLQbar *arg1 = (Pythia8::Sigma2gg2LQLQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LQLQbar_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LQLQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LQLQbar_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LQLQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LQLQbar * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LQLQbar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LQLQbar *arg1 = (Pythia8::Sigma2gg2LQLQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LQLQbar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LQLQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LQLQbar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LQLQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LQLQbar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LQLQbar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LQLQbar *arg1 = (Pythia8::Sigma2gg2LQLQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LQLQbar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LQLQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LQLQbar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LQLQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LQLQbar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LQLQbar_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LQLQbar *arg1 = (Pythia8::Sigma2gg2LQLQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LQLQbar_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LQLQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LQLQbar_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LQLQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LQLQbar * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LQLQbar_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LQLQbar *arg1 = (Pythia8::Sigma2gg2LQLQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LQLQbar_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LQLQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LQLQbar_name" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LQLQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LQLQbar * >(argp1);
  result = ((Pythia8::Sigma2gg2LQLQbar const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LQLQbar_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LQLQbar *arg1 = (Pythia8::Sigma2gg2LQLQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LQLQbar_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LQLQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LQLQbar_code" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LQLQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LQLQbar * >(argp1);
  result = (int)((Pythia8::Sigma2gg2LQLQbar const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LQLQbar_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LQLQbar *arg1 = (Pythia8::Sigma2gg2LQLQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LQLQbar_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LQLQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LQLQbar_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LQLQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LQLQbar * >(argp1);
  result = ((Pythia8::Sigma2gg2LQLQbar const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LQLQbar_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LQLQbar *arg1 = (Pythia8::Sigma2gg2LQLQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LQLQbar_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LQLQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LQLQbar_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LQLQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LQLQbar * >(argp1);
  result = (int)((Pythia8::Sigma2gg2LQLQbar const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2LQLQbar_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LQLQbar *arg1 = (Pythia8::Sigma2gg2LQLQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2LQLQbar_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LQLQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2LQLQbar_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LQLQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LQLQbar * >(argp1);
  result = (int)((Pythia8::Sigma2gg2LQLQbar const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2gg2LQLQbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2LQLQbar *arg1 = (Pythia8::Sigma2gg2LQLQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2gg2LQLQbar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2LQLQbar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2gg2LQLQbar" "', argument " "1"" of type '" "Pythia8::Sigma2gg2LQLQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2LQLQbar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2gg2LQLQbar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2gg2LQLQbar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2LQLQbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LQLQbar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qqbar2LQLQbar")) SWIG_fail;
  result = (Pythia8::Sigma2qqbar2LQLQbar *)new Pythia8::Sigma2qqbar2LQLQbar();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2LQLQbar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LQLQbar_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LQLQbar *arg1 = (Pythia8::Sigma2qqbar2LQLQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LQLQbar_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LQLQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LQLQbar_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LQLQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LQLQbar * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LQLQbar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LQLQbar *arg1 = (Pythia8::Sigma2qqbar2LQLQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LQLQbar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LQLQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LQLQbar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LQLQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LQLQbar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LQLQbar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LQLQbar *arg1 = (Pythia8::Sigma2qqbar2LQLQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LQLQbar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LQLQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LQLQbar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LQLQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LQLQbar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LQLQbar_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LQLQbar *arg1 = (Pythia8::Sigma2qqbar2LQLQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LQLQbar_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LQLQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LQLQbar_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LQLQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LQLQbar * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LQLQbar_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LQLQbar *arg1 = (Pythia8::Sigma2qqbar2LQLQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LQLQbar_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LQLQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LQLQbar_name" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LQLQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LQLQbar * >(argp1);
  result = ((Pythia8::Sigma2qqbar2LQLQbar const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LQLQbar_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LQLQbar *arg1 = (Pythia8::Sigma2qqbar2LQLQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LQLQbar_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LQLQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LQLQbar_code" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LQLQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LQLQbar * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2LQLQbar const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LQLQbar_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LQLQbar *arg1 = (Pythia8::Sigma2qqbar2LQLQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LQLQbar_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LQLQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LQLQbar_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LQLQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LQLQbar * >(argp1);
  result = ((Pythia8::Sigma2qqbar2LQLQbar const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LQLQbar_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LQLQbar *arg1 = (Pythia8::Sigma2qqbar2LQLQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LQLQbar_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LQLQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LQLQbar_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LQLQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LQLQbar * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2LQLQbar const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2LQLQbar_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LQLQbar *arg1 = (Pythia8::Sigma2qqbar2LQLQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2LQLQbar_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LQLQbar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2LQLQbar_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LQLQbar const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LQLQbar * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2LQLQbar const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2LQLQbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2LQLQbar *arg1 = (Pythia8::Sigma2qqbar2LQLQbar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2LQLQbar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2LQLQbar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2LQLQbar" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2LQLQbar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2LQLQbar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2LQLQbar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2LQLQbar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma1ffbarZprimeWprime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbarZprimeWprime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma1ffbarZprimeWprime")) SWIG_fail;
  result = (Pythia8::Sigma1ffbarZprimeWprime *)new Pythia8::Sigma1ffbarZprimeWprime();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma1ffbarZprimeWprime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma1ffbarZprimeWprime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbarZprimeWprime *arg1 = (Pythia8::Sigma1ffbarZprimeWprime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma1ffbarZprimeWprime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbarZprimeWprime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma1ffbarZprimeWprime" "', argument " "1"" of type '" "Pythia8::Sigma1ffbarZprimeWprime *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbarZprimeWprime * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma1ffbarZprimeWprime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma1ffbarZprimeWprime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma1ffbar2gmZZprime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2gmZZprime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma1ffbar2gmZZprime")) SWIG_fail;
  result = (Pythia8::Sigma1ffbar2gmZZprime *)new Pythia8::Sigma1ffbar2gmZZprime();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZZprime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2gmZZprime_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2gmZZprime *arg1 = (Pythia8::Sigma1ffbar2gmZZprime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2gmZZprime_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZZprime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2gmZZprime_initProc" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2gmZZprime *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2gmZZprime * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2gmZZprime_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2gmZZprime *arg1 = (Pythia8::Sigma1ffbar2gmZZprime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2gmZZprime_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZZprime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2gmZZprime_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2gmZZprime *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2gmZZprime * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2gmZZprime_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2gmZZprime *arg1 = (Pythia8::Sigma1ffbar2gmZZprime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2gmZZprime_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZZprime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2gmZZprime_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2gmZZprime *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2gmZZprime * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2gmZZprime_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2gmZZprime *arg1 = (Pythia8::Sigma1ffbar2gmZZprime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2gmZZprime_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZZprime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2gmZZprime_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2gmZZprime *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2gmZZprime * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2gmZZprime_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2gmZZprime *arg1 = (Pythia8::Sigma1ffbar2gmZZprime *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma1ffbar2gmZZprime_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZZprime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2gmZZprime_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2gmZZprime *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2gmZZprime * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma1ffbar2gmZZprime_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma1ffbar2gmZZprime_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma1ffbar2gmZZprime_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma1ffbar2gmZZprime_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2gmZZprime_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2gmZZprime *arg1 = (Pythia8::Sigma1ffbar2gmZZprime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2gmZZprime_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZZprime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2gmZZprime_name" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2gmZZprime const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2gmZZprime * >(argp1);
  result = ((Pythia8::Sigma1ffbar2gmZZprime const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2gmZZprime_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2gmZZprime *arg1 = (Pythia8::Sigma1ffbar2gmZZprime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2gmZZprime_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZZprime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2gmZZprime_code" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2gmZZprime const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2gmZZprime * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2gmZZprime const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2gmZZprime_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2gmZZprime *arg1 = (Pythia8::Sigma1ffbar2gmZZprime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2gmZZprime_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZZprime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2gmZZprime_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2gmZZprime const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2gmZZprime * >(argp1);
  result = ((Pythia8::Sigma1ffbar2gmZZprime const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2gmZZprime_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2gmZZprime *arg1 = (Pythia8::Sigma1ffbar2gmZZprime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2gmZZprime_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZZprime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2gmZZprime_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2gmZZprime const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2gmZZprime * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2gmZZprime const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2gmZZprime_resonanceB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2gmZZprime *arg1 = (Pythia8::Sigma1ffbar2gmZZprime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2gmZZprime_resonanceB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZZprime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2gmZZprime_resonanceB" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2gmZZprime const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2gmZZprime * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2gmZZprime const *)arg1)->resonanceB();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma1ffbar2gmZZprime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2gmZZprime *arg1 = (Pythia8::Sigma1ffbar2gmZZprime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma1ffbar2gmZZprime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZZprime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma1ffbar2gmZZprime" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2gmZZprime *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2gmZZprime * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma1ffbar2gmZZprime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma1ffbar2gmZZprime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma1ffbar2Wprime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Wprime *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma1ffbar2Wprime")) SWIG_fail;
  result = (Pythia8::Sigma1ffbar2Wprime *)new Pythia8::Sigma1ffbar2Wprime();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma1ffbar2Wprime, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Wprime_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Wprime *arg1 = (Pythia8::Sigma1ffbar2Wprime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Wprime_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Wprime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Wprime_initProc" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Wprime *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Wprime * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Wprime_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Wprime *arg1 = (Pythia8::Sigma1ffbar2Wprime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Wprime_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Wprime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Wprime_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Wprime *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Wprime * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Wprime_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Wprime *arg1 = (Pythia8::Sigma1ffbar2Wprime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Wprime_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Wprime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Wprime_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Wprime *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Wprime * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Wprime_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Wprime *arg1 = (Pythia8::Sigma1ffbar2Wprime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Wprime_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Wprime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Wprime_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Wprime *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Wprime * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Wprime_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Wprime *arg1 = (Pythia8::Sigma1ffbar2Wprime *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma1ffbar2Wprime_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Wprime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Wprime_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Wprime *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Wprime * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma1ffbar2Wprime_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma1ffbar2Wprime_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma1ffbar2Wprime_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma1ffbar2Wprime_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Wprime_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Wprime *arg1 = (Pythia8::Sigma1ffbar2Wprime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Wprime_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Wprime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Wprime_name" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Wprime const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Wprime * >(argp1);
  result = ((Pythia8::Sigma1ffbar2Wprime const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Wprime_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Wprime *arg1 = (Pythia8::Sigma1ffbar2Wprime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Wprime_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Wprime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Wprime_code" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Wprime const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Wprime * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2Wprime const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Wprime_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Wprime *arg1 = (Pythia8::Sigma1ffbar2Wprime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Wprime_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Wprime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Wprime_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Wprime const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Wprime * >(argp1);
  result = ((Pythia8::Sigma1ffbar2Wprime const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Wprime_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Wprime *arg1 = (Pythia8::Sigma1ffbar2Wprime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Wprime_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Wprime, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Wprime_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Wprime const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Wprime * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2Wprime const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma1ffbar2Wprime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Wprime *arg1 = (Pythia8::Sigma1ffbar2Wprime *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma1ffbar2Wprime",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Wprime, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma1ffbar2Wprime" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Wprime *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Wprime * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma1ffbar2Wprime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma1ffbar2Wprime, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma1ffbar2Rhorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Rhorizontal *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma1ffbar2Rhorizontal")) SWIG_fail;
  result = (Pythia8::Sigma1ffbar2Rhorizontal *)new Pythia8::Sigma1ffbar2Rhorizontal();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma1ffbar2Rhorizontal, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Rhorizontal_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Rhorizontal *arg1 = (Pythia8::Sigma1ffbar2Rhorizontal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Rhorizontal_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Rhorizontal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Rhorizontal_initProc" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Rhorizontal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Rhorizontal * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Rhorizontal_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Rhorizontal *arg1 = (Pythia8::Sigma1ffbar2Rhorizontal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Rhorizontal_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Rhorizontal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Rhorizontal_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Rhorizontal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Rhorizontal * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Rhorizontal_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Rhorizontal *arg1 = (Pythia8::Sigma1ffbar2Rhorizontal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Rhorizontal_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Rhorizontal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Rhorizontal_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Rhorizontal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Rhorizontal * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Rhorizontal_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Rhorizontal *arg1 = (Pythia8::Sigma1ffbar2Rhorizontal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Rhorizontal_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Rhorizontal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Rhorizontal_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Rhorizontal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Rhorizontal * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Rhorizontal_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Rhorizontal *arg1 = (Pythia8::Sigma1ffbar2Rhorizontal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Rhorizontal_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Rhorizontal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Rhorizontal_name" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Rhorizontal const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Rhorizontal * >(argp1);
  result = ((Pythia8::Sigma1ffbar2Rhorizontal const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Rhorizontal_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Rhorizontal *arg1 = (Pythia8::Sigma1ffbar2Rhorizontal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Rhorizontal_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Rhorizontal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Rhorizontal_code" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Rhorizontal const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Rhorizontal * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2Rhorizontal const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Rhorizontal_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Rhorizontal *arg1 = (Pythia8::Sigma1ffbar2Rhorizontal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Rhorizontal_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Rhorizontal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Rhorizontal_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Rhorizontal const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Rhorizontal * >(argp1);
  result = ((Pythia8::Sigma1ffbar2Rhorizontal const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1ffbar2Rhorizontal_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Rhorizontal *arg1 = (Pythia8::Sigma1ffbar2Rhorizontal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1ffbar2Rhorizontal_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Rhorizontal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1ffbar2Rhorizontal_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Rhorizontal const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Rhorizontal * >(argp1);
  result = (int)((Pythia8::Sigma1ffbar2Rhorizontal const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma1ffbar2Rhorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1ffbar2Rhorizontal *arg1 = (Pythia8::Sigma1ffbar2Rhorizontal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma1ffbar2Rhorizontal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1ffbar2Rhorizontal, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma1ffbar2Rhorizontal" "', argument " "1"" of type '" "Pythia8::Sigma1ffbar2Rhorizontal *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1ffbar2Rhorizontal * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma1ffbar2Rhorizontal_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma1ffbar2Rhorizontal, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SigmaOniaSetup__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaOniaSetup *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SigmaOniaSetup")) SWIG_fail;
  result = (Pythia8::SigmaOniaSetup *)new Pythia8::SigmaOniaSetup();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SigmaOniaSetup, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SigmaOniaSetup__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg2 = (Pythia8::Settings *) 0 ;
  Pythia8::ParticleData *arg3 = (Pythia8::ParticleData *) 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::SigmaOniaSetup *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_SigmaOniaSetup",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SigmaOniaSetup" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SigmaOniaSetup" "', argument " "2"" of type '" "Pythia8::Settings *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SigmaOniaSetup" "', argument " "3"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ParticleData * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SigmaOniaSetup" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (Pythia8::SigmaOniaSetup *)new Pythia8::SigmaOniaSetup(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SigmaOniaSetup, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SigmaOniaSetup(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_SigmaOniaSetup__SWIG_0(self, args);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SigmaOniaSetup__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SigmaOniaSetup'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaOniaSetup::SigmaOniaSetup()\n"
    "    Pythia8::SigmaOniaSetup::SigmaOniaSetup(Pythia8::Info *,Pythia8::Settings *,Pythia8::ParticleData *,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaOniaSetup_setupSigma2gg__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaOniaSetup *arg1 = (Pythia8::SigmaOniaSetup *) 0 ;
  std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaOniaSetup_setupSigma2gg",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaOniaSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaOniaSetup_setupSigma2gg" "', argument " "1"" of type '" "Pythia8::SigmaOniaSetup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaOniaSetup * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaOniaSetup_setupSigma2gg" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaOniaSetup_setupSigma2gg" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaOniaSetup_setupSigma2gg" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setupSigma2gg(*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaOniaSetup_setupSigma2gg__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaOniaSetup *arg1 = (Pythia8::SigmaOniaSetup *) 0 ;
  std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaOniaSetup_setupSigma2gg",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaOniaSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaOniaSetup_setupSigma2gg" "', argument " "1"" of type '" "Pythia8::SigmaOniaSetup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaOniaSetup * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaOniaSetup_setupSigma2gg" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaOniaSetup_setupSigma2gg" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > * >(argp2);
  (arg1)->setupSigma2gg(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaOniaSetup_setupSigma2gg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaOniaSetup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SigmaOniaSetup_setupSigma2gg__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaOniaSetup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SigmaOniaSetup_setupSigma2gg__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaOniaSetup_setupSigma2gg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaOniaSetup::setupSigma2gg(std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &,bool)\n"
    "    Pythia8::SigmaOniaSetup::setupSigma2gg(std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaOniaSetup_setupSigma2qg__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaOniaSetup *arg1 = (Pythia8::SigmaOniaSetup *) 0 ;
  std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaOniaSetup_setupSigma2qg",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaOniaSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaOniaSetup_setupSigma2qg" "', argument " "1"" of type '" "Pythia8::SigmaOniaSetup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaOniaSetup * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaOniaSetup_setupSigma2qg" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaOniaSetup_setupSigma2qg" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaOniaSetup_setupSigma2qg" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setupSigma2qg(*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaOniaSetup_setupSigma2qg__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaOniaSetup *arg1 = (Pythia8::SigmaOniaSetup *) 0 ;
  std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaOniaSetup_setupSigma2qg",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaOniaSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaOniaSetup_setupSigma2qg" "', argument " "1"" of type '" "Pythia8::SigmaOniaSetup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaOniaSetup * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaOniaSetup_setupSigma2qg" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaOniaSetup_setupSigma2qg" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > * >(argp2);
  (arg1)->setupSigma2qg(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaOniaSetup_setupSigma2qg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaOniaSetup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SigmaOniaSetup_setupSigma2qg__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaOniaSetup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SigmaOniaSetup_setupSigma2qg__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaOniaSetup_setupSigma2qg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaOniaSetup::setupSigma2qg(std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &,bool)\n"
    "    Pythia8::SigmaOniaSetup::setupSigma2qg(std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaOniaSetup_setupSigma2qq__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaOniaSetup *arg1 = (Pythia8::SigmaOniaSetup *) 0 ;
  std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaOniaSetup_setupSigma2qq",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaOniaSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaOniaSetup_setupSigma2qq" "', argument " "1"" of type '" "Pythia8::SigmaOniaSetup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaOniaSetup * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaOniaSetup_setupSigma2qq" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaOniaSetup_setupSigma2qq" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaOniaSetup_setupSigma2qq" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setupSigma2qq(*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaOniaSetup_setupSigma2qq__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaOniaSetup *arg1 = (Pythia8::SigmaOniaSetup *) 0 ;
  std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaOniaSetup_setupSigma2qq",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaOniaSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaOniaSetup_setupSigma2qq" "', argument " "1"" of type '" "Pythia8::SigmaOniaSetup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaOniaSetup * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaOniaSetup_setupSigma2qq" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaOniaSetup_setupSigma2qq" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > * >(argp2);
  (arg1)->setupSigma2qq(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaOniaSetup_setupSigma2qq(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaOniaSetup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SigmaOniaSetup_setupSigma2qq__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaOniaSetup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SigmaOniaSetup_setupSigma2qq__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaOniaSetup_setupSigma2qq'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaOniaSetup::setupSigma2qq(std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &,bool)\n"
    "    Pythia8::SigmaOniaSetup::setupSigma2qq(std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SigmaOniaSetup_setupSigma2dbl__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaOniaSetup *arg1 = (Pythia8::SigmaOniaSetup *) 0 ;
  std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SigmaOniaSetup_setupSigma2dbl",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaOniaSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaOniaSetup_setupSigma2dbl" "', argument " "1"" of type '" "Pythia8::SigmaOniaSetup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaOniaSetup * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaOniaSetup_setupSigma2dbl" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaOniaSetup_setupSigma2dbl" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SigmaOniaSetup_setupSigma2dbl" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setupSigma2dbl(*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaOniaSetup_setupSigma2dbl__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaOniaSetup *arg1 = (Pythia8::SigmaOniaSetup *) 0 ;
  std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SigmaOniaSetup_setupSigma2dbl",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaOniaSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SigmaOniaSetup_setupSigma2dbl" "', argument " "1"" of type '" "Pythia8::SigmaOniaSetup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaOniaSetup * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SigmaOniaSetup_setupSigma2dbl" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SigmaOniaSetup_setupSigma2dbl" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > * >(argp2);
  (arg1)->setupSigma2dbl(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SigmaOniaSetup_setupSigma2dbl(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaOniaSetup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SigmaOniaSetup_setupSigma2dbl__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaOniaSetup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SigmaOniaSetup_setupSigma2dbl__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SigmaOniaSetup_setupSigma2dbl'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SigmaOniaSetup::setupSigma2dbl(std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &,bool)\n"
    "    Pythia8::SigmaOniaSetup::setupSigma2dbl(std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_SigmaOniaSetup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaOniaSetup *arg1 = (Pythia8::SigmaOniaSetup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SigmaOniaSetup",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaOniaSetup, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SigmaOniaSetup" "', argument " "1"" of type '" "Pythia8::SigmaOniaSetup *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaOniaSetup * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SigmaOniaSetup_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SigmaOniaSetup, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2gg2QQbar3S11g(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Sigma2gg2QQbar3S11g *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Sigma2gg2QQbar3S11g",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2gg2QQbar3S11g" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2gg2QQbar3S11g" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2gg2QQbar3S11g" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::Sigma2gg2QQbar3S11g *)new Pythia8::Sigma2gg2QQbar3S11g(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11g, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3S11g_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11g *arg1 = (Pythia8::Sigma2gg2QQbar3S11g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3S11g_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3S11g_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11g *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11g * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3S11g_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11g *arg1 = (Pythia8::Sigma2gg2QQbar3S11g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3S11g_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3S11g_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11g *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11g * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3S11g_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11g *arg1 = (Pythia8::Sigma2gg2QQbar3S11g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3S11g_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3S11g_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11g *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11g * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3S11g_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11g *arg1 = (Pythia8::Sigma2gg2QQbar3S11g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3S11g_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3S11g_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11g *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11g * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3S11g_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11g *arg1 = (Pythia8::Sigma2gg2QQbar3S11g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3S11g_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3S11g_name" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11g const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11g * >(argp1);
  result = ((Pythia8::Sigma2gg2QQbar3S11g const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3S11g_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11g *arg1 = (Pythia8::Sigma2gg2QQbar3S11g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3S11g_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3S11g_code" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11g const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11g * >(argp1);
  result = (int)((Pythia8::Sigma2gg2QQbar3S11g const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3S11g_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11g *arg1 = (Pythia8::Sigma2gg2QQbar3S11g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3S11g_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3S11g_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11g const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11g * >(argp1);
  result = ((Pythia8::Sigma2gg2QQbar3S11g const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3S11g_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11g *arg1 = (Pythia8::Sigma2gg2QQbar3S11g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3S11g_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3S11g_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11g const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11g * >(argp1);
  result = (int)((Pythia8::Sigma2gg2QQbar3S11g const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2gg2QQbar3S11g(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11g *arg1 = (Pythia8::Sigma2gg2QQbar3S11g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2gg2QQbar3S11g",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11g, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2gg2QQbar3S11g" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11g *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11g * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2gg2QQbar3S11g_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11g, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2gg2QQbar3S11gm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Sigma2gg2QQbar3S11gm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Sigma2gg2QQbar3S11gm",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2gg2QQbar3S11gm" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2gg2QQbar3S11gm" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2gg2QQbar3S11gm" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::Sigma2gg2QQbar3S11gm *)new Pythia8::Sigma2gg2QQbar3S11gm(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11gm, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3S11gm_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11gm *arg1 = (Pythia8::Sigma2gg2QQbar3S11gm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3S11gm_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11gm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3S11gm_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11gm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11gm * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3S11gm_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11gm *arg1 = (Pythia8::Sigma2gg2QQbar3S11gm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3S11gm_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11gm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3S11gm_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11gm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11gm * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3S11gm_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11gm *arg1 = (Pythia8::Sigma2gg2QQbar3S11gm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3S11gm_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11gm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3S11gm_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11gm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11gm * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3S11gm_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11gm *arg1 = (Pythia8::Sigma2gg2QQbar3S11gm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3S11gm_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11gm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3S11gm_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11gm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11gm * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3S11gm_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11gm *arg1 = (Pythia8::Sigma2gg2QQbar3S11gm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3S11gm_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11gm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3S11gm_name" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11gm const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11gm * >(argp1);
  result = ((Pythia8::Sigma2gg2QQbar3S11gm const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3S11gm_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11gm *arg1 = (Pythia8::Sigma2gg2QQbar3S11gm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3S11gm_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11gm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3S11gm_code" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11gm const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11gm * >(argp1);
  result = (int)((Pythia8::Sigma2gg2QQbar3S11gm const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3S11gm_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11gm *arg1 = (Pythia8::Sigma2gg2QQbar3S11gm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3S11gm_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11gm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3S11gm_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11gm const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11gm * >(argp1);
  result = ((Pythia8::Sigma2gg2QQbar3S11gm const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3S11gm_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11gm *arg1 = (Pythia8::Sigma2gg2QQbar3S11gm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3S11gm_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11gm, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3S11gm_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11gm const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11gm * >(argp1);
  result = (int)((Pythia8::Sigma2gg2QQbar3S11gm const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2gg2QQbar3S11gm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11gm *arg1 = (Pythia8::Sigma2gg2QQbar3S11gm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2gg2QQbar3S11gm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11gm, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2gg2QQbar3S11gm" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11gm *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11gm * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2gg2QQbar3S11gm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11gm, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2gg2QQbar3PJ1g(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::Sigma2gg2QQbar3PJ1g *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Sigma2gg2QQbar3PJ1g",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2gg2QQbar3PJ1g" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2gg2QQbar3PJ1g" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2gg2QQbar3PJ1g" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Sigma2gg2QQbar3PJ1g" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (Pythia8::Sigma2gg2QQbar3PJ1g *)new Pythia8::Sigma2gg2QQbar3PJ1g(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3PJ1g, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3PJ1g_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3PJ1g *arg1 = (Pythia8::Sigma2gg2QQbar3PJ1g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3PJ1g_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3PJ1g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3PJ1g_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3PJ1g *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3PJ1g * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3PJ1g_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3PJ1g *arg1 = (Pythia8::Sigma2gg2QQbar3PJ1g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3PJ1g_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3PJ1g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3PJ1g_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3PJ1g *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3PJ1g * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3PJ1g_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3PJ1g *arg1 = (Pythia8::Sigma2gg2QQbar3PJ1g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3PJ1g_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3PJ1g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3PJ1g_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3PJ1g *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3PJ1g * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3PJ1g_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3PJ1g *arg1 = (Pythia8::Sigma2gg2QQbar3PJ1g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3PJ1g_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3PJ1g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3PJ1g_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3PJ1g *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3PJ1g * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3PJ1g_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3PJ1g *arg1 = (Pythia8::Sigma2gg2QQbar3PJ1g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3PJ1g_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3PJ1g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3PJ1g_name" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3PJ1g const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3PJ1g * >(argp1);
  result = ((Pythia8::Sigma2gg2QQbar3PJ1g const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3PJ1g_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3PJ1g *arg1 = (Pythia8::Sigma2gg2QQbar3PJ1g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3PJ1g_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3PJ1g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3PJ1g_code" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3PJ1g const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3PJ1g * >(argp1);
  result = (int)((Pythia8::Sigma2gg2QQbar3PJ1g const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3PJ1g_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3PJ1g *arg1 = (Pythia8::Sigma2gg2QQbar3PJ1g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3PJ1g_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3PJ1g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3PJ1g_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3PJ1g const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3PJ1g * >(argp1);
  result = ((Pythia8::Sigma2gg2QQbar3PJ1g const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3PJ1g_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3PJ1g *arg1 = (Pythia8::Sigma2gg2QQbar3PJ1g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3PJ1g_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3PJ1g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3PJ1g_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3PJ1g const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3PJ1g * >(argp1);
  result = (int)((Pythia8::Sigma2gg2QQbar3PJ1g const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2gg2QQbar3PJ1g(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3PJ1g *arg1 = (Pythia8::Sigma2gg2QQbar3PJ1g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2gg2QQbar3PJ1g",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3PJ1g, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2gg2QQbar3PJ1g" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3PJ1g *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3PJ1g * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2gg2QQbar3PJ1g_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3PJ1g, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qg2QQbar3PJ1q(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::Sigma2qg2QQbar3PJ1q *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Sigma2qg2QQbar3PJ1q",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qg2QQbar3PJ1q" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2qg2QQbar3PJ1q" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2qg2QQbar3PJ1q" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Sigma2qg2QQbar3PJ1q" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (Pythia8::Sigma2qg2QQbar3PJ1q *)new Pythia8::Sigma2qg2QQbar3PJ1q(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qg2QQbar3PJ1q, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2QQbar3PJ1q_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2QQbar3PJ1q *arg1 = (Pythia8::Sigma2qg2QQbar3PJ1q *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2QQbar3PJ1q_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2QQbar3PJ1q, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2QQbar3PJ1q_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qg2QQbar3PJ1q *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2QQbar3PJ1q * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2QQbar3PJ1q_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2QQbar3PJ1q *arg1 = (Pythia8::Sigma2qg2QQbar3PJ1q *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2QQbar3PJ1q_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2QQbar3PJ1q, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2QQbar3PJ1q_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qg2QQbar3PJ1q *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2QQbar3PJ1q * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2QQbar3PJ1q_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2QQbar3PJ1q *arg1 = (Pythia8::Sigma2qg2QQbar3PJ1q *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2QQbar3PJ1q_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2QQbar3PJ1q, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2QQbar3PJ1q_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qg2QQbar3PJ1q const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2QQbar3PJ1q * >(argp1);
  result = ((Pythia8::Sigma2qg2QQbar3PJ1q const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qg2QQbar3PJ1q(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2QQbar3PJ1q *arg1 = (Pythia8::Sigma2qg2QQbar3PJ1q *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qg2QQbar3PJ1q",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2QQbar3PJ1q, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qg2QQbar3PJ1q" "', argument " "1"" of type '" "Pythia8::Sigma2qg2QQbar3PJ1q *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2QQbar3PJ1q * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qg2QQbar3PJ1q_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qg2QQbar3PJ1q, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2QQbar3PJ1g(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::Sigma2qqbar2QQbar3PJ1g *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Sigma2qqbar2QQbar3PJ1g",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qqbar2QQbar3PJ1g" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2qqbar2QQbar3PJ1g" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2qqbar2QQbar3PJ1g" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Sigma2qqbar2QQbar3PJ1g" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (Pythia8::Sigma2qqbar2QQbar3PJ1g *)new Pythia8::Sigma2qqbar2QQbar3PJ1g(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar3PJ1g, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2QQbar3PJ1g_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbar3PJ1g *arg1 = (Pythia8::Sigma2qqbar2QQbar3PJ1g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2QQbar3PJ1g_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar3PJ1g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2QQbar3PJ1g_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbar3PJ1g *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbar3PJ1g * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2QQbar3PJ1g_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbar3PJ1g *arg1 = (Pythia8::Sigma2qqbar2QQbar3PJ1g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2QQbar3PJ1g_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar3PJ1g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2QQbar3PJ1g_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbar3PJ1g *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbar3PJ1g * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2QQbar3PJ1g_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbar3PJ1g *arg1 = (Pythia8::Sigma2qqbar2QQbar3PJ1g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2QQbar3PJ1g_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar3PJ1g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2QQbar3PJ1g_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbar3PJ1g const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbar3PJ1g * >(argp1);
  result = ((Pythia8::Sigma2qqbar2QQbar3PJ1g const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2QQbar3PJ1g(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbar3PJ1g *arg1 = (Pythia8::Sigma2qqbar2QQbar3PJ1g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2QQbar3PJ1g",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar3PJ1g, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2QQbar3PJ1g" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbar3PJ1g *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbar3PJ1g * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2QQbar3PJ1g_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar3PJ1g, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2gg2QQbar3DJ1g(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::Sigma2gg2QQbar3DJ1g *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Sigma2gg2QQbar3DJ1g",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2gg2QQbar3DJ1g" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2gg2QQbar3DJ1g" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2gg2QQbar3DJ1g" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Sigma2gg2QQbar3DJ1g" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (Pythia8::Sigma2gg2QQbar3DJ1g *)new Pythia8::Sigma2gg2QQbar3DJ1g(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3DJ1g, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3DJ1g_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3DJ1g *arg1 = (Pythia8::Sigma2gg2QQbar3DJ1g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3DJ1g_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3DJ1g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3DJ1g_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3DJ1g *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3DJ1g * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3DJ1g_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3DJ1g *arg1 = (Pythia8::Sigma2gg2QQbar3DJ1g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3DJ1g_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3DJ1g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3DJ1g_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3DJ1g *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3DJ1g * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2gg2QQbar3DJ1g(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3DJ1g *arg1 = (Pythia8::Sigma2gg2QQbar3DJ1g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2gg2QQbar3DJ1g",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3DJ1g, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2gg2QQbar3DJ1g" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3DJ1g *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3DJ1g * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2gg2QQbar3DJ1g_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3DJ1g, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2gg2QQbarX8g(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int arg3 ;
  double arg4 ;
  int arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::Sigma2gg2QQbarX8g *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Sigma2gg2QQbarX8g",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2gg2QQbarX8g" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2gg2QQbarX8g" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2gg2QQbarX8g" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Sigma2gg2QQbarX8g" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Sigma2gg2QQbarX8g" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (Pythia8::Sigma2gg2QQbarX8g *)new Pythia8::Sigma2gg2QQbarX8g(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gg2QQbarX8g, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbarX8g_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbarX8g *arg1 = (Pythia8::Sigma2gg2QQbarX8g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbarX8g_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbarX8g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbarX8g_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbarX8g *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbarX8g * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbarX8g_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbarX8g *arg1 = (Pythia8::Sigma2gg2QQbarX8g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbarX8g_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbarX8g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbarX8g_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbarX8g *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbarX8g * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbarX8g_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbarX8g *arg1 = (Pythia8::Sigma2gg2QQbarX8g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbarX8g_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbarX8g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbarX8g_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbarX8g *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbarX8g * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbarX8g_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbarX8g *arg1 = (Pythia8::Sigma2gg2QQbarX8g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbarX8g_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbarX8g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbarX8g_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbarX8g *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbarX8g * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbarX8g_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbarX8g *arg1 = (Pythia8::Sigma2gg2QQbarX8g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbarX8g_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbarX8g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbarX8g_name" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbarX8g const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbarX8g * >(argp1);
  result = ((Pythia8::Sigma2gg2QQbarX8g const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbarX8g_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbarX8g *arg1 = (Pythia8::Sigma2gg2QQbarX8g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbarX8g_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbarX8g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbarX8g_code" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbarX8g const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbarX8g * >(argp1);
  result = (int)((Pythia8::Sigma2gg2QQbarX8g const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbarX8g_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbarX8g *arg1 = (Pythia8::Sigma2gg2QQbarX8g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbarX8g_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbarX8g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbarX8g_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbarX8g const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbarX8g * >(argp1);
  result = ((Pythia8::Sigma2gg2QQbarX8g const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbarX8g_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbarX8g *arg1 = (Pythia8::Sigma2gg2QQbarX8g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbarX8g_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbarX8g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbarX8g_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbarX8g const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbarX8g * >(argp1);
  result = (int)((Pythia8::Sigma2gg2QQbarX8g const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2gg2QQbarX8g(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbarX8g *arg1 = (Pythia8::Sigma2gg2QQbarX8g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2gg2QQbarX8g",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbarX8g, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2gg2QQbarX8g" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbarX8g *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbarX8g * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2gg2QQbarX8g_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2gg2QQbarX8g, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qg2QQbarX8q(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int arg3 ;
  double arg4 ;
  int arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::Sigma2qg2QQbarX8q *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Sigma2qg2QQbarX8q",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qg2QQbarX8q" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2qg2QQbarX8q" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2qg2QQbarX8q" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Sigma2qg2QQbarX8q" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Sigma2qg2QQbarX8q" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (Pythia8::Sigma2qg2QQbarX8q *)new Pythia8::Sigma2qg2QQbarX8q(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qg2QQbarX8q, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2QQbarX8q_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2QQbarX8q *arg1 = (Pythia8::Sigma2qg2QQbarX8q *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2QQbarX8q_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2QQbarX8q, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2QQbarX8q_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qg2QQbarX8q *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2QQbarX8q * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2QQbarX8q_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2QQbarX8q *arg1 = (Pythia8::Sigma2qg2QQbarX8q *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2QQbarX8q_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2QQbarX8q, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2QQbarX8q_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qg2QQbarX8q *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2QQbarX8q * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2QQbarX8q_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2QQbarX8q *arg1 = (Pythia8::Sigma2qg2QQbarX8q *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2QQbarX8q_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2QQbarX8q, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2QQbarX8q_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qg2QQbarX8q const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2QQbarX8q * >(argp1);
  result = ((Pythia8::Sigma2qg2QQbarX8q const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qg2QQbarX8q(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2QQbarX8q *arg1 = (Pythia8::Sigma2qg2QQbarX8q *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qg2QQbarX8q",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2QQbarX8q, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qg2QQbarX8q" "', argument " "1"" of type '" "Pythia8::Sigma2qg2QQbarX8q *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2QQbarX8q * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qg2QQbarX8q_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qg2QQbarX8q, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2QQbarX8g(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int arg3 ;
  double arg4 ;
  int arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::Sigma2qqbar2QQbarX8g *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Sigma2qqbar2QQbarX8g",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qqbar2QQbarX8g" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2qqbar2QQbarX8g" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2qqbar2QQbarX8g" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Sigma2qqbar2QQbarX8g" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Sigma2qqbar2QQbarX8g" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (Pythia8::Sigma2qqbar2QQbarX8g *)new Pythia8::Sigma2qqbar2QQbarX8g(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbarX8g, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2QQbarX8g_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbarX8g *arg1 = (Pythia8::Sigma2qqbar2QQbarX8g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2QQbarX8g_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbarX8g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2QQbarX8g_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbarX8g *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbarX8g * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2QQbarX8g_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbarX8g *arg1 = (Pythia8::Sigma2qqbar2QQbarX8g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2QQbarX8g_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbarX8g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2QQbarX8g_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbarX8g *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbarX8g * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2QQbarX8g_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbarX8g *arg1 = (Pythia8::Sigma2qqbar2QQbarX8g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2QQbarX8g_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbarX8g, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2QQbarX8g_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbarX8g const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbarX8g * >(argp1);
  result = ((Pythia8::Sigma2qqbar2QQbarX8g const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2QQbarX8g(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbarX8g *arg1 = (Pythia8::Sigma2qqbar2QQbarX8g *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2QQbarX8g",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbarX8g, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2QQbarX8g" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbarX8g *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbarX8g * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2QQbarX8g_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbarX8g, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2gg2QQbar3S11QQbar3S11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Sigma2gg2QQbar3S11QQbar3S11",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2gg2QQbar3S11QQbar3S11" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2gg2QQbar3S11QQbar3S11" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2gg2QQbar3S11QQbar3S11" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Sigma2gg2QQbar3S11QQbar3S11" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Sigma2gg2QQbar3S11QQbar3S11" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *)new Pythia8::Sigma2gg2QQbar3S11QQbar3S11(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3S11QQbar3S11_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *arg1 = (Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3S11QQbar3S11_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3S11QQbar3S11_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11QQbar3S11 * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3S11QQbar3S11_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *arg1 = (Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3S11QQbar3S11_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3S11QQbar3S11_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11QQbar3S11 * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3S11QQbar3S11_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *arg1 = (Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3S11QQbar3S11_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3S11QQbar3S11_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11QQbar3S11 * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3S11QQbar3S11_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *arg1 = (Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3S11QQbar3S11_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3S11QQbar3S11_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11QQbar3S11 * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3S11QQbar3S11_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *arg1 = (Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3S11QQbar3S11_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3S11QQbar3S11_name" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11QQbar3S11 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11QQbar3S11 * >(argp1);
  result = ((Pythia8::Sigma2gg2QQbar3S11QQbar3S11 const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3S11QQbar3S11_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *arg1 = (Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3S11QQbar3S11_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3S11QQbar3S11_code" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11QQbar3S11 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11QQbar3S11 * >(argp1);
  result = (int)((Pythia8::Sigma2gg2QQbar3S11QQbar3S11 const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3S11QQbar3S11_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *arg1 = (Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3S11QQbar3S11_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3S11QQbar3S11_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11QQbar3S11 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11QQbar3S11 * >(argp1);
  result = ((Pythia8::Sigma2gg2QQbar3S11QQbar3S11 const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3S11QQbar3S11_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *arg1 = (Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3S11QQbar3S11_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3S11QQbar3S11_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11QQbar3S11 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11QQbar3S11 * >(argp1);
  result = (int)((Pythia8::Sigma2gg2QQbar3S11QQbar3S11 const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2QQbar3S11QQbar3S11_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *arg1 = (Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2QQbar3S11QQbar3S11_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2QQbar3S11QQbar3S11_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11QQbar3S11 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11QQbar3S11 * >(argp1);
  result = (int)((Pythia8::Sigma2gg2QQbar3S11QQbar3S11 const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2gg2QQbar3S11QQbar3S11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *arg1 = (Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2gg2QQbar3S11QQbar3S11",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2gg2QQbar3S11QQbar3S11" "', argument " "1"" of type '" "Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2QQbar3S11QQbar3S11 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2gg2QQbar3S11QQbar3S11_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2QQbar3S11QQbar3S11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Sigma2qqbar2QQbar3S11QQbar3S11",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qqbar2QQbar3S11QQbar3S11" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2qqbar2QQbar3S11QQbar3S11" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2qqbar2QQbar3S11QQbar3S11" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Sigma2qqbar2QQbar3S11QQbar3S11" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Sigma2qqbar2QQbar3S11QQbar3S11" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *)new Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2QQbar3S11QQbar3S11_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *arg1 = (Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2QQbar3S11QQbar3S11_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2QQbar3S11QQbar3S11_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2QQbar3S11QQbar3S11_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *arg1 = (Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2QQbar3S11QQbar3S11_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2QQbar3S11QQbar3S11_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2QQbar3S11QQbar3S11_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *arg1 = (Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2QQbar3S11QQbar3S11_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2QQbar3S11QQbar3S11_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2QQbar3S11QQbar3S11_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *arg1 = (Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2QQbar3S11QQbar3S11_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2QQbar3S11QQbar3S11_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2QQbar3S11QQbar3S11_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *arg1 = (Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2QQbar3S11QQbar3S11_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2QQbar3S11QQbar3S11_name" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 * >(argp1);
  result = ((Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2QQbar3S11QQbar3S11_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *arg1 = (Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2QQbar3S11QQbar3S11_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2QQbar3S11QQbar3S11_code" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2QQbar3S11QQbar3S11_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *arg1 = (Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2QQbar3S11QQbar3S11_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2QQbar3S11QQbar3S11_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 * >(argp1);
  result = ((Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2QQbar3S11QQbar3S11_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *arg1 = (Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2QQbar3S11QQbar3S11_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2QQbar3S11QQbar3S11_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2QQbar3S11QQbar3S11_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *arg1 = (Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2QQbar3S11QQbar3S11_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2QQbar3S11QQbar3S11_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2QQbar3S11QQbar3S11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *arg1 = (Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2QQbar3S11QQbar3S11",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2QQbar3S11QQbar3S11" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2QQbar3S11QQbar3S11_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2SUSY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2SUSY *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2SUSY")) SWIG_fail;
  result = (Pythia8::Sigma2SUSY *)new Pythia8::Sigma2SUSY();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2SUSY, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2SUSY_weightDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2SUSY *arg1 = (Pythia8::Sigma2SUSY *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Sigma2SUSY_weightDecay",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2SUSY, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2SUSY_weightDecay" "', argument " "1"" of type '" "Pythia8::Sigma2SUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2SUSY * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sigma2SUSY_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sigma2SUSY_weightDecay" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sigma2SUSY_weightDecay" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sigma2SUSY_weightDecay" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->weightDecay(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2SUSY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2SUSY *arg1 = (Pythia8::Sigma2SUSY *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2SUSY",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2SUSY, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2SUSY" "', argument " "1"" of type '" "Pythia8::Sigma2SUSY *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2SUSY * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2SUSY_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2SUSY, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2chi0chi0__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0chi0 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qqbar2chi0chi0")) SWIG_fail;
  result = (Pythia8::Sigma2qqbar2chi0chi0 *)new Pythia8::Sigma2qqbar2chi0chi0();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0chi0, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2chi0chi0__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Sigma2qqbar2chi0chi0 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Sigma2qqbar2chi0chi0",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qqbar2chi0chi0" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2qqbar2chi0chi0" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2qqbar2chi0chi0" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::Sigma2qqbar2chi0chi0 *)new Pythia8::Sigma2qqbar2chi0chi0(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0chi0, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2chi0chi0(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Sigma2qqbar2chi0chi0__SWIG_0(self, args);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Sigma2qqbar2chi0chi0__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Sigma2qqbar2chi0chi0'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Sigma2qqbar2chi0chi0::Sigma2qqbar2chi0chi0()\n"
    "    Pythia8::Sigma2qqbar2chi0chi0::Sigma2qqbar2chi0chi0(int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chi0chi0_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0chi0 *arg1 = (Pythia8::Sigma2qqbar2chi0chi0 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chi0chi0_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0chi0, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chi0chi0_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0chi0 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0chi0 * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chi0chi0_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0chi0 *arg1 = (Pythia8::Sigma2qqbar2chi0chi0 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chi0chi0_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0chi0, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chi0chi0_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0chi0 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0chi0 * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chi0chi0_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0chi0 *arg1 = (Pythia8::Sigma2qqbar2chi0chi0 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chi0chi0_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0chi0, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chi0chi0_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0chi0 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0chi0 * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chi0chi0_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0chi0 *arg1 = (Pythia8::Sigma2qqbar2chi0chi0 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chi0chi0_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0chi0, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chi0chi0_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0chi0 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0chi0 * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chi0chi0_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0chi0 *arg1 = (Pythia8::Sigma2qqbar2chi0chi0 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chi0chi0_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0chi0, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chi0chi0_name" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0chi0 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0chi0 * >(argp1);
  result = ((Pythia8::Sigma2qqbar2chi0chi0 const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chi0chi0_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0chi0 *arg1 = (Pythia8::Sigma2qqbar2chi0chi0 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chi0chi0_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0chi0, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chi0chi0_code" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0chi0 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0chi0 * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2chi0chi0 const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chi0chi0_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0chi0 *arg1 = (Pythia8::Sigma2qqbar2chi0chi0 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chi0chi0_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0chi0, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chi0chi0_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0chi0 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0chi0 * >(argp1);
  result = ((Pythia8::Sigma2qqbar2chi0chi0 const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chi0chi0_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0chi0 *arg1 = (Pythia8::Sigma2qqbar2chi0chi0 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chi0chi0_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0chi0, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chi0chi0_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0chi0 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0chi0 * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2chi0chi0 const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chi0chi0_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0chi0 *arg1 = (Pythia8::Sigma2qqbar2chi0chi0 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chi0chi0_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0chi0, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chi0chi0_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0chi0 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0chi0 * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2chi0chi0 const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chi0chi0_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0chi0 *arg1 = (Pythia8::Sigma2qqbar2chi0chi0 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chi0chi0_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0chi0, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chi0chi0_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0chi0 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0chi0 * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2chi0chi0 const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chi0chi0_isSUSY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0chi0 *arg1 = (Pythia8::Sigma2qqbar2chi0chi0 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chi0chi0_isSUSY",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0chi0, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chi0chi0_isSUSY" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0chi0 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0chi0 * >(argp1);
  result = (bool)((Pythia8::Sigma2qqbar2chi0chi0 const *)arg1)->isSUSY();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chi0chi0_getSigma0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0chi0 *arg1 = (Pythia8::Sigma2qqbar2chi0chi0 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chi0chi0_getSigma0",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0chi0, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chi0chi0_getSigma0" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0chi0 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0chi0 * >(argp1);
  result = (double)((Pythia8::Sigma2qqbar2chi0chi0 const *)arg1)->getSigma0();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2chi0chi0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0chi0 *arg1 = (Pythia8::Sigma2qqbar2chi0chi0 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2chi0chi0",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0chi0, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2chi0chi0" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0chi0 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0chi0 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2chi0chi0_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0chi0, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2charchi0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Sigma2qqbar2charchi0 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Sigma2qqbar2charchi0",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qqbar2charchi0" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2qqbar2charchi0" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2qqbar2charchi0" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::Sigma2qqbar2charchi0 *)new Pythia8::Sigma2qqbar2charchi0(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2charchi0, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2charchi0_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2charchi0 *arg1 = (Pythia8::Sigma2qqbar2charchi0 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2charchi0_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2charchi0, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2charchi0_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2charchi0 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2charchi0 * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2charchi0_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2charchi0 *arg1 = (Pythia8::Sigma2qqbar2charchi0 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2charchi0_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2charchi0, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2charchi0_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2charchi0 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2charchi0 * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2charchi0_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2charchi0 *arg1 = (Pythia8::Sigma2qqbar2charchi0 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2charchi0_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2charchi0, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2charchi0_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2charchi0 const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2charchi0 * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2charchi0 const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2charchi0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2charchi0 *arg1 = (Pythia8::Sigma2qqbar2charchi0 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2charchi0",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2charchi0, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2charchi0" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2charchi0 *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2charchi0 * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2charchi0_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2charchi0, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2charchar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Sigma2qqbar2charchar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Sigma2qqbar2charchar",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qqbar2charchar" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2qqbar2charchar" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2qqbar2charchar" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::Sigma2qqbar2charchar *)new Pythia8::Sigma2qqbar2charchar(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2charchar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2charchar_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2charchar *arg1 = (Pythia8::Sigma2qqbar2charchar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2charchar_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2charchar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2charchar_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2charchar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2charchar * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2charchar_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2charchar *arg1 = (Pythia8::Sigma2qqbar2charchar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2charchar_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2charchar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2charchar_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2charchar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2charchar * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2charchar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2charchar *arg1 = (Pythia8::Sigma2qqbar2charchar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2charchar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2charchar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2charchar" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2charchar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2charchar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2charchar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2charchar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qg2chi0squark__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2chi0squark *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qg2chi0squark")) SWIG_fail;
  result = (Pythia8::Sigma2qg2chi0squark *)new Pythia8::Sigma2qg2chi0squark();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qg2chi0squark, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2qg2chi0squark__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  bool arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::Sigma2qg2chi0squark *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Sigma2qg2chi0squark",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qg2chi0squark" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2qg2chi0squark" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2qg2chi0squark" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Sigma2qg2chi0squark" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (Pythia8::Sigma2qg2chi0squark *)new Pythia8::Sigma2qg2chi0squark(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qg2chi0squark, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2qg2chi0squark(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Sigma2qg2chi0squark__SWIG_0(self, args);
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Sigma2qg2chi0squark__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Sigma2qg2chi0squark'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Sigma2qg2chi0squark::Sigma2qg2chi0squark()\n"
    "    Pythia8::Sigma2qg2chi0squark::Sigma2qg2chi0squark(int,int,bool,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2chi0squark_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2chi0squark *arg1 = (Pythia8::Sigma2qg2chi0squark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2chi0squark_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2chi0squark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2chi0squark_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qg2chi0squark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2chi0squark * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2chi0squark_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2chi0squark *arg1 = (Pythia8::Sigma2qg2chi0squark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2chi0squark_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2chi0squark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2chi0squark_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qg2chi0squark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2chi0squark * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2chi0squark_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2chi0squark *arg1 = (Pythia8::Sigma2qg2chi0squark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2chi0squark_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2chi0squark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2chi0squark_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qg2chi0squark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2chi0squark * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2chi0squark_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2chi0squark *arg1 = (Pythia8::Sigma2qg2chi0squark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2chi0squark_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2chi0squark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2chi0squark_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qg2chi0squark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2chi0squark * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2chi0squark_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2chi0squark *arg1 = (Pythia8::Sigma2qg2chi0squark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2chi0squark_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2chi0squark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2chi0squark_name" "', argument " "1"" of type '" "Pythia8::Sigma2qg2chi0squark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2chi0squark * >(argp1);
  result = ((Pythia8::Sigma2qg2chi0squark const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2chi0squark_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2chi0squark *arg1 = (Pythia8::Sigma2qg2chi0squark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2chi0squark_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2chi0squark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2chi0squark_code" "', argument " "1"" of type '" "Pythia8::Sigma2qg2chi0squark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2chi0squark * >(argp1);
  result = (int)((Pythia8::Sigma2qg2chi0squark const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2chi0squark_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2chi0squark *arg1 = (Pythia8::Sigma2qg2chi0squark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2chi0squark_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2chi0squark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2chi0squark_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qg2chi0squark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2chi0squark * >(argp1);
  result = ((Pythia8::Sigma2qg2chi0squark const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2chi0squark_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2chi0squark *arg1 = (Pythia8::Sigma2qg2chi0squark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2chi0squark_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2chi0squark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2chi0squark_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qg2chi0squark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2chi0squark * >(argp1);
  result = (int)((Pythia8::Sigma2qg2chi0squark const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2chi0squark_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2chi0squark *arg1 = (Pythia8::Sigma2qg2chi0squark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2chi0squark_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2chi0squark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2chi0squark_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qg2chi0squark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2chi0squark * >(argp1);
  result = (int)((Pythia8::Sigma2qg2chi0squark const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2chi0squark_isSUSY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2chi0squark *arg1 = (Pythia8::Sigma2qg2chi0squark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2chi0squark_isSUSY",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2chi0squark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2chi0squark_isSUSY" "', argument " "1"" of type '" "Pythia8::Sigma2qg2chi0squark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2chi0squark * >(argp1);
  result = (bool)((Pythia8::Sigma2qg2chi0squark const *)arg1)->isSUSY();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qg2chi0squark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2chi0squark *arg1 = (Pythia8::Sigma2qg2chi0squark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qg2chi0squark",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2chi0squark, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qg2chi0squark" "', argument " "1"" of type '" "Pythia8::Sigma2qg2chi0squark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2chi0squark * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qg2chi0squark_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qg2chi0squark, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qg2charsquark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  bool arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::Sigma2qg2charsquark *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Sigma2qg2charsquark",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qg2charsquark" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2qg2charsquark" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2qg2charsquark" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Sigma2qg2charsquark" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (Pythia8::Sigma2qg2charsquark *)new Pythia8::Sigma2qg2charsquark(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qg2charsquark, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2charsquark_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2charsquark *arg1 = (Pythia8::Sigma2qg2charsquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2charsquark_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2charsquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2charsquark_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qg2charsquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2charsquark * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2charsquark_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2charsquark *arg1 = (Pythia8::Sigma2qg2charsquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2charsquark_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2charsquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2charsquark_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qg2charsquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2charsquark * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2charsquark_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2charsquark *arg1 = (Pythia8::Sigma2qg2charsquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2charsquark_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2charsquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2charsquark_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qg2charsquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2charsquark * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2charsquark_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2charsquark *arg1 = (Pythia8::Sigma2qg2charsquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2charsquark_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2charsquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2charsquark_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qg2charsquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2charsquark * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qg2charsquark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2charsquark *arg1 = (Pythia8::Sigma2qg2charsquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qg2charsquark",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2charsquark, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qg2charsquark" "', argument " "1"" of type '" "Pythia8::Sigma2qg2charsquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2charsquark * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qg2charsquark_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qg2charsquark, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qq2squarksquark__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2squarksquark *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qq2squarksquark")) SWIG_fail;
  result = (Pythia8::Sigma2qq2squarksquark *)new Pythia8::Sigma2qq2squarksquark();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qq2squarksquark, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2qq2squarksquark__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Sigma2qq2squarksquark *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Sigma2qq2squarksquark",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qq2squarksquark" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2qq2squarksquark" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2qq2squarksquark" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::Sigma2qq2squarksquark *)new Pythia8::Sigma2qq2squarksquark(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qq2squarksquark, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2qq2squarksquark(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Sigma2qq2squarksquark__SWIG_0(self, args);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Sigma2qq2squarksquark__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Sigma2qq2squarksquark'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Sigma2qq2squarksquark::Sigma2qq2squarksquark()\n"
    "    Pythia8::Sigma2qq2squarksquark::Sigma2qq2squarksquark(int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2squarksquark_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2squarksquark *arg1 = (Pythia8::Sigma2qq2squarksquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2squarksquark_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2squarksquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2squarksquark_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qq2squarksquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2squarksquark * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2squarksquark_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2squarksquark *arg1 = (Pythia8::Sigma2qq2squarksquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2squarksquark_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2squarksquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2squarksquark_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qq2squarksquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2squarksquark * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2squarksquark_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2squarksquark *arg1 = (Pythia8::Sigma2qq2squarksquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2squarksquark_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2squarksquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2squarksquark_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qq2squarksquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2squarksquark * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2squarksquark_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2squarksquark *arg1 = (Pythia8::Sigma2qq2squarksquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2squarksquark_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2squarksquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2squarksquark_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qq2squarksquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2squarksquark * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2squarksquark_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2squarksquark *arg1 = (Pythia8::Sigma2qq2squarksquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2squarksquark_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2squarksquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2squarksquark_name" "', argument " "1"" of type '" "Pythia8::Sigma2qq2squarksquark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2squarksquark * >(argp1);
  result = ((Pythia8::Sigma2qq2squarksquark const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2squarksquark_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2squarksquark *arg1 = (Pythia8::Sigma2qq2squarksquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2squarksquark_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2squarksquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2squarksquark_code" "', argument " "1"" of type '" "Pythia8::Sigma2qq2squarksquark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2squarksquark * >(argp1);
  result = (int)((Pythia8::Sigma2qq2squarksquark const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2squarksquark_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2squarksquark *arg1 = (Pythia8::Sigma2qq2squarksquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2squarksquark_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2squarksquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2squarksquark_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qq2squarksquark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2squarksquark * >(argp1);
  result = ((Pythia8::Sigma2qq2squarksquark const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2squarksquark_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2squarksquark *arg1 = (Pythia8::Sigma2qq2squarksquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2squarksquark_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2squarksquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2squarksquark_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qq2squarksquark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2squarksquark * >(argp1);
  result = (int)((Pythia8::Sigma2qq2squarksquark const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2squarksquark_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2squarksquark *arg1 = (Pythia8::Sigma2qq2squarksquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2squarksquark_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2squarksquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2squarksquark_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qq2squarksquark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2squarksquark * >(argp1);
  result = (int)((Pythia8::Sigma2qq2squarksquark const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qq2squarksquark_isSUSY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2squarksquark *arg1 = (Pythia8::Sigma2qq2squarksquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qq2squarksquark_isSUSY",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2squarksquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qq2squarksquark_isSUSY" "', argument " "1"" of type '" "Pythia8::Sigma2qq2squarksquark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2squarksquark * >(argp1);
  result = (bool)((Pythia8::Sigma2qq2squarksquark const *)arg1)->isSUSY();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qq2squarksquark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qq2squarksquark *arg1 = (Pythia8::Sigma2qq2squarksquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qq2squarksquark",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qq2squarksquark, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qq2squarksquark" "', argument " "1"" of type '" "Pythia8::Sigma2qq2squarksquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qq2squarksquark * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qq2squarksquark_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qq2squarksquark, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2squarkantisquark__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2squarkantisquark *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qqbar2squarkantisquark")) SWIG_fail;
  result = (Pythia8::Sigma2qqbar2squarkantisquark *)new Pythia8::Sigma2qqbar2squarkantisquark();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2squarkantisquark, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2squarkantisquark__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Sigma2qqbar2squarkantisquark *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Sigma2qqbar2squarkantisquark",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qqbar2squarkantisquark" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2qqbar2squarkantisquark" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2qqbar2squarkantisquark" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::Sigma2qqbar2squarkantisquark *)new Pythia8::Sigma2qqbar2squarkantisquark(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2squarkantisquark, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2squarkantisquark(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Sigma2qqbar2squarkantisquark__SWIG_0(self, args);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Sigma2qqbar2squarkantisquark__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Sigma2qqbar2squarkantisquark'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Sigma2qqbar2squarkantisquark::Sigma2qqbar2squarkantisquark()\n"
    "    Pythia8::Sigma2qqbar2squarkantisquark::Sigma2qqbar2squarkantisquark(int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2squarkantisquark_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2squarkantisquark *arg1 = (Pythia8::Sigma2qqbar2squarkantisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2squarkantisquark_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2squarkantisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2squarkantisquark_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2squarkantisquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2squarkantisquark * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2squarkantisquark_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2squarkantisquark *arg1 = (Pythia8::Sigma2qqbar2squarkantisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2squarkantisquark_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2squarkantisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2squarkantisquark_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2squarkantisquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2squarkantisquark * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2squarkantisquark_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2squarkantisquark *arg1 = (Pythia8::Sigma2qqbar2squarkantisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2squarkantisquark_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2squarkantisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2squarkantisquark_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2squarkantisquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2squarkantisquark * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2squarkantisquark_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2squarkantisquark *arg1 = (Pythia8::Sigma2qqbar2squarkantisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2squarkantisquark_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2squarkantisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2squarkantisquark_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2squarkantisquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2squarkantisquark * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2squarkantisquark_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2squarkantisquark *arg1 = (Pythia8::Sigma2qqbar2squarkantisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2squarkantisquark_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2squarkantisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2squarkantisquark_name" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2squarkantisquark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2squarkantisquark * >(argp1);
  result = ((Pythia8::Sigma2qqbar2squarkantisquark const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2squarkantisquark_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2squarkantisquark *arg1 = (Pythia8::Sigma2qqbar2squarkantisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2squarkantisquark_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2squarkantisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2squarkantisquark_code" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2squarkantisquark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2squarkantisquark * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2squarkantisquark const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2squarkantisquark_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2squarkantisquark *arg1 = (Pythia8::Sigma2qqbar2squarkantisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2squarkantisquark_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2squarkantisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2squarkantisquark_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2squarkantisquark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2squarkantisquark * >(argp1);
  result = ((Pythia8::Sigma2qqbar2squarkantisquark const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2squarkantisquark_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2squarkantisquark *arg1 = (Pythia8::Sigma2qqbar2squarkantisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2squarkantisquark_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2squarkantisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2squarkantisquark_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2squarkantisquark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2squarkantisquark * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2squarkantisquark const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2squarkantisquark_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2squarkantisquark *arg1 = (Pythia8::Sigma2qqbar2squarkantisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2squarkantisquark_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2squarkantisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2squarkantisquark_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2squarkantisquark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2squarkantisquark * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2squarkantisquark const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2squarkantisquark_isSUSY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2squarkantisquark *arg1 = (Pythia8::Sigma2qqbar2squarkantisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2squarkantisquark_isSUSY",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2squarkantisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2squarkantisquark_isSUSY" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2squarkantisquark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2squarkantisquark * >(argp1);
  result = (bool)((Pythia8::Sigma2qqbar2squarkantisquark const *)arg1)->isSUSY();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2squarkantisquark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2squarkantisquark *arg1 = (Pythia8::Sigma2qqbar2squarkantisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2squarkantisquark",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2squarkantisquark, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2squarkantisquark" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2squarkantisquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2squarkantisquark * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2squarkantisquark_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2squarkantisquark, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2gg2squarkantisquark__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2squarkantisquark *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2gg2squarkantisquark")) SWIG_fail;
  result = (Pythia8::Sigma2gg2squarkantisquark *)new Pythia8::Sigma2gg2squarkantisquark();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gg2squarkantisquark, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2gg2squarkantisquark__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Sigma2gg2squarkantisquark *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Sigma2gg2squarkantisquark",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2gg2squarkantisquark" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2gg2squarkantisquark" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::Sigma2gg2squarkantisquark *)new Pythia8::Sigma2gg2squarkantisquark(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gg2squarkantisquark, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2gg2squarkantisquark(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Sigma2gg2squarkantisquark__SWIG_0(self, args);
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Sigma2gg2squarkantisquark__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Sigma2gg2squarkantisquark'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Sigma2gg2squarkantisquark::Sigma2gg2squarkantisquark()\n"
    "    Pythia8::Sigma2gg2squarkantisquark::Sigma2gg2squarkantisquark(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2squarkantisquark_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2squarkantisquark *arg1 = (Pythia8::Sigma2gg2squarkantisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2squarkantisquark_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2squarkantisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2squarkantisquark_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2gg2squarkantisquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2squarkantisquark * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2squarkantisquark_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2squarkantisquark *arg1 = (Pythia8::Sigma2gg2squarkantisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2squarkantisquark_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2squarkantisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2squarkantisquark_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2gg2squarkantisquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2squarkantisquark * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2squarkantisquark_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2squarkantisquark *arg1 = (Pythia8::Sigma2gg2squarkantisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2squarkantisquark_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2squarkantisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2squarkantisquark_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2gg2squarkantisquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2squarkantisquark * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2squarkantisquark_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2squarkantisquark *arg1 = (Pythia8::Sigma2gg2squarkantisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2squarkantisquark_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2squarkantisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2squarkantisquark_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2gg2squarkantisquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2squarkantisquark * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2squarkantisquark_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2squarkantisquark *arg1 = (Pythia8::Sigma2gg2squarkantisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2squarkantisquark_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2squarkantisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2squarkantisquark_name" "', argument " "1"" of type '" "Pythia8::Sigma2gg2squarkantisquark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2squarkantisquark * >(argp1);
  result = ((Pythia8::Sigma2gg2squarkantisquark const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2squarkantisquark_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2squarkantisquark *arg1 = (Pythia8::Sigma2gg2squarkantisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2squarkantisquark_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2squarkantisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2squarkantisquark_code" "', argument " "1"" of type '" "Pythia8::Sigma2gg2squarkantisquark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2squarkantisquark * >(argp1);
  result = (int)((Pythia8::Sigma2gg2squarkantisquark const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2squarkantisquark_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2squarkantisquark *arg1 = (Pythia8::Sigma2gg2squarkantisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2squarkantisquark_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2squarkantisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2squarkantisquark_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2gg2squarkantisquark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2squarkantisquark * >(argp1);
  result = ((Pythia8::Sigma2gg2squarkantisquark const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2squarkantisquark_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2squarkantisquark *arg1 = (Pythia8::Sigma2gg2squarkantisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2squarkantisquark_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2squarkantisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2squarkantisquark_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2gg2squarkantisquark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2squarkantisquark * >(argp1);
  result = (int)((Pythia8::Sigma2gg2squarkantisquark const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2squarkantisquark_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2squarkantisquark *arg1 = (Pythia8::Sigma2gg2squarkantisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2squarkantisquark_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2squarkantisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2squarkantisquark_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2gg2squarkantisquark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2squarkantisquark * >(argp1);
  result = (int)((Pythia8::Sigma2gg2squarkantisquark const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2squarkantisquark_isSUSY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2squarkantisquark *arg1 = (Pythia8::Sigma2gg2squarkantisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2squarkantisquark_isSUSY",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2squarkantisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2squarkantisquark_isSUSY" "', argument " "1"" of type '" "Pythia8::Sigma2gg2squarkantisquark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2squarkantisquark * >(argp1);
  result = (bool)((Pythia8::Sigma2gg2squarkantisquark const *)arg1)->isSUSY();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2gg2squarkantisquark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2squarkantisquark *arg1 = (Pythia8::Sigma2gg2squarkantisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2gg2squarkantisquark",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2squarkantisquark, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2gg2squarkantisquark" "', argument " "1"" of type '" "Pythia8::Sigma2gg2squarkantisquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2squarkantisquark * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2gg2squarkantisquark_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2gg2squarkantisquark, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qg2squarkgluino__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2squarkgluino *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qg2squarkgluino")) SWIG_fail;
  result = (Pythia8::Sigma2qg2squarkgluino *)new Pythia8::Sigma2qg2squarkgluino();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qg2squarkgluino, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2qg2squarkgluino__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Sigma2qg2squarkgluino *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Sigma2qg2squarkgluino",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qg2squarkgluino" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2qg2squarkgluino" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::Sigma2qg2squarkgluino *)new Pythia8::Sigma2qg2squarkgluino(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qg2squarkgluino, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2qg2squarkgluino(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Sigma2qg2squarkgluino__SWIG_0(self, args);
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Sigma2qg2squarkgluino__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Sigma2qg2squarkgluino'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Sigma2qg2squarkgluino::Sigma2qg2squarkgluino()\n"
    "    Pythia8::Sigma2qg2squarkgluino::Sigma2qg2squarkgluino(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2squarkgluino_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2squarkgluino *arg1 = (Pythia8::Sigma2qg2squarkgluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2squarkgluino_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2squarkgluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2squarkgluino_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qg2squarkgluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2squarkgluino * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2squarkgluino_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2squarkgluino *arg1 = (Pythia8::Sigma2qg2squarkgluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2squarkgluino_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2squarkgluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2squarkgluino_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qg2squarkgluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2squarkgluino * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2squarkgluino_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2squarkgluino *arg1 = (Pythia8::Sigma2qg2squarkgluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2squarkgluino_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2squarkgluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2squarkgluino_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qg2squarkgluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2squarkgluino * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2squarkgluino_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2squarkgluino *arg1 = (Pythia8::Sigma2qg2squarkgluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2squarkgluino_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2squarkgluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2squarkgluino_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qg2squarkgluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2squarkgluino * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2squarkgluino_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2squarkgluino *arg1 = (Pythia8::Sigma2qg2squarkgluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2squarkgluino_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2squarkgluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2squarkgluino_name" "', argument " "1"" of type '" "Pythia8::Sigma2qg2squarkgluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2squarkgluino * >(argp1);
  result = ((Pythia8::Sigma2qg2squarkgluino const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2squarkgluino_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2squarkgluino *arg1 = (Pythia8::Sigma2qg2squarkgluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2squarkgluino_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2squarkgluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2squarkgluino_code" "', argument " "1"" of type '" "Pythia8::Sigma2qg2squarkgluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2squarkgluino * >(argp1);
  result = (int)((Pythia8::Sigma2qg2squarkgluino const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2squarkgluino_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2squarkgluino *arg1 = (Pythia8::Sigma2qg2squarkgluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2squarkgluino_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2squarkgluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2squarkgluino_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qg2squarkgluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2squarkgluino * >(argp1);
  result = ((Pythia8::Sigma2qg2squarkgluino const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2squarkgluino_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2squarkgluino *arg1 = (Pythia8::Sigma2qg2squarkgluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2squarkgluino_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2squarkgluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2squarkgluino_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qg2squarkgluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2squarkgluino * >(argp1);
  result = (int)((Pythia8::Sigma2qg2squarkgluino const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2squarkgluino_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2squarkgluino *arg1 = (Pythia8::Sigma2qg2squarkgluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2squarkgluino_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2squarkgluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2squarkgluino_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qg2squarkgluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2squarkgluino * >(argp1);
  result = (int)((Pythia8::Sigma2qg2squarkgluino const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qg2squarkgluino_isSUSY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2squarkgluino *arg1 = (Pythia8::Sigma2qg2squarkgluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qg2squarkgluino_isSUSY",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2squarkgluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qg2squarkgluino_isSUSY" "', argument " "1"" of type '" "Pythia8::Sigma2qg2squarkgluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2squarkgluino * >(argp1);
  result = (bool)((Pythia8::Sigma2qg2squarkgluino const *)arg1)->isSUSY();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qg2squarkgluino(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qg2squarkgluino *arg1 = (Pythia8::Sigma2qg2squarkgluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qg2squarkgluino",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qg2squarkgluino, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qg2squarkgluino" "', argument " "1"" of type '" "Pythia8::Sigma2qg2squarkgluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qg2squarkgluino * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qg2squarkgluino_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qg2squarkgluino, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2gg2gluinogluino(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gluinogluino *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2gg2gluinogluino")) SWIG_fail;
  result = (Pythia8::Sigma2gg2gluinogluino *)new Pythia8::Sigma2gg2gluinogluino();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2gg2gluinogluino, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2gluinogluino_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gluinogluino *arg1 = (Pythia8::Sigma2gg2gluinogluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2gluinogluino_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gluinogluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2gluinogluino_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gluinogluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gluinogluino * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2gluinogluino_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gluinogluino *arg1 = (Pythia8::Sigma2gg2gluinogluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2gluinogluino_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gluinogluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2gluinogluino_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gluinogluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gluinogluino * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2gluinogluino_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gluinogluino *arg1 = (Pythia8::Sigma2gg2gluinogluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2gluinogluino_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gluinogluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2gluinogluino_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gluinogluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gluinogluino * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2gluinogluino_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gluinogluino *arg1 = (Pythia8::Sigma2gg2gluinogluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2gluinogluino_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gluinogluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2gluinogluino_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gluinogluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gluinogluino * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2gluinogluino_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gluinogluino *arg1 = (Pythia8::Sigma2gg2gluinogluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2gluinogluino_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gluinogluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2gluinogluino_name" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gluinogluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gluinogluino * >(argp1);
  result = ((Pythia8::Sigma2gg2gluinogluino const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2gluinogluino_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gluinogluino *arg1 = (Pythia8::Sigma2gg2gluinogluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2gluinogluino_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gluinogluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2gluinogluino_code" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gluinogluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gluinogluino * >(argp1);
  result = (int)((Pythia8::Sigma2gg2gluinogluino const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2gluinogluino_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gluinogluino *arg1 = (Pythia8::Sigma2gg2gluinogluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2gluinogluino_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gluinogluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2gluinogluino_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gluinogluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gluinogluino * >(argp1);
  result = ((Pythia8::Sigma2gg2gluinogluino const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2gluinogluino_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gluinogluino *arg1 = (Pythia8::Sigma2gg2gluinogluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2gluinogluino_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gluinogluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2gluinogluino_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gluinogluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gluinogluino * >(argp1);
  result = (int)((Pythia8::Sigma2gg2gluinogluino const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2gluinogluino_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gluinogluino *arg1 = (Pythia8::Sigma2gg2gluinogluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2gluinogluino_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gluinogluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2gluinogluino_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gluinogluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gluinogluino * >(argp1);
  result = (int)((Pythia8::Sigma2gg2gluinogluino const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2gg2gluinogluino_isSUSY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gluinogluino *arg1 = (Pythia8::Sigma2gg2gluinogluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2gg2gluinogluino_isSUSY",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gluinogluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2gg2gluinogluino_isSUSY" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gluinogluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gluinogluino * >(argp1);
  result = (bool)((Pythia8::Sigma2gg2gluinogluino const *)arg1)->isSUSY();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2gg2gluinogluino(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2gg2gluinogluino *arg1 = (Pythia8::Sigma2gg2gluinogluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2gg2gluinogluino",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2gg2gluinogluino, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2gg2gluinogluino" "', argument " "1"" of type '" "Pythia8::Sigma2gg2gluinogluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2gg2gluinogluino * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2gg2gluinogluino_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2gg2gluinogluino, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2gluinogluino(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gluinogluino *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qqbar2gluinogluino")) SWIG_fail;
  result = (Pythia8::Sigma2qqbar2gluinogluino *)new Pythia8::Sigma2qqbar2gluinogluino();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2gluinogluino, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2gluinogluino_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gluinogluino *arg1 = (Pythia8::Sigma2qqbar2gluinogluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2gluinogluino_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gluinogluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2gluinogluino_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gluinogluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gluinogluino * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2gluinogluino_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gluinogluino *arg1 = (Pythia8::Sigma2qqbar2gluinogluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2gluinogluino_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gluinogluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2gluinogluino_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gluinogluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gluinogluino * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2gluinogluino_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gluinogluino *arg1 = (Pythia8::Sigma2qqbar2gluinogluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2gluinogluino_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gluinogluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2gluinogluino_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gluinogluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gluinogluino * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2gluinogluino_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gluinogluino *arg1 = (Pythia8::Sigma2qqbar2gluinogluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2gluinogluino_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gluinogluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2gluinogluino_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gluinogluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gluinogluino * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2gluinogluino_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gluinogluino *arg1 = (Pythia8::Sigma2qqbar2gluinogluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2gluinogluino_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gluinogluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2gluinogluino_name" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gluinogluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gluinogluino * >(argp1);
  result = ((Pythia8::Sigma2qqbar2gluinogluino const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2gluinogluino_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gluinogluino *arg1 = (Pythia8::Sigma2qqbar2gluinogluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2gluinogluino_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gluinogluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2gluinogluino_code" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gluinogluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gluinogluino * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2gluinogluino const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2gluinogluino_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gluinogluino *arg1 = (Pythia8::Sigma2qqbar2gluinogluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2gluinogluino_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gluinogluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2gluinogluino_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gluinogluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gluinogluino * >(argp1);
  result = ((Pythia8::Sigma2qqbar2gluinogluino const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2gluinogluino_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gluinogluino *arg1 = (Pythia8::Sigma2qqbar2gluinogluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2gluinogluino_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gluinogluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2gluinogluino_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gluinogluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gluinogluino * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2gluinogluino const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2gluinogluino_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gluinogluino *arg1 = (Pythia8::Sigma2qqbar2gluinogluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2gluinogluino_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gluinogluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2gluinogluino_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gluinogluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gluinogluino * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2gluinogluino const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2gluinogluino_isSUSY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gluinogluino *arg1 = (Pythia8::Sigma2qqbar2gluinogluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2gluinogluino_isSUSY",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gluinogluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2gluinogluino_isSUSY" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gluinogluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gluinogluino * >(argp1);
  result = (bool)((Pythia8::Sigma2qqbar2gluinogluino const *)arg1)->isSUSY();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2gluinogluino(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2gluinogluino *arg1 = (Pythia8::Sigma2qqbar2gluinogluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2gluinogluino",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2gluinogluino, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2gluinogluino" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2gluinogluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2gluinogluino * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2gluinogluino_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2gluinogluino, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma1qq2antisquark__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qq2antisquark *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma1qq2antisquark")) SWIG_fail;
  result = (Pythia8::Sigma1qq2antisquark *)new Pythia8::Sigma1qq2antisquark();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma1qq2antisquark, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma1qq2antisquark__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Sigma1qq2antisquark *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Sigma1qq2antisquark",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma1qq2antisquark" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Sigma1qq2antisquark *)new Pythia8::Sigma1qq2antisquark(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma1qq2antisquark, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma1qq2antisquark(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Sigma1qq2antisquark__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Sigma1qq2antisquark__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Sigma1qq2antisquark'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Sigma1qq2antisquark::Sigma1qq2antisquark()\n"
    "    Pythia8::Sigma1qq2antisquark::Sigma1qq2antisquark(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Sigma1qq2antisquark_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qq2antisquark *arg1 = (Pythia8::Sigma1qq2antisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qq2antisquark_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qq2antisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qq2antisquark_initProc" "', argument " "1"" of type '" "Pythia8::Sigma1qq2antisquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qq2antisquark * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qq2antisquark_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qq2antisquark *arg1 = (Pythia8::Sigma1qq2antisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qq2antisquark_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qq2antisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qq2antisquark_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma1qq2antisquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qq2antisquark * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qq2antisquark_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qq2antisquark *arg1 = (Pythia8::Sigma1qq2antisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qq2antisquark_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qq2antisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qq2antisquark_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma1qq2antisquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qq2antisquark * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qq2antisquark_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qq2antisquark *arg1 = (Pythia8::Sigma1qq2antisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qq2antisquark_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qq2antisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qq2antisquark_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma1qq2antisquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qq2antisquark * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qq2antisquark_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qq2antisquark *arg1 = (Pythia8::Sigma1qq2antisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qq2antisquark_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qq2antisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qq2antisquark_name" "', argument " "1"" of type '" "Pythia8::Sigma1qq2antisquark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qq2antisquark * >(argp1);
  result = ((Pythia8::Sigma1qq2antisquark const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qq2antisquark_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qq2antisquark *arg1 = (Pythia8::Sigma1qq2antisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qq2antisquark_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qq2antisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qq2antisquark_code" "', argument " "1"" of type '" "Pythia8::Sigma1qq2antisquark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qq2antisquark * >(argp1);
  result = (int)((Pythia8::Sigma1qq2antisquark const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qq2antisquark_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qq2antisquark *arg1 = (Pythia8::Sigma1qq2antisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qq2antisquark_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qq2antisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qq2antisquark_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma1qq2antisquark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qq2antisquark * >(argp1);
  result = ((Pythia8::Sigma1qq2antisquark const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qq2antisquark_isSUSY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qq2antisquark *arg1 = (Pythia8::Sigma1qq2antisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qq2antisquark_isSUSY",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qq2antisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qq2antisquark_isSUSY" "', argument " "1"" of type '" "Pythia8::Sigma1qq2antisquark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qq2antisquark * >(argp1);
  result = (bool)((Pythia8::Sigma1qq2antisquark const *)arg1)->isSUSY();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qq2antisquark_isRPV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qq2antisquark *arg1 = (Pythia8::Sigma1qq2antisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qq2antisquark_isRPV",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qq2antisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qq2antisquark_isRPV" "', argument " "1"" of type '" "Pythia8::Sigma1qq2antisquark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qq2antisquark * >(argp1);
  result = (bool)((Pythia8::Sigma1qq2antisquark const *)arg1)->isRPV();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma1qq2antisquark_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qq2antisquark *arg1 = (Pythia8::Sigma1qq2antisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma1qq2antisquark_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qq2antisquark, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma1qq2antisquark_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma1qq2antisquark const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qq2antisquark * >(argp1);
  result = (int)((Pythia8::Sigma1qq2antisquark const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma1qq2antisquark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma1qq2antisquark *arg1 = (Pythia8::Sigma1qq2antisquark *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma1qq2antisquark",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma1qq2antisquark, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma1qq2antisquark" "', argument " "1"" of type '" "Pythia8::Sigma1qq2antisquark *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma1qq2antisquark * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma1qq2antisquark_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma1qq2antisquark, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2chi0gluino__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0gluino *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qqbar2chi0gluino")) SWIG_fail;
  result = (Pythia8::Sigma2qqbar2chi0gluino *)new Pythia8::Sigma2qqbar2chi0gluino();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0gluino, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2chi0gluino__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Sigma2qqbar2chi0gluino *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Sigma2qqbar2chi0gluino",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qqbar2chi0gluino" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2qqbar2chi0gluino" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::Sigma2qqbar2chi0gluino *)new Pythia8::Sigma2qqbar2chi0gluino(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0gluino, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2chi0gluino(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Sigma2qqbar2chi0gluino__SWIG_0(self, args);
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Sigma2qqbar2chi0gluino__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Sigma2qqbar2chi0gluino'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Sigma2qqbar2chi0gluino::Sigma2qqbar2chi0gluino()\n"
    "    Pythia8::Sigma2qqbar2chi0gluino::Sigma2qqbar2chi0gluino(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chi0gluino_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0gluino *arg1 = (Pythia8::Sigma2qqbar2chi0gluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chi0gluino_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0gluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chi0gluino_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0gluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0gluino * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chi0gluino_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0gluino *arg1 = (Pythia8::Sigma2qqbar2chi0gluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chi0gluino_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0gluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chi0gluino_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0gluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0gluino * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chi0gluino_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0gluino *arg1 = (Pythia8::Sigma2qqbar2chi0gluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chi0gluino_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0gluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chi0gluino_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0gluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0gluino * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chi0gluino_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0gluino *arg1 = (Pythia8::Sigma2qqbar2chi0gluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chi0gluino_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0gluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chi0gluino_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0gluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0gluino * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chi0gluino_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0gluino *arg1 = (Pythia8::Sigma2qqbar2chi0gluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chi0gluino_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0gluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chi0gluino_name" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0gluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0gluino * >(argp1);
  result = ((Pythia8::Sigma2qqbar2chi0gluino const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chi0gluino_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0gluino *arg1 = (Pythia8::Sigma2qqbar2chi0gluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chi0gluino_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0gluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chi0gluino_code" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0gluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0gluino * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2chi0gluino const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chi0gluino_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0gluino *arg1 = (Pythia8::Sigma2qqbar2chi0gluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chi0gluino_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0gluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chi0gluino_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0gluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0gluino * >(argp1);
  result = ((Pythia8::Sigma2qqbar2chi0gluino const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chi0gluino_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0gluino *arg1 = (Pythia8::Sigma2qqbar2chi0gluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chi0gluino_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0gluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chi0gluino_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0gluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0gluino * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2chi0gluino const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chi0gluino_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0gluino *arg1 = (Pythia8::Sigma2qqbar2chi0gluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chi0gluino_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0gluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chi0gluino_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0gluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0gluino * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2chi0gluino const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chi0gluino_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0gluino *arg1 = (Pythia8::Sigma2qqbar2chi0gluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chi0gluino_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0gluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chi0gluino_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0gluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0gluino * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2chi0gluino const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chi0gluino_isSUSY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0gluino *arg1 = (Pythia8::Sigma2qqbar2chi0gluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chi0gluino_isSUSY",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0gluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chi0gluino_isSUSY" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0gluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0gluino * >(argp1);
  result = (bool)((Pythia8::Sigma2qqbar2chi0gluino const *)arg1)->isSUSY();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chi0gluino_getSigma0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0gluino *arg1 = (Pythia8::Sigma2qqbar2chi0gluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chi0gluino_getSigma0",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0gluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chi0gluino_getSigma0" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0gluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0gluino * >(argp1);
  result = (double)((Pythia8::Sigma2qqbar2chi0gluino const *)arg1)->getSigma0();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2chi0gluino(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chi0gluino *arg1 = (Pythia8::Sigma2qqbar2chi0gluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2chi0gluino",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0gluino, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2chi0gluino" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chi0gluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chi0gluino * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2chi0gluino_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2chi0gluino, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2chargluino(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Sigma2qqbar2chargluino *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Sigma2qqbar2chargluino",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qqbar2chargluino" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2qqbar2chargluino" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::Sigma2qqbar2chargluino *)new Pythia8::Sigma2qqbar2chargluino(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2chargluino, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chargluino_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chargluino *arg1 = (Pythia8::Sigma2qqbar2chargluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chargluino_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chargluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chargluino_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chargluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chargluino * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chargluino_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chargluino *arg1 = (Pythia8::Sigma2qqbar2chargluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chargluino_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chargluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chargluino_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chargluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chargluino * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chargluino_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chargluino *arg1 = (Pythia8::Sigma2qqbar2chargluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chargluino_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chargluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chargluino_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chargluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chargluino * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chargluino_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chargluino *arg1 = (Pythia8::Sigma2qqbar2chargluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chargluino_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chargluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chargluino_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chargluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chargluino * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2chargluino_resonanceA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chargluino *arg1 = (Pythia8::Sigma2qqbar2chargluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2chargluino_resonanceA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chargluino, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2chargluino_resonanceA" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chargluino const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chargluino * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2chargluino const *)arg1)->resonanceA();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2chargluino(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2chargluino *arg1 = (Pythia8::Sigma2qqbar2chargluino *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2chargluino",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2chargluino, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2chargluino" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2chargluino *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2chargluino * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2chargluino_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2chargluino, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2sleptonantislepton__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2sleptonantislepton *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Sigma2qqbar2sleptonantislepton")) SWIG_fail;
  result = (Pythia8::Sigma2qqbar2sleptonantislepton *)new Pythia8::Sigma2qqbar2sleptonantislepton();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2sleptonantislepton, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2sleptonantislepton__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Sigma2qqbar2sleptonantislepton *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Sigma2qqbar2sleptonantislepton",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Sigma2qqbar2sleptonantislepton" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Sigma2qqbar2sleptonantislepton" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Sigma2qqbar2sleptonantislepton" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::Sigma2qqbar2sleptonantislepton *)new Pythia8::Sigma2qqbar2sleptonantislepton(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Sigma2qqbar2sleptonantislepton, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Sigma2qqbar2sleptonantislepton(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Sigma2qqbar2sleptonantislepton__SWIG_0(self, args);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Sigma2qqbar2sleptonantislepton__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Sigma2qqbar2sleptonantislepton'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Sigma2qqbar2sleptonantislepton::Sigma2qqbar2sleptonantislepton()\n"
    "    Pythia8::Sigma2qqbar2sleptonantislepton::Sigma2qqbar2sleptonantislepton(int,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2sleptonantislepton_initProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2sleptonantislepton *arg1 = (Pythia8::Sigma2qqbar2sleptonantislepton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2sleptonantislepton_initProc",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2sleptonantislepton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2sleptonantislepton_initProc" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2sleptonantislepton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2sleptonantislepton * >(argp1);
  (arg1)->initProc();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2sleptonantislepton_sigmaKin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2sleptonantislepton *arg1 = (Pythia8::Sigma2qqbar2sleptonantislepton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2sleptonantislepton_sigmaKin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2sleptonantislepton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2sleptonantislepton_sigmaKin" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2sleptonantislepton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2sleptonantislepton * >(argp1);
  (arg1)->sigmaKin();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2sleptonantislepton_sigmaHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2sleptonantislepton *arg1 = (Pythia8::Sigma2qqbar2sleptonantislepton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2sleptonantislepton_sigmaHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2sleptonantislepton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2sleptonantislepton_sigmaHat" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2sleptonantislepton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2sleptonantislepton * >(argp1);
  result = (double)(arg1)->sigmaHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2sleptonantislepton_setIdColAcol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2sleptonantislepton *arg1 = (Pythia8::Sigma2qqbar2sleptonantislepton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2sleptonantislepton_setIdColAcol",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2sleptonantislepton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2sleptonantislepton_setIdColAcol" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2sleptonantislepton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2sleptonantislepton * >(argp1);
  (arg1)->setIdColAcol();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2sleptonantislepton_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2sleptonantislepton *arg1 = (Pythia8::Sigma2qqbar2sleptonantislepton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2sleptonantislepton_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2sleptonantislepton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2sleptonantislepton_name" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2sleptonantislepton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2sleptonantislepton * >(argp1);
  result = ((Pythia8::Sigma2qqbar2sleptonantislepton const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2sleptonantislepton_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2sleptonantislepton *arg1 = (Pythia8::Sigma2qqbar2sleptonantislepton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2sleptonantislepton_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2sleptonantislepton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2sleptonantislepton_code" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2sleptonantislepton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2sleptonantislepton * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2sleptonantislepton const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2sleptonantislepton_inFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2sleptonantislepton *arg1 = (Pythia8::Sigma2qqbar2sleptonantislepton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2sleptonantislepton_inFlux",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2sleptonantislepton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2sleptonantislepton_inFlux" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2sleptonantislepton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2sleptonantislepton * >(argp1);
  result = ((Pythia8::Sigma2qqbar2sleptonantislepton const *)arg1)->inFlux();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2sleptonantislepton_id3Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2sleptonantislepton *arg1 = (Pythia8::Sigma2qqbar2sleptonantislepton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2sleptonantislepton_id3Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2sleptonantislepton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2sleptonantislepton_id3Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2sleptonantislepton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2sleptonantislepton * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2sleptonantislepton const *)arg1)->id3Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2sleptonantislepton_id4Mass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2sleptonantislepton *arg1 = (Pythia8::Sigma2qqbar2sleptonantislepton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2sleptonantislepton_id4Mass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2sleptonantislepton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2sleptonantislepton_id4Mass" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2sleptonantislepton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2sleptonantislepton * >(argp1);
  result = (int)((Pythia8::Sigma2qqbar2sleptonantislepton const *)arg1)->id4Mass();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Sigma2qqbar2sleptonantislepton_isSUSY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2sleptonantislepton *arg1 = (Pythia8::Sigma2qqbar2sleptonantislepton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Sigma2qqbar2sleptonantislepton_isSUSY",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2sleptonantislepton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sigma2qqbar2sleptonantislepton_isSUSY" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2sleptonantislepton const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2sleptonantislepton * >(argp1);
  result = (bool)((Pythia8::Sigma2qqbar2sleptonantislepton const *)arg1)->isSUSY();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Sigma2qqbar2sleptonantislepton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Sigma2qqbar2sleptonantislepton *arg1 = (Pythia8::Sigma2qqbar2sleptonantislepton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Sigma2qqbar2sleptonantislepton",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Sigma2qqbar2sleptonantislepton, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sigma2qqbar2sleptonantislepton" "', argument " "1"" of type '" "Pythia8::Sigma2qqbar2sleptonantislepton *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Sigma2qqbar2sleptonantislepton * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Sigma2qqbar2sleptonantislepton_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Sigma2qqbar2sleptonantislepton, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SpaceDipoleEnd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  bool arg10 ;
  int arg11 ;
  int arg12 ;
  int arg13 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  Pythia8::SpaceDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:new_SpaceDipoleEnd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpaceDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SpaceDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpaceDipoleEnd" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SpaceDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpaceDipoleEnd" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SpaceDipoleEnd" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SpaceDipoleEnd" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SpaceDipoleEnd" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SpaceDipoleEnd" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SpaceDipoleEnd" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SpaceDipoleEnd" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SpaceDipoleEnd" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_int(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_SpaceDipoleEnd" "', argument " "13"" of type '" "int""'");
  } 
  arg13 = static_cast< int >(val13);
  result = (Pythia8::SpaceDipoleEnd *)new Pythia8::SpaceDipoleEnd(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SpaceDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpaceDipoleEnd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  bool arg10 ;
  int arg11 ;
  int arg12 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  Pythia8::SpaceDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:new_SpaceDipoleEnd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpaceDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SpaceDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpaceDipoleEnd" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SpaceDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpaceDipoleEnd" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SpaceDipoleEnd" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SpaceDipoleEnd" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SpaceDipoleEnd" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SpaceDipoleEnd" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SpaceDipoleEnd" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SpaceDipoleEnd" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_SpaceDipoleEnd" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  result = (Pythia8::SpaceDipoleEnd *)new Pythia8::SpaceDipoleEnd(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SpaceDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpaceDipoleEnd__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  bool arg10 ;
  int arg11 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  Pythia8::SpaceDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:new_SpaceDipoleEnd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpaceDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SpaceDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpaceDipoleEnd" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SpaceDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpaceDipoleEnd" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SpaceDipoleEnd" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SpaceDipoleEnd" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SpaceDipoleEnd" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SpaceDipoleEnd" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SpaceDipoleEnd" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_SpaceDipoleEnd" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  result = (Pythia8::SpaceDipoleEnd *)new Pythia8::SpaceDipoleEnd(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SpaceDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpaceDipoleEnd__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  bool arg10 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  Pythia8::SpaceDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:new_SpaceDipoleEnd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpaceDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SpaceDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpaceDipoleEnd" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SpaceDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpaceDipoleEnd" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SpaceDipoleEnd" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SpaceDipoleEnd" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SpaceDipoleEnd" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SpaceDipoleEnd" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_SpaceDipoleEnd" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  result = (Pythia8::SpaceDipoleEnd *)new Pythia8::SpaceDipoleEnd(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SpaceDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpaceDipoleEnd__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  Pythia8::SpaceDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_SpaceDipoleEnd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpaceDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SpaceDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpaceDipoleEnd" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SpaceDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpaceDipoleEnd" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SpaceDipoleEnd" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SpaceDipoleEnd" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SpaceDipoleEnd" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_SpaceDipoleEnd" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  result = (Pythia8::SpaceDipoleEnd *)new Pythia8::SpaceDipoleEnd(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SpaceDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpaceDipoleEnd__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  Pythia8::SpaceDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:new_SpaceDipoleEnd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpaceDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SpaceDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpaceDipoleEnd" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SpaceDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpaceDipoleEnd" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SpaceDipoleEnd" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SpaceDipoleEnd" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_SpaceDipoleEnd" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  result = (Pythia8::SpaceDipoleEnd *)new Pythia8::SpaceDipoleEnd(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SpaceDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpaceDipoleEnd__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  int arg6 ;
  int arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Pythia8::SpaceDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_SpaceDipoleEnd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpaceDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SpaceDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpaceDipoleEnd" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SpaceDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpaceDipoleEnd" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SpaceDipoleEnd" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_SpaceDipoleEnd" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  result = (Pythia8::SpaceDipoleEnd *)new Pythia8::SpaceDipoleEnd(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SpaceDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpaceDipoleEnd__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  int arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::SpaceDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_SpaceDipoleEnd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpaceDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SpaceDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpaceDipoleEnd" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SpaceDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpaceDipoleEnd" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_SpaceDipoleEnd" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (Pythia8::SpaceDipoleEnd *)new Pythia8::SpaceDipoleEnd(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SpaceDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpaceDipoleEnd__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::SpaceDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_SpaceDipoleEnd",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpaceDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SpaceDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpaceDipoleEnd" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SpaceDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SpaceDipoleEnd" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (Pythia8::SpaceDipoleEnd *)new Pythia8::SpaceDipoleEnd(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SpaceDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpaceDipoleEnd__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::SpaceDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_SpaceDipoleEnd",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpaceDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SpaceDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpaceDipoleEnd" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SpaceDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (Pythia8::SpaceDipoleEnd *)new Pythia8::SpaceDipoleEnd(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SpaceDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpaceDipoleEnd__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::SpaceDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_SpaceDipoleEnd",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpaceDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SpaceDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SpaceDipoleEnd" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::SpaceDipoleEnd *)new Pythia8::SpaceDipoleEnd(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SpaceDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpaceDipoleEnd__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::SpaceDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_SpaceDipoleEnd",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpaceDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SpaceDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::SpaceDipoleEnd *)new Pythia8::SpaceDipoleEnd(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SpaceDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpaceDipoleEnd__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::SpaceDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SpaceDipoleEnd",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpaceDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::SpaceDipoleEnd *)new Pythia8::SpaceDipoleEnd(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SpaceDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpaceDipoleEnd__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SpaceDipoleEnd")) SWIG_fail;
  result = (Pythia8::SpaceDipoleEnd *)new Pythia8::SpaceDipoleEnd();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SpaceDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SpaceDipoleEnd(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[14] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 13) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_SpaceDipoleEnd__SWIG_13(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SpaceDipoleEnd__SWIG_12(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SpaceDipoleEnd__SWIG_11(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_SpaceDipoleEnd__SWIG_10(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_SpaceDipoleEnd__SWIG_9(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_SpaceDipoleEnd__SWIG_8(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_SpaceDipoleEnd__SWIG_7(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_SpaceDipoleEnd__SWIG_6(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_SpaceDipoleEnd__SWIG_5(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_SpaceDipoleEnd__SWIG_4(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_SpaceDipoleEnd__SWIG_3(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_SpaceDipoleEnd__SWIG_2(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_SpaceDipoleEnd__SWIG_1(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_SpaceDipoleEnd__SWIG_0(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SpaceDipoleEnd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SpaceDipoleEnd::SpaceDipoleEnd(int,int,int,int,double,int,int,int,int,bool,int,int,int)\n"
    "    Pythia8::SpaceDipoleEnd::SpaceDipoleEnd(int,int,int,int,double,int,int,int,int,bool,int,int)\n"
    "    Pythia8::SpaceDipoleEnd::SpaceDipoleEnd(int,int,int,int,double,int,int,int,int,bool,int)\n"
    "    Pythia8::SpaceDipoleEnd::SpaceDipoleEnd(int,int,int,int,double,int,int,int,int,bool)\n"
    "    Pythia8::SpaceDipoleEnd::SpaceDipoleEnd(int,int,int,int,double,int,int,int,int)\n"
    "    Pythia8::SpaceDipoleEnd::SpaceDipoleEnd(int,int,int,int,double,int,int,int)\n"
    "    Pythia8::SpaceDipoleEnd::SpaceDipoleEnd(int,int,int,int,double,int,int)\n"
    "    Pythia8::SpaceDipoleEnd::SpaceDipoleEnd(int,int,int,int,double,int)\n"
    "    Pythia8::SpaceDipoleEnd::SpaceDipoleEnd(int,int,int,int,double)\n"
    "    Pythia8::SpaceDipoleEnd::SpaceDipoleEnd(int,int,int,int)\n"
    "    Pythia8::SpaceDipoleEnd::SpaceDipoleEnd(int,int,int)\n"
    "    Pythia8::SpaceDipoleEnd::SpaceDipoleEnd(int,int)\n"
    "    Pythia8::SpaceDipoleEnd::SpaceDipoleEnd(int)\n"
    "    Pythia8::SpaceDipoleEnd::SpaceDipoleEnd()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_store(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  int arg15 ;
  double arg16 ;
  double arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:SpaceDipoleEnd_store",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_store" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_store" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpaceDipoleEnd_store" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpaceDipoleEnd_store" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpaceDipoleEnd_store" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SpaceDipoleEnd_store" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SpaceDipoleEnd_store" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SpaceDipoleEnd_store" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "SpaceDipoleEnd_store" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "SpaceDipoleEnd_store" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  ecode11 = SWIG_AsVal_double(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "SpaceDipoleEnd_store" "', argument " "11"" of type '" "double""'");
  } 
  arg11 = static_cast< double >(val11);
  ecode12 = SWIG_AsVal_double(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "SpaceDipoleEnd_store" "', argument " "12"" of type '" "double""'");
  } 
  arg12 = static_cast< double >(val12);
  ecode13 = SWIG_AsVal_double(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "SpaceDipoleEnd_store" "', argument " "13"" of type '" "double""'");
  } 
  arg13 = static_cast< double >(val13);
  ecode14 = SWIG_AsVal_double(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "SpaceDipoleEnd_store" "', argument " "14"" of type '" "double""'");
  } 
  arg14 = static_cast< double >(val14);
  ecode15 = SWIG_AsVal_int(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "SpaceDipoleEnd_store" "', argument " "15"" of type '" "int""'");
  } 
  arg15 = static_cast< int >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "SpaceDipoleEnd_store" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_double(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "SpaceDipoleEnd_store" "', argument " "17"" of type '" "double""'");
  } 
  arg17 = static_cast< double >(val17);
  (arg1)->store(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_system_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_system_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_system_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_system_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->system = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_system_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_system_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_system_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (int) ((arg1)->system);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_side_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_side_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_side_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_side_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->side = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_side_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_side_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_side_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (int) ((arg1)->side);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_iRadiator_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_iRadiator_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_iRadiator_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_iRadiator_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iRadiator = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_iRadiator_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_iRadiator_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_iRadiator_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (int) ((arg1)->iRadiator);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_iRecoiler_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_iRecoiler_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_iRecoiler_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_iRecoiler_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iRecoiler = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_iRecoiler_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_iRecoiler_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_iRecoiler_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (int) ((arg1)->iRecoiler);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_pTmax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_pTmax_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_pTmax_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_pTmax_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pTmax = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_pTmax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_pTmax_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_pTmax_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (double) ((arg1)->pTmax);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_colType_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_colType_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_colType_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_colType_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->colType = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_colType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_colType_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_colType_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (int) ((arg1)->colType);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_chgType_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_chgType_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_chgType_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_chgType_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->chgType = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_chgType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_chgType_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_chgType_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (int) ((arg1)->chgType);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_weakType_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_weakType_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_weakType_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_weakType_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->weakType = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_weakType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_weakType_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_weakType_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (int) ((arg1)->weakType);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_MEtype_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_MEtype_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_MEtype_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_MEtype_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->MEtype = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_MEtype_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_MEtype_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_MEtype_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (int) ((arg1)->MEtype);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_normalRecoil_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_normalRecoil_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_normalRecoil_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_normalRecoil_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->normalRecoil = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_normalRecoil_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_normalRecoil_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_normalRecoil_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (bool) ((arg1)->normalRecoil);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_weakPol_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_weakPol_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_weakPol_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_weakPol_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->weakPol = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_weakPol_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_weakPol_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_weakPol_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (int) ((arg1)->weakPol);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_iColPartner_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_iColPartner_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_iColPartner_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_iColPartner_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iColPartner = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_iColPartner_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_iColPartner_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_iColPartner_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (int) ((arg1)->iColPartner);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_idColPartner_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_idColPartner_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_idColPartner_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_idColPartner_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->idColPartner = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_idColPartner_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_idColPartner_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_idColPartner_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (int) ((arg1)->idColPartner);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_nBranch_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_nBranch_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_nBranch_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_nBranch_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->nBranch = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_nBranch_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_nBranch_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_nBranch_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (int) ((arg1)->nBranch);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_idDaughter_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_idDaughter_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_idDaughter_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_idDaughter_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->idDaughter = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_idDaughter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_idDaughter_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_idDaughter_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (int) ((arg1)->idDaughter);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_idMother_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_idMother_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_idMother_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_idMother_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->idMother = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_idMother_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_idMother_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_idMother_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (int) ((arg1)->idMother);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_idSister_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_idSister_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_idSister_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_idSister_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->idSister = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_idSister_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_idSister_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_idSister_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (int) ((arg1)->idSister);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_iFinPol_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_iFinPol_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_iFinPol_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_iFinPol_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iFinPol = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_iFinPol_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_iFinPol_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_iFinPol_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (int) ((arg1)->iFinPol);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_x1_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_x1_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_x1_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_x1_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->x1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_x1_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_x1_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_x1_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (double) ((arg1)->x1);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_x2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_x2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_x2_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_x2_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->x2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_x2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_x2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_x2_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (double) ((arg1)->x2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_m2Dip_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_m2Dip_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_m2Dip_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_m2Dip_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->m2Dip = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_m2Dip_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_m2Dip_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_m2Dip_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (double) ((arg1)->m2Dip);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_pT2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_pT2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_pT2_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_pT2_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pT2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_pT2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_pT2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_pT2_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (double) ((arg1)->pT2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_z_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_z_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_z_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_z_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->z = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_z_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_z_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_z_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (double) ((arg1)->z);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_xMo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_xMo_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_xMo_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_xMo_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->xMo = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_xMo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_xMo_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_xMo_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (double) ((arg1)->xMo);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_Q2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_Q2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_Q2_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_Q2_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->Q2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_Q2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_Q2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_Q2_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (double) ((arg1)->Q2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_mSister_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_mSister_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_mSister_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_mSister_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->mSister = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_mSister_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_mSister_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_mSister_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (double) ((arg1)->mSister);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_m2Sister_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_m2Sister_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_m2Sister_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_m2Sister_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->m2Sister = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_m2Sister_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_m2Sister_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_m2Sister_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (double) ((arg1)->m2Sister);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_pT2corr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_pT2corr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_pT2corr_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_pT2corr_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pT2corr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_pT2corr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_pT2corr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_pT2corr_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (double) ((arg1)->pT2corr);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_pT2Old_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_pT2Old_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_pT2Old_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_pT2Old_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pT2Old = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_pT2Old_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_pT2Old_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_pT2Old_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (double) ((arg1)->pT2Old);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_zOld_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_zOld_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_zOld_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_zOld_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->zOld = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_zOld_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_zOld_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_zOld_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (double) ((arg1)->zOld);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_asymPol_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_asymPol_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_asymPol_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_asymPol_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->asymPol = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_asymPol_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_asymPol_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_asymPol_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (double) ((arg1)->asymPol);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_m2IF_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_m2IF_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_m2IF_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_m2IF_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->m2IF = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_m2IF_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_m2IF_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_m2IF_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (double) ((arg1)->m2IF);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_mColPartner_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_mColPartner_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_mColPartner_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_mColPartner_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->mColPartner = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_mColPartner_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_mColPartner_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_mColPartner_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (double) ((arg1)->mColPartner);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_pAccept_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceDipoleEnd_pAccept_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_pAccept_set" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceDipoleEnd_pAccept_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pAccept = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceDipoleEnd_pAccept_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceDipoleEnd_pAccept_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceDipoleEnd_pAccept_get" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  result = (double) ((arg1)->pAccept);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SpaceDipoleEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceDipoleEnd *arg1 = (Pythia8::SpaceDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SpaceDipoleEnd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SpaceDipoleEnd" "', argument " "1"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SpaceDipoleEnd_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SpaceDipoleEnd, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SpaceShower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::SpaceShower *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_SpaceShower",&obj0)) SWIG_fail;
  arg1 = obj0;
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (Pythia8::SpaceShower *)new SwigDirector_SpaceShower(arg1); 
  } else {
    result = (Pythia8::SpaceShower *)new Pythia8::SpaceShower(); 
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SpaceShower, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SpaceShower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SpaceShower",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SpaceShower" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_initPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = (Pythia8::Settings *) 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  Pythia8::CoupSM *arg6 = (Pythia8::CoupSM *) 0 ;
  Pythia8::PartonSystems *arg7 = (Pythia8::PartonSystems *) 0 ;
  Pythia8::UserHooks *arg8 = (Pythia8::UserHooks *) 0 ;
  Pythia8::MergingHooks *arg9 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::PartonVertex *arg10 = (Pythia8::PartonVertex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:SpaceShower_initPtr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_initPtr" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_initPtr" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SpaceShower_initPtr" "', argument " "3"" of type '" "Pythia8::Settings *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SpaceShower_initPtr" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SpaceShower_initPtr" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SpaceShower_initPtr" "', argument " "6"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::CoupSM * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SpaceShower_initPtr" "', argument " "7"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::PartonSystems * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "SpaceShower_initPtr" "', argument " "8"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::UserHooks * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "SpaceShower_initPtr" "', argument " "9"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::MergingHooks * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_Pythia8__PartonVertex, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "SpaceShower_initPtr" "', argument " "10"" of type '" "Pythia8::PartonVertex *""'"); 
  }
  arg10 = reinterpret_cast< Pythia8::PartonVertex * >(argp10);
  (arg1)->initPtr(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::BeamParticle *arg2 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg3 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SpaceShower_init",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_init" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_init" "', argument " "2"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::BeamParticle * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SpaceShower_init" "', argument " "3"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::BeamParticle * >(argp3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::SpaceShower::init(arg2,arg3);
    } else {
      (arg1)->init(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_reassignBeamPtrs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::BeamParticle *arg2 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg3 = (Pythia8::BeamParticle *) 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SpaceShower_reassignBeamPtrs",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_reassignBeamPtrs" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_reassignBeamPtrs" "', argument " "2"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::BeamParticle * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SpaceShower_reassignBeamPtrs" "', argument " "3"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::BeamParticle * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpaceShower_reassignBeamPtrs" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->reassignBeamPtrs(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_reassignBeamPtrs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::BeamParticle *arg2 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg3 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SpaceShower_reassignBeamPtrs",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_reassignBeamPtrs" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_reassignBeamPtrs" "', argument " "2"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::BeamParticle * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SpaceShower_reassignBeamPtrs" "', argument " "3"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::BeamParticle * >(argp3);
  (arg1)->reassignBeamPtrs(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_reassignBeamPtrs(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SpaceShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SpaceShower_reassignBeamPtrs__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SpaceShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SpaceShower_reassignBeamPtrs__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SpaceShower_reassignBeamPtrs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SpaceShower::reassignBeamPtrs(Pythia8::BeamParticle *,Pythia8::BeamParticle *,int)\n"
    "    Pythia8::SpaceShower::reassignBeamPtrs(Pythia8::BeamParticle *,Pythia8::BeamParticle *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SpaceShower_limitPTmax__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SpaceShower_limitPTmax",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_limitPTmax" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_limitPTmax" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpaceShower_limitPTmax" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpaceShower_limitPTmax" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpaceShower_limitPTmax" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::SpaceShower::limitPTmax(*arg2,arg3,arg4);
    } else {
      result = (bool)(arg1)->limitPTmax(*arg2,arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_limitPTmax__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SpaceShower_limitPTmax",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_limitPTmax" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_limitPTmax" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpaceShower_limitPTmax" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpaceShower_limitPTmax" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::SpaceShower::limitPTmax(*arg2,arg3);
    } else {
      result = (bool)(arg1)->limitPTmax(*arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_limitPTmax__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceShower_limitPTmax",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_limitPTmax" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_limitPTmax" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpaceShower_limitPTmax" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::SpaceShower::limitPTmax(*arg2);
    } else {
      result = (bool)(arg1)->limitPTmax(*arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_limitPTmax(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SpaceShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SpaceShower_limitPTmax__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SpaceShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SpaceShower_limitPTmax__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SpaceShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SpaceShower_limitPTmax__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SpaceShower_limitPTmax'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SpaceShower::limitPTmax(Pythia8::Event &,double,double)\n"
    "    Pythia8::SpaceShower::limitPTmax(Pythia8::Event &,double)\n"
    "    Pythia8::SpaceShower::limitPTmax(Pythia8::Event &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SpaceShower_enhancePTmax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceShower_enhancePTmax",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_enhancePTmax" "', argument " "1"" of type '" "Pythia8::SpaceShower const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)((Pythia8::SpaceShower const *)arg1)->Pythia8::SpaceShower::enhancePTmax();
    } else {
      result = (double)((Pythia8::SpaceShower const *)arg1)->enhancePTmax();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_prepare__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SpaceShower_prepare",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_prepare" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceShower_prepare" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SpaceShower_prepare" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpaceShower_prepare" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpaceShower_prepare" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::SpaceShower::prepare(arg2,*arg3,arg4);
    } else {
      (arg1)->prepare(arg2,*arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_prepare__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SpaceShower_prepare",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_prepare" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceShower_prepare" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SpaceShower_prepare" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpaceShower_prepare" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::SpaceShower::prepare(arg2,*arg3);
    } else {
      (arg1)->prepare(arg2,*arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_prepare(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SpaceShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SpaceShower_prepare__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SpaceShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SpaceShower_prepare__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SpaceShower_prepare'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SpaceShower::prepare(int,Pythia8::Event &,bool)\n"
    "    Pythia8::SpaceShower::prepare(int,Pythia8::Event &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SpaceShower_update__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SpaceShower_update",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_update" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceShower_update" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SpaceShower_update" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpaceShower_update" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpaceShower_update" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::SpaceShower::update(arg2,*arg3,arg4);
    } else {
      (arg1)->update(arg2,*arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_update__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SpaceShower_update",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_update" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceShower_update" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SpaceShower_update" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpaceShower_update" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::SpaceShower::update(arg2,*arg3);
    } else {
      (arg1)->update(arg2,*arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_update(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SpaceShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SpaceShower_update__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SpaceShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SpaceShower_update__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SpaceShower_update'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SpaceShower::update(int,Pythia8::Event &,bool)\n"
    "    Pythia8::SpaceShower::update(int,Pythia8::Event &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SpaceShower_pTnext__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SpaceShower_pTnext",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_pTnext" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_pTnext" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpaceShower_pTnext" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpaceShower_pTnext" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpaceShower_pTnext" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpaceShower_pTnext" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SpaceShower_pTnext" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::SpaceShower::pTnext(*arg2,arg3,arg4,arg5,arg6);
    } else {
      result = (double)(arg1)->pTnext(*arg2,arg3,arg4,arg5,arg6);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_pTnext__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SpaceShower_pTnext",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_pTnext" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_pTnext" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpaceShower_pTnext" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpaceShower_pTnext" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpaceShower_pTnext" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpaceShower_pTnext" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::SpaceShower::pTnext(*arg2,arg3,arg4,arg5);
    } else {
      result = (double)(arg1)->pTnext(*arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_pTnext__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SpaceShower_pTnext",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_pTnext" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_pTnext" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpaceShower_pTnext" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpaceShower_pTnext" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpaceShower_pTnext" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::SpaceShower::pTnext(*arg2,arg3,arg4);
    } else {
      result = (double)(arg1)->pTnext(*arg2,arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_pTnext(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SpaceShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SpaceShower_pTnext__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SpaceShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SpaceShower_pTnext__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SpaceShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SpaceShower_pTnext__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SpaceShower_pTnext'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SpaceShower::pTnext(Pythia8::Event &,double,double,int,bool)\n"
    "    Pythia8::SpaceShower::pTnext(Pythia8::Event &,double,double,int)\n"
    "    Pythia8::SpaceShower::pTnext(Pythia8::Event &,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SpaceShower_branch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceShower_branch",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_branch" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_branch" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpaceShower_branch" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::SpaceShower::branch(*arg2);
    } else {
      result = (bool)(arg1)->branch(*arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_initUncertainties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceShower_initUncertainties",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_initUncertainties" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  result = (bool)(arg1)->initUncertainties();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_calcUncertainties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  bool arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  Pythia8::SpaceDipoleEnd *arg7 = (Pythia8::SpaceDipoleEnd *) 0 ;
  Pythia8::Particle *arg8 = (Pythia8::Particle *) 0 ;
  Pythia8::Particle *arg9 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:SpaceShower_calcUncertainties",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_calcUncertainties" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceShower_calcUncertainties" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpaceShower_calcUncertainties" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpaceShower_calcUncertainties" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpaceShower_calcUncertainties" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SpaceShower_calcUncertainties" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__SpaceDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SpaceShower_calcUncertainties" "', argument " "7"" of type '" "Pythia8::SpaceDipoleEnd *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::SpaceDipoleEnd * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "SpaceShower_calcUncertainties" "', argument " "8"" of type '" "Pythia8::Particle *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::Particle * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "SpaceShower_calcUncertainties" "', argument " "9"" of type '" "Pythia8::Particle *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::Particle * >(argp9);
  (arg1)->calcUncertainties(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_wasGamma2qqbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceShower_wasGamma2qqbar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_wasGamma2qqbar" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  result = (bool)(arg1)->wasGamma2qqbar();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_system(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceShower_system",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_system" "', argument " "1"" of type '" "Pythia8::SpaceShower const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)((Pythia8::SpaceShower const *)arg1)->Pythia8::SpaceShower::system();
    } else {
      result = (int)((Pythia8::SpaceShower const *)arg1)->system();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_doRestart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceShower_doRestart",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_doRestart" "', argument " "1"" of type '" "Pythia8::SpaceShower const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  result = (bool)((Pythia8::SpaceShower const *)arg1)->doRestart();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_getHasWeaklyRadiated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceShower_getHasWeaklyRadiated",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_getHasWeaklyRadiated" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  result = (bool)(arg1)->getHasWeaklyRadiated();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_clustered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Pythia8::Event result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SpaceShower_clustered",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_clustered" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_clustered" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpaceShower_clustered" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpaceShower_clustered" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpaceShower_clustered" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpaceShower_clustered" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SpaceShower_clustered" "', argument " "6"" of type '" "std::string""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (arg1)->Pythia8::SpaceShower::clustered((Pythia8::Event const &)*arg2,arg3,arg4,arg5,arg6);
    } else {
      result = (arg1)->clustered((Pythia8::Event const &)*arg2,arg3,arg4,arg5,arg6);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj((new Pythia8::Event(static_cast< const Pythia8::Event& >(result))), SWIGTYPE_p_Pythia8__Event, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_getStateVariables(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigValueWrapper< std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SpaceShower_getStateVariables",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_getStateVariables" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_getStateVariables" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpaceShower_getStateVariables" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpaceShower_getStateVariables" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpaceShower_getStateVariables" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpaceShower_getStateVariables" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SpaceShower_getStateVariables" "', argument " "6"" of type '" "std::string""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (arg1)->Pythia8::SpaceShower::getStateVariables((Pythia8::Event const &)*arg2,arg3,arg4,arg5,arg6);
    } else {
      result = (arg1)->getStateVariables((Pythia8::Event const &)*arg2,arg3,arg4,arg5,arg6);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj((new std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > >(static_cast< const std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > >& >(result))), SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_isSpacelike(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SpaceShower_isSpacelike",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_isSpacelike" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_isSpacelike" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpaceShower_isSpacelike" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpaceShower_isSpacelike" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpaceShower_isSpacelike" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpaceShower_isSpacelike" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SpaceShower_isSpacelike" "', argument " "6"" of type '" "std::string""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::SpaceShower::isSpacelike((Pythia8::Event const &)*arg2,arg3,arg4,arg5,arg6);
    } else {
      result = (bool)(arg1)->isSpacelike((Pythia8::Event const &)*arg2,arg3,arg4,arg5,arg6);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_getSplittingName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SpaceShower_getSplittingName",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_getSplittingName" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_getSplittingName" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpaceShower_getSplittingName" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpaceShower_getSplittingName" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpaceShower_getSplittingName" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpaceShower_getSplittingName" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (arg1)->Pythia8::SpaceShower::getSplittingName((Pythia8::Event const &)*arg2,arg3,arg4,arg5);
    } else {
      result = (arg1)->getSplittingName((Pythia8::Event const &)*arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_getSplittingProb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SpaceShower_getSplittingProb",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_getSplittingProb" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_getSplittingProb" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpaceShower_getSplittingProb" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpaceShower_getSplittingProb" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpaceShower_getSplittingProb" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SpaceShower_getSplittingProb" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SpaceShower_getSplittingProb" "', argument " "6"" of type '" "std::string""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::SpaceShower::getSplittingProb((Pythia8::Event const &)*arg2,arg3,arg4,arg5,arg6);
    } else {
      result = (double)(arg1)->getSplittingProb((Pythia8::Event const &)*arg2,arg3,arg4,arg5,arg6);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_allowedSplitting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:SpaceShower_allowedSplitting",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_allowedSplitting" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_allowedSplitting" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpaceShower_allowedSplitting" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpaceShower_allowedSplitting" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpaceShower_allowedSplitting" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::SpaceShower::allowedSplitting((Pythia8::Event const &)*arg2,arg3,arg4);
    } else {
      result = (bool)(arg1)->allowedSplitting((Pythia8::Event const &)*arg2,arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_getRecoilers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  std::vector< int,std::allocator< int > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SpaceShower_getRecoilers",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_getRecoilers" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_getRecoilers" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpaceShower_getRecoilers" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpaceShower_getRecoilers" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SpaceShower_getRecoilers" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "SpaceShower_getRecoilers" "', argument " "5"" of type '" "std::string""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (arg1)->Pythia8::SpaceShower::getRecoilers((Pythia8::Event const &)*arg2,arg3,arg4,arg5);
    } else {
      result = (arg1)->getRecoilers((Pythia8::Event const &)*arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_mergingHooksPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::MergingHooks *arg2 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceShower_mergingHooksPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_mergingHooksPtr_set" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__MergingHooks, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_mergingHooksPtr_set" "', argument " "2"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::MergingHooks * >(argp2);
  if (arg1) (arg1)->mergingHooksPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_mergingHooksPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::MergingHooks *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceShower_mergingHooksPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_mergingHooksPtr_get" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  result = (Pythia8::MergingHooks *) ((arg1)->mergingHooksPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_infoPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceShower_infoPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_infoPtr_set" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_infoPtr_set" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  if (arg1) darg->infoPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_infoPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  Pythia8::Info *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceShower_infoPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_infoPtr_get" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  result = (Pythia8::Info *) (darg->infoPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_settingsPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::Settings *arg2 = (Pythia8::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceShower_settingsPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_settingsPtr_set" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Settings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_settingsPtr_set" "', argument " "2"" of type '" "Pythia8::Settings *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  if (arg1) darg->settingsPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_settingsPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  Pythia8::Settings *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceShower_settingsPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_settingsPtr_get" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  result = (Pythia8::Settings *) (darg->settingsPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_particleDataPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::ParticleData *arg2 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceShower_particleDataPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_particleDataPtr_set" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ParticleData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_particleDataPtr_set" "', argument " "2"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ParticleData * >(argp2);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  if (arg1) darg->particleDataPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_particleDataPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  Pythia8::ParticleData *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceShower_particleDataPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_particleDataPtr_get" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  result = (Pythia8::ParticleData *) (darg->particleDataPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_rndmPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::Rndm *arg2 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceShower_rndmPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_rndmPtr_set" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Rndm, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_rndmPtr_set" "', argument " "2"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Rndm * >(argp2);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  if (arg1) darg->rndmPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_rndmPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  Pythia8::Rndm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceShower_rndmPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_rndmPtr_get" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  result = (Pythia8::Rndm *) (darg->rndmPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_coupSMPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::CoupSM *arg2 = (Pythia8::CoupSM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceShower_coupSMPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_coupSMPtr_set" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__CoupSM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_coupSMPtr_set" "', argument " "2"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::CoupSM * >(argp2);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  if (arg1) darg->coupSMPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_coupSMPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  Pythia8::CoupSM *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceShower_coupSMPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_coupSMPtr_get" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  result = (Pythia8::CoupSM *) (darg->coupSMPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_beamAPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::BeamParticle *arg2 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceShower_beamAPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_beamAPtr_set" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__BeamParticle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_beamAPtr_set" "', argument " "2"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::BeamParticle * >(argp2);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  if (arg1) darg->beamAPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_beamAPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  Pythia8::BeamParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceShower_beamAPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_beamAPtr_get" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  result = (Pythia8::BeamParticle *) (darg->beamAPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_beamBPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::BeamParticle *arg2 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceShower_beamBPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_beamBPtr_set" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__BeamParticle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_beamBPtr_set" "', argument " "2"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::BeamParticle * >(argp2);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  if (arg1) darg->beamBPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_beamBPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  Pythia8::BeamParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceShower_beamBPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_beamBPtr_get" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  result = (Pythia8::BeamParticle *) (darg->beamBPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_beamOffset_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceShower_beamOffset_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_beamOffset_set" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceShower_beamOffset_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  if (arg1) darg->beamOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_beamOffset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceShower_beamOffset_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_beamOffset_get" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  result = (int) (darg->beamOffset);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_partonSystemsPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::PartonSystems *arg2 = (Pythia8::PartonSystems *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceShower_partonSystemsPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_partonSystemsPtr_set" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PartonSystems, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_partonSystemsPtr_set" "', argument " "2"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PartonSystems * >(argp2);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  if (arg1) darg->partonSystemsPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_partonSystemsPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  Pythia8::PartonSystems *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceShower_partonSystemsPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_partonSystemsPtr_get" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  result = (Pythia8::PartonSystems *) (darg->partonSystemsPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_userHooksPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::UserHooks *arg2 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceShower_userHooksPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_userHooksPtr_set" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__UserHooks, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_userHooksPtr_set" "', argument " "2"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::UserHooks * >(argp2);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  if (arg1) darg->userHooksPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_userHooksPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  Pythia8::UserHooks *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceShower_userHooksPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_userHooksPtr_get" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  result = (Pythia8::UserHooks *) (darg->userHooksPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_partonVertexPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::PartonVertex *arg2 = (Pythia8::PartonVertex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceShower_partonVertexPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_partonVertexPtr_set" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PartonVertex, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_partonVertexPtr_set" "', argument " "2"" of type '" "Pythia8::PartonVertex *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PartonVertex * >(argp2);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  if (arg1) darg->partonVertexPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_partonVertexPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  Pythia8::PartonVertex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceShower_partonVertexPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_partonVertexPtr_get" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  result = (Pythia8::PartonVertex *) (darg->partonVertexPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PartonVertex, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_weakShowerMEs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::WeakShowerMEs *arg2 = (Pythia8::WeakShowerMEs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceShower_weakShowerMEs_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_weakShowerMEs_set" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__WeakShowerMEs, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpaceShower_weakShowerMEs_set" "', argument " "2"" of type '" "Pythia8::WeakShowerMEs *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::WeakShowerMEs * >(argp2);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  if (arg1) darg->weakShowerMEs = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_weakShowerMEs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  Pythia8::WeakShowerMEs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceShower_weakShowerMEs_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_weakShowerMEs_get" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  result = (Pythia8::WeakShowerMEs *)& (darg->weakShowerMEs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__WeakShowerMEs, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_rescatterFail_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceShower_rescatterFail_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_rescatterFail_set" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceShower_rescatterFail_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  if (arg1) darg->rescatterFail = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_rescatterFail_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceShower_rescatterFail_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_rescatterFail_get" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  result = (bool) (darg->rescatterFail);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_iSysSel_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceShower_iSysSel_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_iSysSel_set" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceShower_iSysSel_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  if (arg1) darg->iSysSel = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_iSysSel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceShower_iSysSel_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_iSysSel_get" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  result = (int) (darg->iSysSel);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_pTmaxFudge_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SpaceShower_pTmaxFudge_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_pTmaxFudge_set" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpaceShower_pTmaxFudge_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  if (arg1) darg->pTmaxFudge = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower_pTmaxFudge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_SpaceShower *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceShower_pTmaxFudge_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower_pTmaxFudge_get" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  darg = dynamic_cast<SwigDirector_SpaceShower *>(arg1);
  result = (double) (darg->pTmaxFudge);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SpaceShower___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SpaceShower___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceShower___str__" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  result = Pythia8_SpaceShower___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_SpaceShower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SpaceShower *arg1 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:disown_SpaceShower",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_SpaceShower" "', argument " "1"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SpaceShower * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SpaceShower_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SpaceShower, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_StringEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StringEnd")) SWIG_fail;
  result = (Pythia8::StringEnd *)new Pythia8::StringEnd();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__StringEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  Pythia8::ParticleData *arg2 = (Pythia8::ParticleData *) 0 ;
  Pythia8::StringFlav *arg3 = (Pythia8::StringFlav *) 0 ;
  Pythia8::StringPT *arg4 = (Pythia8::StringPT *) 0 ;
  Pythia8::StringZ *arg5 = (Pythia8::StringZ *) 0 ;
  Pythia8::Settings *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:StringEnd_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_init" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringEnd_init" "', argument " "2"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ParticleData * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringEnd_init" "', argument " "3"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::StringFlav * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__StringPT, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StringEnd_init" "', argument " "4"" of type '" "Pythia8::StringPT *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::StringPT * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__StringZ, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "StringEnd_init" "', argument " "5"" of type '" "Pythia8::StringZ *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::StringZ * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "StringEnd_init" "', argument " "6"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringEnd_init" "', argument " "6"" of type '" "Pythia8::Settings &""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::Settings * >(argp6);
  (arg1)->init(arg2,arg3,arg4,arg5,*arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_setUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  bool arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:StringEnd_setUp",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_setUp" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_setUp" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringEnd_setUp" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StringEnd_setUp" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "StringEnd_setUp" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "StringEnd_setUp" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "StringEnd_setUp" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "StringEnd_setUp" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "StringEnd_setUp" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "StringEnd_setUp" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  (arg1)->setUp(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_newHadron__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_newHadron",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_newHadron" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_newHadron" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->newHadron(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_newHadron__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_newHadron",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_newHadron" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  (arg1)->newHadron();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_newHadron(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringEnd, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringEnd_newHadron__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringEnd, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringEnd_newHadron__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'StringEnd_newHadron'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::StringEnd::newHadron(double)\n"
    "    Pythia8::StringEnd::newHadron()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringEnd_kinematicsHadron__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  Pythia8::StringSystem *arg2 = 0 ;
  std::vector< Pythia8::StringVertex,std::allocator< Pythia8::StringVertex > > *arg3 = 0 ;
  bool arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:StringEnd_kinematicsHadron",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_kinematicsHadron" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__StringSystem,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringEnd_kinematicsHadron" "', argument " "2"" of type '" "Pythia8::StringSystem &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringEnd_kinematicsHadron" "', argument " "2"" of type '" "Pythia8::StringSystem &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::StringSystem * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_Pythia8__StringVertex_std__allocatorT_Pythia8__StringVertex_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringEnd_kinematicsHadron" "', argument " "3"" of type '" "std::vector< Pythia8::StringVertex,std::allocator< Pythia8::StringVertex > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringEnd_kinematicsHadron" "', argument " "3"" of type '" "std::vector< Pythia8::StringVertex,std::allocator< Pythia8::StringVertex > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::StringVertex,std::allocator< Pythia8::StringVertex > > * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StringEnd_kinematicsHadron" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "StringEnd_kinematicsHadron" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (arg1)->kinematicsHadron(*arg2,*arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_kinematicsHadron__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  Pythia8::StringSystem *arg2 = 0 ;
  std::vector< Pythia8::StringVertex,std::allocator< Pythia8::StringVertex > > *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:StringEnd_kinematicsHadron",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_kinematicsHadron" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__StringSystem,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringEnd_kinematicsHadron" "', argument " "2"" of type '" "Pythia8::StringSystem &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringEnd_kinematicsHadron" "', argument " "2"" of type '" "Pythia8::StringSystem &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::StringSystem * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_Pythia8__StringVertex_std__allocatorT_Pythia8__StringVertex_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringEnd_kinematicsHadron" "', argument " "3"" of type '" "std::vector< Pythia8::StringVertex,std::allocator< Pythia8::StringVertex > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringEnd_kinematicsHadron" "', argument " "3"" of type '" "std::vector< Pythia8::StringVertex,std::allocator< Pythia8::StringVertex > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::StringVertex,std::allocator< Pythia8::StringVertex > > * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StringEnd_kinematicsHadron" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (arg1)->kinematicsHadron(*arg2,*arg3,arg4);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_kinematicsHadron__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  Pythia8::StringSystem *arg2 = 0 ;
  std::vector< Pythia8::StringVertex,std::allocator< Pythia8::StringVertex > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:StringEnd_kinematicsHadron",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_kinematicsHadron" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__StringSystem,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringEnd_kinematicsHadron" "', argument " "2"" of type '" "Pythia8::StringSystem &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringEnd_kinematicsHadron" "', argument " "2"" of type '" "Pythia8::StringSystem &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::StringSystem * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_Pythia8__StringVertex_std__allocatorT_Pythia8__StringVertex_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringEnd_kinematicsHadron" "', argument " "3"" of type '" "std::vector< Pythia8::StringVertex,std::allocator< Pythia8::StringVertex > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringEnd_kinematicsHadron" "', argument " "3"" of type '" "std::vector< Pythia8::StringVertex,std::allocator< Pythia8::StringVertex > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::StringVertex,std::allocator< Pythia8::StringVertex > > * >(argp3);
  result = (arg1)->kinematicsHadron(*arg2,*arg3);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_kinematicsHadron(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringEnd, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__StringSystem, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_Pythia8__StringVertex_std__allocatorT_Pythia8__StringVertex_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StringEnd_kinematicsHadron__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringEnd, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__StringSystem, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_Pythia8__StringVertex_std__allocatorT_Pythia8__StringVertex_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_StringEnd_kinematicsHadron__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringEnd, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__StringSystem, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_Pythia8__StringVertex_std__allocatorT_Pythia8__StringVertex_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_StringEnd_kinematicsHadron__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'StringEnd_kinematicsHadron'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::StringEnd::kinematicsHadron(Pythia8::StringSystem &,std::vector< Pythia8::StringVertex,std::allocator< Pythia8::StringVertex > > &,bool,double)\n"
    "    Pythia8::StringEnd::kinematicsHadron(Pythia8::StringSystem &,std::vector< Pythia8::StringVertex,std::allocator< Pythia8::StringVertex > > &,bool)\n"
    "    Pythia8::StringEnd::kinematicsHadron(Pythia8::StringSystem &,std::vector< Pythia8::StringVertex,std::allocator< Pythia8::StringVertex > > &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringEnd_kinematicsHadronTmp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  Pythia8::StringSystem arg2 ;
  Pythia8::Vec4 arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:StringEnd_kinematicsHadronTmp",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_kinematicsHadronTmp" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__StringSystem,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringEnd_kinematicsHadronTmp" "', argument " "2"" of type '" "Pythia8::StringSystem""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringEnd_kinematicsHadronTmp" "', argument " "2"" of type '" "Pythia8::StringSystem""'");
    } else {
      Pythia8::StringSystem * temp = reinterpret_cast< Pythia8::StringSystem * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringEnd_kinematicsHadronTmp" "', argument " "3"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringEnd_kinematicsHadronTmp" "', argument " "3"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StringEnd_kinematicsHadronTmp" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "StringEnd_kinematicsHadronTmp" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (arg1)->kinematicsHadronTmp(arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_update",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_update" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  (arg1)->update();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int Swig_var_StringEnd_TINY_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StringEnd_TINY is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StringEnd_TINY_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(Pythia8::StringEnd::TINY));
  return pyobj;
}


SWIGINTERN int Swig_var_StringEnd_PT2SAME_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StringEnd_PT2SAME is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StringEnd_PT2SAME_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(Pythia8::StringEnd::PT2SAME));
  return pyobj;
}


SWIGINTERN int Swig_var_StringEnd_MEANMMIN_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StringEnd_MEANMMIN is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StringEnd_MEANMMIN_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(Pythia8::StringEnd::MEANMMIN));
  return pyobj;
}


SWIGINTERN int Swig_var_StringEnd_MEANM_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StringEnd_MEANM is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StringEnd_MEANM_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(Pythia8::StringEnd::MEANM));
  return pyobj;
}


SWIGINTERN int Swig_var_StringEnd_MEANPT_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable StringEnd_MEANPT is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_StringEnd_MEANPT_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(Pythia8::StringEnd::MEANPT));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_StringEnd_particleDataPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  Pythia8::ParticleData *arg2 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_particleDataPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_particleDataPtr_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ParticleData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringEnd_particleDataPtr_set" "', argument " "2"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ParticleData * >(argp2);
  if (arg1) (arg1)->particleDataPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_particleDataPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ParticleData *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_particleDataPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_particleDataPtr_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (Pythia8::ParticleData *) ((arg1)->particleDataPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_flavSelPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  Pythia8::StringFlav *arg2 = (Pythia8::StringFlav *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_flavSelPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_flavSelPtr_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__StringFlav, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringEnd_flavSelPtr_set" "', argument " "2"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::StringFlav * >(argp2);
  if (arg1) (arg1)->flavSelPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_flavSelPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::StringFlav *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_flavSelPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_flavSelPtr_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (Pythia8::StringFlav *) ((arg1)->flavSelPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_pTSelPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  Pythia8::StringPT *arg2 = (Pythia8::StringPT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_pTSelPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_pTSelPtr_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__StringPT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringEnd_pTSelPtr_set" "', argument " "2"" of type '" "Pythia8::StringPT *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::StringPT * >(argp2);
  if (arg1) (arg1)->pTSelPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_pTSelPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::StringPT *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_pTSelPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_pTSelPtr_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (Pythia8::StringPT *) ((arg1)->pTSelPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__StringPT, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_zSelPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  Pythia8::StringZ *arg2 = (Pythia8::StringZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_zSelPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_zSelPtr_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__StringZ, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringEnd_zSelPtr_set" "', argument " "2"" of type '" "Pythia8::StringZ *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::StringZ * >(argp2);
  if (arg1) (arg1)->zSelPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_zSelPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::StringZ *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_zSelPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_zSelPtr_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (Pythia8::StringZ *) ((arg1)->zSelPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__StringZ, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_fromPos_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_fromPos_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_fromPos_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_fromPos_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->fromPos = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_fromPos_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_fromPos_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_fromPos_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (bool) ((arg1)->fromPos);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_thermalModel_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_thermalModel_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_thermalModel_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_thermalModel_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->thermalModel = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_thermalModel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_thermalModel_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_thermalModel_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (bool) ((arg1)->thermalModel);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_mT2suppression_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_mT2suppression_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_mT2suppression_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_mT2suppression_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->mT2suppression = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_mT2suppression_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_mT2suppression_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_mT2suppression_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (bool) ((arg1)->mT2suppression);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_iEnd_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_iEnd_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_iEnd_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_iEnd_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iEnd = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_iEnd_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_iEnd_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_iEnd_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (int) ((arg1)->iEnd);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_iMax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_iMax_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_iMax_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_iMax_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iMax = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_iMax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_iMax_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_iMax_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (int) ((arg1)->iMax);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_idHad_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_idHad_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_idHad_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_idHad_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->idHad = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_idHad_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_idHad_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_idHad_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (int) ((arg1)->idHad);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_iPosOld_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_iPosOld_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_iPosOld_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_iPosOld_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iPosOld = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_iPosOld_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_iPosOld_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_iPosOld_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (int) ((arg1)->iPosOld);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_iNegOld_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_iNegOld_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_iNegOld_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_iNegOld_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iNegOld = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_iNegOld_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_iNegOld_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_iNegOld_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (int) ((arg1)->iNegOld);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_iPosNew_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_iPosNew_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_iPosNew_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_iPosNew_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iPosNew = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_iPosNew_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_iPosNew_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_iPosNew_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (int) ((arg1)->iPosNew);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_iNegNew_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_iNegNew_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_iNegNew_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_iNegNew_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iNegNew = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_iNegNew_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_iNegNew_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_iNegNew_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (int) ((arg1)->iNegNew);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_hadSoFar_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_hadSoFar_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_hadSoFar_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_hadSoFar_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->hadSoFar = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_hadSoFar_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_hadSoFar_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_hadSoFar_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (int) ((arg1)->hadSoFar);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_pxOld_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_pxOld_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_pxOld_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_pxOld_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pxOld = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_pxOld_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_pxOld_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_pxOld_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (double) ((arg1)->pxOld);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_pyOld_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_pyOld_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_pyOld_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_pyOld_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pyOld = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_pyOld_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_pyOld_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_pyOld_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (double) ((arg1)->pyOld);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_pxNew_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_pxNew_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_pxNew_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_pxNew_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pxNew = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_pxNew_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_pxNew_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_pxNew_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (double) ((arg1)->pxNew);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_pyNew_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_pyNew_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_pyNew_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_pyNew_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pyNew = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_pyNew_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_pyNew_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_pyNew_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (double) ((arg1)->pyNew);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_pxHad_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_pxHad_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_pxHad_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_pxHad_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pxHad = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_pxHad_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_pxHad_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_pxHad_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (double) ((arg1)->pxHad);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_pyHad_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_pyHad_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_pyHad_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_pyHad_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pyHad = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_pyHad_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_pyHad_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_pyHad_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (double) ((arg1)->pyHad);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_mHad_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_mHad_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_mHad_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_mHad_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->mHad = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_mHad_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_mHad_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_mHad_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (double) ((arg1)->mHad);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_mT2Had_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_mT2Had_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_mT2Had_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_mT2Had_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->mT2Had = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_mT2Had_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_mT2Had_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_mT2Had_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (double) ((arg1)->mT2Had);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_zHad_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_zHad_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_zHad_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_zHad_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->zHad = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_zHad_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_zHad_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_zHad_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (double) ((arg1)->zHad);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_GammaOld_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_GammaOld_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_GammaOld_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_GammaOld_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->GammaOld = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_GammaOld_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_GammaOld_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_GammaOld_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (double) ((arg1)->GammaOld);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_GammaNew_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_GammaNew_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_GammaNew_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_GammaNew_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->GammaNew = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_GammaNew_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_GammaNew_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_GammaNew_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (double) ((arg1)->GammaNew);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_xPosOld_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_xPosOld_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_xPosOld_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_xPosOld_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->xPosOld = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_xPosOld_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_xPosOld_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_xPosOld_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (double) ((arg1)->xPosOld);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_xPosNew_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_xPosNew_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_xPosNew_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_xPosNew_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->xPosNew = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_xPosNew_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_xPosNew_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_xPosNew_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (double) ((arg1)->xPosNew);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_xPosHad_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_xPosHad_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_xPosHad_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_xPosHad_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->xPosHad = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_xPosHad_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_xPosHad_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_xPosHad_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (double) ((arg1)->xPosHad);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_xNegOld_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_xNegOld_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_xNegOld_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_xNegOld_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->xNegOld = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_xNegOld_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_xNegOld_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_xNegOld_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (double) ((arg1)->xNegOld);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_xNegNew_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_xNegNew_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_xNegNew_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_xNegNew_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->xNegNew = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_xNegNew_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_xNegNew_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_xNegNew_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (double) ((arg1)->xNegNew);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_xNegHad_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_xNegHad_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_xNegHad_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_xNegHad_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->xNegHad = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_xNegHad_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_xNegHad_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_xNegHad_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (double) ((arg1)->xNegHad);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_aLund_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_aLund_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_aLund_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_aLund_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->aLund = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_aLund_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_aLund_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_aLund_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (double) ((arg1)->aLund);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_bLund_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_bLund_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_bLund_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringEnd_bLund_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->bLund = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_bLund_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_bLund_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_bLund_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (double) ((arg1)->bLund);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_flavOld_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  Pythia8::FlavContainer *arg2 = (Pythia8::FlavContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_flavOld_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_flavOld_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__FlavContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringEnd_flavOld_set" "', argument " "2"" of type '" "Pythia8::FlavContainer *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::FlavContainer * >(argp2);
  if (arg1) (arg1)->flavOld = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_flavOld_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::FlavContainer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_flavOld_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_flavOld_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (Pythia8::FlavContainer *)& ((arg1)->flavOld);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__FlavContainer, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_flavNew_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  Pythia8::FlavContainer *arg2 = (Pythia8::FlavContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_flavNew_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_flavNew_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__FlavContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringEnd_flavNew_set" "', argument " "2"" of type '" "Pythia8::FlavContainer *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::FlavContainer * >(argp2);
  if (arg1) (arg1)->flavNew = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_flavNew_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::FlavContainer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_flavNew_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_flavNew_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (Pythia8::FlavContainer *)& ((arg1)->flavNew);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__FlavContainer, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_pHad_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  Pythia8::Vec4 *arg2 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_pHad_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_pHad_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringEnd_pHad_set" "', argument " "2"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  if (arg1) (arg1)->pHad = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_pHad_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_pHad_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_pHad_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (Pythia8::Vec4 *)& ((arg1)->pHad);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_pSoFar_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  Pythia8::Vec4 *arg2 = (Pythia8::Vec4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:StringEnd_pSoFar_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_pSoFar_set" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringEnd_pSoFar_set" "', argument " "2"" of type '" "Pythia8::Vec4 *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  if (arg1) (arg1)->pSoFar = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringEnd_pSoFar_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:StringEnd_pSoFar_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringEnd_pSoFar_get" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  result = (Pythia8::Vec4 *)& ((arg1)->pSoFar);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StringEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringEnd *arg1 = (Pythia8::StringEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StringEnd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringEnd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StringEnd" "', argument " "1"" of type '" "Pythia8::StringEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringEnd * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StringEnd_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__StringEnd, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_StringFragmentation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFragmentation *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StringFragmentation")) SWIG_fail;
  result = (Pythia8::StringFragmentation *)new Pythia8::StringFragmentation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__StringFragmentation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFragmentation_init__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFragmentation *arg1 = (Pythia8::StringFragmentation *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  Pythia8::StringFlav *arg6 = (Pythia8::StringFlav *) 0 ;
  Pythia8::StringPT *arg7 = (Pythia8::StringPT *) 0 ;
  Pythia8::StringZ *arg8 = (Pythia8::StringZ *) 0 ;
  Pythia8::FlavourRope *arg9 = (Pythia8::FlavourRope *) 0 ;
  Pythia8::UserHooks *arg10 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:StringFragmentation_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFragmentation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFragmentation_init" "', argument " "1"" of type '" "Pythia8::StringFragmentation *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFragmentation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringFragmentation_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringFragmentation_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFragmentation_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StringFragmentation_init" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "StringFragmentation_init" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "StringFragmentation_init" "', argument " "6"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::StringFlav * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__StringPT, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "StringFragmentation_init" "', argument " "7"" of type '" "Pythia8::StringPT *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::StringPT * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__StringZ, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "StringFragmentation_init" "', argument " "8"" of type '" "Pythia8::StringZ *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::StringZ * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__FlavourRope, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "StringFragmentation_init" "', argument " "9"" of type '" "Pythia8::FlavourRope *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::FlavourRope * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "StringFragmentation_init" "', argument " "10"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg10 = reinterpret_cast< Pythia8::UserHooks * >(argp10);
  (arg1)->init(arg2,*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFragmentation_init__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFragmentation *arg1 = (Pythia8::StringFragmentation *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  Pythia8::StringFlav *arg6 = (Pythia8::StringFlav *) 0 ;
  Pythia8::StringPT *arg7 = (Pythia8::StringPT *) 0 ;
  Pythia8::StringZ *arg8 = (Pythia8::StringZ *) 0 ;
  Pythia8::FlavourRope *arg9 = (Pythia8::FlavourRope *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:StringFragmentation_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFragmentation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFragmentation_init" "', argument " "1"" of type '" "Pythia8::StringFragmentation *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFragmentation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringFragmentation_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringFragmentation_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFragmentation_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StringFragmentation_init" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "StringFragmentation_init" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "StringFragmentation_init" "', argument " "6"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::StringFlav * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__StringPT, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "StringFragmentation_init" "', argument " "7"" of type '" "Pythia8::StringPT *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::StringPT * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__StringZ, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "StringFragmentation_init" "', argument " "8"" of type '" "Pythia8::StringZ *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::StringZ * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__FlavourRope, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "StringFragmentation_init" "', argument " "9"" of type '" "Pythia8::FlavourRope *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::FlavourRope * >(argp9);
  (arg1)->init(arg2,*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFragmentation_init__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFragmentation *arg1 = (Pythia8::StringFragmentation *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  Pythia8::StringFlav *arg6 = (Pythia8::StringFlav *) 0 ;
  Pythia8::StringPT *arg7 = (Pythia8::StringPT *) 0 ;
  Pythia8::StringZ *arg8 = (Pythia8::StringZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:StringFragmentation_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFragmentation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFragmentation_init" "', argument " "1"" of type '" "Pythia8::StringFragmentation *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFragmentation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringFragmentation_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringFragmentation_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFragmentation_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StringFragmentation_init" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "StringFragmentation_init" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "StringFragmentation_init" "', argument " "6"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::StringFlav * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__StringPT, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "StringFragmentation_init" "', argument " "7"" of type '" "Pythia8::StringPT *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::StringPT * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__StringZ, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "StringFragmentation_init" "', argument " "8"" of type '" "Pythia8::StringZ *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::StringZ * >(argp8);
  (arg1)->init(arg2,*arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFragmentation_init(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 10) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringFragmentation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__Rndm, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__StringFlav, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__StringPT, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Pythia8__StringZ, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_StringFragmentation_init__SWIG_2(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringFragmentation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__Rndm, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__StringFlav, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__StringPT, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Pythia8__StringZ, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_Pythia8__FlavourRope, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_StringFragmentation_init__SWIG_1(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringFragmentation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__Rndm, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__StringFlav, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__StringPT, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Pythia8__StringZ, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_Pythia8__FlavourRope, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_Pythia8__UserHooks, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_StringFragmentation_init__SWIG_0(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'StringFragmentation_init'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::StringFragmentation::init(Pythia8::Info *,Pythia8::Settings &,Pythia8::ParticleData *,Pythia8::Rndm *,Pythia8::StringFlav *,Pythia8::StringPT *,Pythia8::StringZ *,Pythia8::FlavourRope *,Pythia8::UserHooks *)\n"
    "    Pythia8::StringFragmentation::init(Pythia8::Info *,Pythia8::Settings &,Pythia8::ParticleData *,Pythia8::Rndm *,Pythia8::StringFlav *,Pythia8::StringPT *,Pythia8::StringZ *,Pythia8::FlavourRope *)\n"
    "    Pythia8::StringFragmentation::init(Pythia8::Info *,Pythia8::Settings &,Pythia8::ParticleData *,Pythia8::Rndm *,Pythia8::StringFlav *,Pythia8::StringPT *,Pythia8::StringZ *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringFragmentation_fragment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFragmentation *arg1 = (Pythia8::StringFragmentation *) 0 ;
  int arg2 ;
  Pythia8::ColConfig *arg3 = 0 ;
  Pythia8::Event *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:StringFragmentation_fragment",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFragmentation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFragmentation_fragment" "', argument " "1"" of type '" "Pythia8::StringFragmentation *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFragmentation * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringFragmentation_fragment" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__ColConfig,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringFragmentation_fragment" "', argument " "3"" of type '" "Pythia8::ColConfig &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFragmentation_fragment" "', argument " "3"" of type '" "Pythia8::ColConfig &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ColConfig * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StringFragmentation_fragment" "', argument " "4"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFragmentation_fragment" "', argument " "4"" of type '" "Pythia8::Event &""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Event * >(argp4);
  result = (bool)(arg1)->fragment(arg2,*arg3,*arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringFragmentation_junctionRestFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFragmentation *arg1 = (Pythia8::StringFragmentation *) 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  Pythia8::Vec4 *arg3 = 0 ;
  Pythia8::Vec4 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::RotBstMatrix result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:StringFragmentation_junctionRestFrame",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFragmentation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringFragmentation_junctionRestFrame" "', argument " "1"" of type '" "Pythia8::StringFragmentation *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFragmentation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringFragmentation_junctionRestFrame" "', argument " "2"" of type '" "Pythia8::Vec4 &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFragmentation_junctionRestFrame" "', argument " "2"" of type '" "Pythia8::Vec4 &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringFragmentation_junctionRestFrame" "', argument " "3"" of type '" "Pythia8::Vec4 &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFragmentation_junctionRestFrame" "', argument " "3"" of type '" "Pythia8::Vec4 &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Vec4 * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Vec4,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StringFragmentation_junctionRestFrame" "', argument " "4"" of type '" "Pythia8::Vec4 &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringFragmentation_junctionRestFrame" "', argument " "4"" of type '" "Pythia8::Vec4 &""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Vec4 * >(argp4);
  result = (arg1)->junctionRestFrame(*arg2,*arg3,*arg4);
  resultobj = SWIG_NewPointerObj((new Pythia8::RotBstMatrix(static_cast< const Pythia8::RotBstMatrix& >(result))), SWIGTYPE_p_Pythia8__RotBstMatrix, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StringFragmentation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringFragmentation *arg1 = (Pythia8::StringFragmentation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StringFragmentation",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringFragmentation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StringFragmentation" "', argument " "1"" of type '" "Pythia8::StringFragmentation *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringFragmentation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StringFragmentation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__StringFragmentation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_StringLength_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringLength *arg1 = (Pythia8::StringLength *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:StringLength_init",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringLength, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringLength_init" "', argument " "1"" of type '" "Pythia8::StringLength *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringLength * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringLength_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringLength_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringLength_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  (arg1)->init(arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringLength_getLength__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringLength *arg1 = (Pythia8::StringLength *) 0 ;
  Pythia8::Vec4 arg2 ;
  Pythia8::Vec4 arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:StringLength_getLength",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringLength, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringLength_getLength" "', argument " "1"" of type '" "Pythia8::StringLength *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringLength * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringLength_getLength" "', argument " "2"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringLength_getLength" "', argument " "2"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringLength_getLength" "', argument " "3"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringLength_getLength" "', argument " "3"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StringLength_getLength" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (double)(arg1)->getLength(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringLength_getLength__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringLength *arg1 = (Pythia8::StringLength *) 0 ;
  Pythia8::Vec4 arg2 ;
  Pythia8::Vec4 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:StringLength_getLength",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringLength, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringLength_getLength" "', argument " "1"" of type '" "Pythia8::StringLength *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringLength * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringLength_getLength" "', argument " "2"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringLength_getLength" "', argument " "2"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringLength_getLength" "', argument " "3"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringLength_getLength" "', argument " "3"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = (double)(arg1)->getLength(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringLength_getLength(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringLength, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StringLength_getLength__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringLength, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_StringLength_getLength__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'StringLength_getLength'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::StringLength::getLength(Pythia8::Vec4,Pythia8::Vec4,bool)\n"
    "    Pythia8::StringLength::getLength(Pythia8::Vec4,Pythia8::Vec4)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringLength_getStringLength__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringLength *arg1 = (Pythia8::StringLength *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:StringLength_getStringLength",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringLength, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringLength_getStringLength" "', argument " "1"" of type '" "Pythia8::StringLength *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringLength * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringLength_getStringLength" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringLength_getStringLength" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringLength_getStringLength" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StringLength_getStringLength" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (double)(arg1)->getStringLength(*arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringLength_getStringLength__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringLength *arg1 = (Pythia8::StringLength *) 0 ;
  Pythia8::Vec4 arg2 ;
  Pythia8::Vec4 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:StringLength_getStringLength",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringLength, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringLength_getStringLength" "', argument " "1"" of type '" "Pythia8::StringLength *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringLength * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringLength_getStringLength" "', argument " "2"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringLength_getStringLength" "', argument " "2"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringLength_getStringLength" "', argument " "3"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringLength_getStringLength" "', argument " "3"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  result = (double)(arg1)->getStringLength(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringLength_getStringLength(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringLength, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StringLength_getStringLength__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringLength, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_StringLength_getStringLength__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'StringLength_getStringLength'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::StringLength::getStringLength(Pythia8::Event &,int,int)\n"
    "    Pythia8::StringLength::getStringLength(Pythia8::Vec4,Pythia8::Vec4)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringLength_getJuncLength__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringLength *arg1 = (Pythia8::StringLength *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:StringLength_getJuncLength",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringLength, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringLength_getJuncLength" "', argument " "1"" of type '" "Pythia8::StringLength *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringLength * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringLength_getJuncLength" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringLength_getJuncLength" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringLength_getJuncLength" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StringLength_getJuncLength" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "StringLength_getJuncLength" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (double)(arg1)->getJuncLength(*arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringLength_getJuncLength__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringLength *arg1 = (Pythia8::StringLength *) 0 ;
  Pythia8::Vec4 arg2 ;
  Pythia8::Vec4 arg3 ;
  Pythia8::Vec4 arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:StringLength_getJuncLength",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringLength, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringLength_getJuncLength" "', argument " "1"" of type '" "Pythia8::StringLength *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringLength * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringLength_getJuncLength" "', argument " "2"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringLength_getJuncLength" "', argument " "2"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringLength_getJuncLength" "', argument " "3"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringLength_getJuncLength" "', argument " "3"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StringLength_getJuncLength" "', argument " "4"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringLength_getJuncLength" "', argument " "4"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  result = (double)(arg1)->getJuncLength(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringLength_getJuncLength__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringLength *arg1 = (Pythia8::StringLength *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:StringLength_getJuncLength",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringLength, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringLength_getJuncLength" "', argument " "1"" of type '" "Pythia8::StringLength *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringLength * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringLength_getJuncLength" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringLength_getJuncLength" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringLength_getJuncLength" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "StringLength_getJuncLength" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "StringLength_getJuncLength" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "StringLength_getJuncLength" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (double)(arg1)->getJuncLength(*arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringLength_getJuncLength__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringLength *arg1 = (Pythia8::StringLength *) 0 ;
  Pythia8::Vec4 arg2 ;
  Pythia8::Vec4 arg3 ;
  Pythia8::Vec4 arg4 ;
  Pythia8::Vec4 arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:StringLength_getJuncLength",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringLength, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringLength_getJuncLength" "', argument " "1"" of type '" "Pythia8::StringLength *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringLength * >(argp1);
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringLength_getJuncLength" "', argument " "2"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringLength_getJuncLength" "', argument " "2"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringLength_getJuncLength" "', argument " "3"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringLength_getJuncLength" "', argument " "3"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StringLength_getJuncLength" "', argument " "4"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringLength_getJuncLength" "', argument " "4"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "StringLength_getJuncLength" "', argument " "5"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringLength_getJuncLength" "', argument " "5"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  result = (double)(arg1)->getJuncLength(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringLength_getJuncLength(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringLength, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_StringLength_getJuncLength__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringLength, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_StringLength_getJuncLength__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringLength, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_StringLength_getJuncLength__SWIG_3(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__StringLength, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_StringLength_getJuncLength__SWIG_2(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'StringLength_getJuncLength'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::StringLength::getJuncLength(Pythia8::Event &,int,int,int)\n"
    "    Pythia8::StringLength::getJuncLength(Pythia8::Vec4,Pythia8::Vec4,Pythia8::Vec4)\n"
    "    Pythia8::StringLength::getJuncLength(Pythia8::Event &,int,int,int,int)\n"
    "    Pythia8::StringLength::getJuncLength(Pythia8::Vec4,Pythia8::Vec4,Pythia8::Vec4,Pythia8::Vec4)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_StringLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringLength *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_StringLength")) SWIG_fail;
  result = (Pythia8::StringLength *)new Pythia8::StringLength();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__StringLength, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StringLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::StringLength *arg1 = (Pythia8::StringLength *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_StringLength",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__StringLength, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StringLength" "', argument " "1"" of type '" "Pythia8::StringLength *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::StringLength * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StringLength_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__StringLength, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TimeDipoleEnd__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TimeDipoleEnd")) SWIG_fail;
  result = (Pythia8::TimeDipoleEnd *)new Pythia8::TimeDipoleEnd();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TimeDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeDipoleEnd__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int arg10 ;
  int arg11 ;
  int arg12 ;
  bool arg13 ;
  bool arg14 ;
  int arg15 ;
  double arg16 ;
  bool arg17 ;
  bool arg18 ;
  bool arg19 ;
  bool arg20 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  bool val19 ;
  int ecode19 = 0 ;
  bool val20 ;
  int ecode20 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  Pythia8::TimeDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOO:new_TimeDipoleEnd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeDipoleEnd" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TimeDipoleEnd" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_TimeDipoleEnd" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_TimeDipoleEnd" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_TimeDipoleEnd" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_TimeDipoleEnd" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_TimeDipoleEnd" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_TimeDipoleEnd" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_TimeDipoleEnd" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_TimeDipoleEnd" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_TimeDipoleEnd" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_int(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_TimeDipoleEnd" "', argument " "15"" of type '" "int""'");
  } 
  arg15 = static_cast< int >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_TimeDipoleEnd" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_TimeDipoleEnd" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_bool(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "new_TimeDipoleEnd" "', argument " "18"" of type '" "bool""'");
  } 
  arg18 = static_cast< bool >(val18);
  ecode19 = SWIG_AsVal_bool(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "new_TimeDipoleEnd" "', argument " "19"" of type '" "bool""'");
  } 
  arg19 = static_cast< bool >(val19);
  ecode20 = SWIG_AsVal_bool(obj19, &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "new_TimeDipoleEnd" "', argument " "20"" of type '" "bool""'");
  } 
  arg20 = static_cast< bool >(val20);
  result = (Pythia8::TimeDipoleEnd *)new Pythia8::TimeDipoleEnd(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TimeDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeDipoleEnd__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int arg10 ;
  int arg11 ;
  int arg12 ;
  bool arg13 ;
  bool arg14 ;
  int arg15 ;
  double arg16 ;
  bool arg17 ;
  bool arg18 ;
  bool arg19 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  bool val19 ;
  int ecode19 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  Pythia8::TimeDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOO:new_TimeDipoleEnd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeDipoleEnd" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TimeDipoleEnd" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_TimeDipoleEnd" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_TimeDipoleEnd" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_TimeDipoleEnd" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_TimeDipoleEnd" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_TimeDipoleEnd" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_TimeDipoleEnd" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_TimeDipoleEnd" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_TimeDipoleEnd" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_TimeDipoleEnd" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_int(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_TimeDipoleEnd" "', argument " "15"" of type '" "int""'");
  } 
  arg15 = static_cast< int >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_TimeDipoleEnd" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_TimeDipoleEnd" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_bool(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "new_TimeDipoleEnd" "', argument " "18"" of type '" "bool""'");
  } 
  arg18 = static_cast< bool >(val18);
  ecode19 = SWIG_AsVal_bool(obj18, &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "new_TimeDipoleEnd" "', argument " "19"" of type '" "bool""'");
  } 
  arg19 = static_cast< bool >(val19);
  result = (Pythia8::TimeDipoleEnd *)new Pythia8::TimeDipoleEnd(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TimeDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeDipoleEnd__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int arg10 ;
  int arg11 ;
  int arg12 ;
  bool arg13 ;
  bool arg14 ;
  int arg15 ;
  double arg16 ;
  bool arg17 ;
  bool arg18 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  Pythia8::TimeDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOO:new_TimeDipoleEnd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeDipoleEnd" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TimeDipoleEnd" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_TimeDipoleEnd" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_TimeDipoleEnd" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_TimeDipoleEnd" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_TimeDipoleEnd" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_TimeDipoleEnd" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_TimeDipoleEnd" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_TimeDipoleEnd" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_TimeDipoleEnd" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_TimeDipoleEnd" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_int(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_TimeDipoleEnd" "', argument " "15"" of type '" "int""'");
  } 
  arg15 = static_cast< int >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_TimeDipoleEnd" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_TimeDipoleEnd" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_bool(obj17, &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "new_TimeDipoleEnd" "', argument " "18"" of type '" "bool""'");
  } 
  arg18 = static_cast< bool >(val18);
  result = (Pythia8::TimeDipoleEnd *)new Pythia8::TimeDipoleEnd(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TimeDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeDipoleEnd__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int arg10 ;
  int arg11 ;
  int arg12 ;
  bool arg13 ;
  bool arg14 ;
  int arg15 ;
  double arg16 ;
  bool arg17 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  Pythia8::TimeDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:new_TimeDipoleEnd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeDipoleEnd" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TimeDipoleEnd" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_TimeDipoleEnd" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_TimeDipoleEnd" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_TimeDipoleEnd" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_TimeDipoleEnd" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_TimeDipoleEnd" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_TimeDipoleEnd" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_TimeDipoleEnd" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_TimeDipoleEnd" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_TimeDipoleEnd" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_int(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_TimeDipoleEnd" "', argument " "15"" of type '" "int""'");
  } 
  arg15 = static_cast< int >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_TimeDipoleEnd" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  ecode17 = SWIG_AsVal_bool(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_TimeDipoleEnd" "', argument " "17"" of type '" "bool""'");
  } 
  arg17 = static_cast< bool >(val17);
  result = (Pythia8::TimeDipoleEnd *)new Pythia8::TimeDipoleEnd(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TimeDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeDipoleEnd__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int arg10 ;
  int arg11 ;
  int arg12 ;
  bool arg13 ;
  bool arg14 ;
  int arg15 ;
  double arg16 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  Pythia8::TimeDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:new_TimeDipoleEnd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeDipoleEnd" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TimeDipoleEnd" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_TimeDipoleEnd" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_TimeDipoleEnd" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_TimeDipoleEnd" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_TimeDipoleEnd" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_TimeDipoleEnd" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_TimeDipoleEnd" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_TimeDipoleEnd" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_TimeDipoleEnd" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_TimeDipoleEnd" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_int(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_TimeDipoleEnd" "', argument " "15"" of type '" "int""'");
  } 
  arg15 = static_cast< int >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_TimeDipoleEnd" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  result = (Pythia8::TimeDipoleEnd *)new Pythia8::TimeDipoleEnd(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TimeDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeDipoleEnd__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int arg10 ;
  int arg11 ;
  int arg12 ;
  bool arg13 ;
  bool arg14 ;
  int arg15 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  Pythia8::TimeDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:new_TimeDipoleEnd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeDipoleEnd" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TimeDipoleEnd" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_TimeDipoleEnd" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_TimeDipoleEnd" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_TimeDipoleEnd" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_TimeDipoleEnd" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_TimeDipoleEnd" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_TimeDipoleEnd" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_TimeDipoleEnd" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_TimeDipoleEnd" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_TimeDipoleEnd" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_int(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_TimeDipoleEnd" "', argument " "15"" of type '" "int""'");
  } 
  arg15 = static_cast< int >(val15);
  result = (Pythia8::TimeDipoleEnd *)new Pythia8::TimeDipoleEnd(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TimeDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeDipoleEnd__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int arg10 ;
  int arg11 ;
  int arg12 ;
  bool arg13 ;
  bool arg14 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  Pythia8::TimeDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:new_TimeDipoleEnd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeDipoleEnd" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TimeDipoleEnd" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_TimeDipoleEnd" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_TimeDipoleEnd" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_TimeDipoleEnd" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_TimeDipoleEnd" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_TimeDipoleEnd" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_TimeDipoleEnd" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_TimeDipoleEnd" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_TimeDipoleEnd" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_TimeDipoleEnd" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  result = (Pythia8::TimeDipoleEnd *)new Pythia8::TimeDipoleEnd(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TimeDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeDipoleEnd__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int arg10 ;
  int arg11 ;
  int arg12 ;
  bool arg13 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  Pythia8::TimeDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:new_TimeDipoleEnd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeDipoleEnd" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TimeDipoleEnd" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_TimeDipoleEnd" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_TimeDipoleEnd" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_TimeDipoleEnd" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_TimeDipoleEnd" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_TimeDipoleEnd" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_TimeDipoleEnd" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_TimeDipoleEnd" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_TimeDipoleEnd" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  result = (Pythia8::TimeDipoleEnd *)new Pythia8::TimeDipoleEnd(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TimeDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeDipoleEnd__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int arg10 ;
  int arg11 ;
  int arg12 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  Pythia8::TimeDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:new_TimeDipoleEnd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeDipoleEnd" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TimeDipoleEnd" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_TimeDipoleEnd" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_TimeDipoleEnd" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_TimeDipoleEnd" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_TimeDipoleEnd" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_TimeDipoleEnd" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_TimeDipoleEnd" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_TimeDipoleEnd" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  result = (Pythia8::TimeDipoleEnd *)new Pythia8::TimeDipoleEnd(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TimeDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeDipoleEnd__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int arg10 ;
  int arg11 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  Pythia8::TimeDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:new_TimeDipoleEnd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeDipoleEnd" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TimeDipoleEnd" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_TimeDipoleEnd" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_TimeDipoleEnd" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_TimeDipoleEnd" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_TimeDipoleEnd" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_TimeDipoleEnd" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_TimeDipoleEnd" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  result = (Pythia8::TimeDipoleEnd *)new Pythia8::TimeDipoleEnd(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TimeDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeDipoleEnd__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int arg10 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  Pythia8::TimeDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:new_TimeDipoleEnd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeDipoleEnd" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TimeDipoleEnd" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_TimeDipoleEnd" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_TimeDipoleEnd" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_TimeDipoleEnd" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_TimeDipoleEnd" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_TimeDipoleEnd" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  result = (Pythia8::TimeDipoleEnd *)new Pythia8::TimeDipoleEnd(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TimeDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeDipoleEnd__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  Pythia8::TimeDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_TimeDipoleEnd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeDipoleEnd" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TimeDipoleEnd" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_TimeDipoleEnd" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_TimeDipoleEnd" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_TimeDipoleEnd" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_TimeDipoleEnd" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  result = (Pythia8::TimeDipoleEnd *)new Pythia8::TimeDipoleEnd(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TimeDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeDipoleEnd__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  Pythia8::TimeDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:new_TimeDipoleEnd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeDipoleEnd" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TimeDipoleEnd" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_TimeDipoleEnd" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_TimeDipoleEnd" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_TimeDipoleEnd" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  result = (Pythia8::TimeDipoleEnd *)new Pythia8::TimeDipoleEnd(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TimeDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeDipoleEnd__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Pythia8::TimeDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_TimeDipoleEnd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeDipoleEnd" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TimeDipoleEnd" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_TimeDipoleEnd" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_TimeDipoleEnd" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  result = (Pythia8::TimeDipoleEnd *)new Pythia8::TimeDipoleEnd(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TimeDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeDipoleEnd__SWIG_15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::TimeDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_TimeDipoleEnd",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeDipoleEnd" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TimeDipoleEnd" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_TimeDipoleEnd" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (Pythia8::TimeDipoleEnd *)new Pythia8::TimeDipoleEnd(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TimeDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeDipoleEnd__SWIG_16(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::TimeDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_TimeDipoleEnd",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeDipoleEnd" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TimeDipoleEnd" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (Pythia8::TimeDipoleEnd *)new Pythia8::TimeDipoleEnd(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TimeDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeDipoleEnd__SWIG_17(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::TimeDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_TimeDipoleEnd",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeDipoleEnd" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDipoleEnd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (Pythia8::TimeDipoleEnd *)new Pythia8::TimeDipoleEnd(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TimeDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeDipoleEnd__SWIG_18(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::TimeDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_TimeDipoleEnd",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeDipoleEnd" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (Pythia8::TimeDipoleEnd *)new Pythia8::TimeDipoleEnd(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TimeDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeDipoleEnd__SWIG_19(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::TimeDipoleEnd *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_TimeDipoleEnd",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeDipoleEnd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeDipoleEnd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::TimeDipoleEnd *)new Pythia8::TimeDipoleEnd(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TimeDipoleEnd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TimeDipoleEnd(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[21] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 20) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_TimeDipoleEnd__SWIG_0(self, args);
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TimeDipoleEnd__SWIG_19(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_TimeDipoleEnd__SWIG_18(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_TimeDipoleEnd__SWIG_17(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_TimeDipoleEnd__SWIG_16(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_TimeDipoleEnd__SWIG_15(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_TimeDipoleEnd__SWIG_14(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_TimeDipoleEnd__SWIG_13(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_TimeDipoleEnd__SWIG_12(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_TimeDipoleEnd__SWIG_11(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_TimeDipoleEnd__SWIG_10(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_TimeDipoleEnd__SWIG_9(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_new_TimeDipoleEnd__SWIG_8(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_new_TimeDipoleEnd__SWIG_7(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_int(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_new_TimeDipoleEnd__SWIG_6(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_int(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_new_TimeDipoleEnd__SWIG_5(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_int(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_new_TimeDipoleEnd__SWIG_4(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_int(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_new_TimeDipoleEnd__SWIG_3(self, args);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_int(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_bool(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          return _wrap_new_TimeDipoleEnd__SWIG_2(self, args);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 20) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_int(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_double(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_bool(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_bool(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            return _wrap_new_TimeDipoleEnd__SWIG_1(self, args);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TimeDipoleEnd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::TimeDipoleEnd::TimeDipoleEnd()\n"
    "    Pythia8::TimeDipoleEnd::TimeDipoleEnd(int,int,double,int,int,int,int,int,int,int,int,int,bool,bool,int,double,bool,bool,bool,bool)\n"
    "    Pythia8::TimeDipoleEnd::TimeDipoleEnd(int,int,double,int,int,int,int,int,int,int,int,int,bool,bool,int,double,bool,bool,bool)\n"
    "    Pythia8::TimeDipoleEnd::TimeDipoleEnd(int,int,double,int,int,int,int,int,int,int,int,int,bool,bool,int,double,bool,bool)\n"
    "    Pythia8::TimeDipoleEnd::TimeDipoleEnd(int,int,double,int,int,int,int,int,int,int,int,int,bool,bool,int,double,bool)\n"
    "    Pythia8::TimeDipoleEnd::TimeDipoleEnd(int,int,double,int,int,int,int,int,int,int,int,int,bool,bool,int,double)\n"
    "    Pythia8::TimeDipoleEnd::TimeDipoleEnd(int,int,double,int,int,int,int,int,int,int,int,int,bool,bool,int)\n"
    "    Pythia8::TimeDipoleEnd::TimeDipoleEnd(int,int,double,int,int,int,int,int,int,int,int,int,bool,bool)\n"
    "    Pythia8::TimeDipoleEnd::TimeDipoleEnd(int,int,double,int,int,int,int,int,int,int,int,int,bool)\n"
    "    Pythia8::TimeDipoleEnd::TimeDipoleEnd(int,int,double,int,int,int,int,int,int,int,int,int)\n"
    "    Pythia8::TimeDipoleEnd::TimeDipoleEnd(int,int,double,int,int,int,int,int,int,int,int)\n"
    "    Pythia8::TimeDipoleEnd::TimeDipoleEnd(int,int,double,int,int,int,int,int,int,int)\n"
    "    Pythia8::TimeDipoleEnd::TimeDipoleEnd(int,int,double,int,int,int,int,int,int)\n"
    "    Pythia8::TimeDipoleEnd::TimeDipoleEnd(int,int,double,int,int,int,int,int)\n"
    "    Pythia8::TimeDipoleEnd::TimeDipoleEnd(int,int,double,int,int,int,int)\n"
    "    Pythia8::TimeDipoleEnd::TimeDipoleEnd(int,int,double,int,int,int)\n"
    "    Pythia8::TimeDipoleEnd::TimeDipoleEnd(int,int,double,int,int)\n"
    "    Pythia8::TimeDipoleEnd::TimeDipoleEnd(int,int,double,int)\n"
    "    Pythia8::TimeDipoleEnd::TimeDipoleEnd(int,int,double)\n"
    "    Pythia8::TimeDipoleEnd::TimeDipoleEnd(int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_iRadiator_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_iRadiator_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_iRadiator_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_iRadiator_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iRadiator = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_iRadiator_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_iRadiator_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_iRadiator_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (int) ((arg1)->iRadiator);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_iRecoiler_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_iRecoiler_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_iRecoiler_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_iRecoiler_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iRecoiler = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_iRecoiler_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_iRecoiler_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_iRecoiler_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (int) ((arg1)->iRecoiler);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_pTmax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_pTmax_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_pTmax_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_pTmax_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pTmax = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_pTmax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_pTmax_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_pTmax_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (double) ((arg1)->pTmax);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_colType_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_colType_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_colType_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_colType_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->colType = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_colType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_colType_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_colType_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (int) ((arg1)->colType);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_chgType_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_chgType_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_chgType_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_chgType_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->chgType = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_chgType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_chgType_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_chgType_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (int) ((arg1)->chgType);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_gamType_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_gamType_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_gamType_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_gamType_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->gamType = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_gamType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_gamType_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_gamType_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (int) ((arg1)->gamType);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_weakType_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_weakType_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_weakType_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_weakType_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->weakType = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_weakType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_weakType_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_weakType_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (int) ((arg1)->weakType);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_isrType_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_isrType_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_isrType_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_isrType_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->isrType = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_isrType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_isrType_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_isrType_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (int) ((arg1)->isrType);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_system_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_system_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_system_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_system_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->system = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_system_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_system_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_system_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (int) ((arg1)->system);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_systemRec_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_systemRec_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_systemRec_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_systemRec_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->systemRec = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_systemRec_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_systemRec_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_systemRec_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (int) ((arg1)->systemRec);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_MEtype_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_MEtype_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_MEtype_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_MEtype_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->MEtype = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_MEtype_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_MEtype_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_MEtype_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (int) ((arg1)->MEtype);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_iMEpartner_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_iMEpartner_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_iMEpartner_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_iMEpartner_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iMEpartner = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_iMEpartner_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_iMEpartner_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_iMEpartner_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (int) ((arg1)->iMEpartner);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_weakPol_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_weakPol_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_weakPol_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_weakPol_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->weakPol = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_weakPol_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_weakPol_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_weakPol_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (int) ((arg1)->weakPol);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_isOctetOnium_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_isOctetOnium_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_isOctetOnium_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_isOctetOnium_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isOctetOnium = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_isOctetOnium_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_isOctetOnium_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_isOctetOnium_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (bool) ((arg1)->isOctetOnium);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_isHiddenValley_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_isHiddenValley_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_isHiddenValley_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_isHiddenValley_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isHiddenValley = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_isHiddenValley_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_isHiddenValley_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_isHiddenValley_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (bool) ((arg1)->isHiddenValley);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_colvType_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_colvType_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_colvType_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_colvType_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->colvType = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_colvType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_colvType_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_colvType_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (int) ((arg1)->colvType);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_MEmix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_MEmix_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_MEmix_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_MEmix_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->MEmix = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_MEmix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_MEmix_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_MEmix_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (double) ((arg1)->MEmix);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_MEorder_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_MEorder_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_MEorder_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_MEorder_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->MEorder = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_MEorder_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_MEorder_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_MEorder_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (bool) ((arg1)->MEorder);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_MEsplit_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_MEsplit_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_MEsplit_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_MEsplit_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->MEsplit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_MEsplit_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_MEsplit_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_MEsplit_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (bool) ((arg1)->MEsplit);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_MEgluinoRec_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_MEgluinoRec_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_MEgluinoRec_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_MEgluinoRec_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->MEgluinoRec = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_MEgluinoRec_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_MEgluinoRec_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_MEgluinoRec_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (bool) ((arg1)->MEgluinoRec);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_isFlexible_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_isFlexible_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_isFlexible_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_isFlexible_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isFlexible = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_isFlexible_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_isFlexible_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_isFlexible_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (bool) ((arg1)->isFlexible);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_flavour_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_flavour_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_flavour_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_flavour_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->flavour = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_flavour_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_flavour_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_flavour_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (int) ((arg1)->flavour);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_iAunt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_iAunt_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_iAunt_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_iAunt_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iAunt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_iAunt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_iAunt_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_iAunt_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (int) ((arg1)->iAunt);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_mRad_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_mRad_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_mRad_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_mRad_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->mRad = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_mRad_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_mRad_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_mRad_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (double) ((arg1)->mRad);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_m2Rad_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_m2Rad_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_m2Rad_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_m2Rad_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->m2Rad = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_m2Rad_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_m2Rad_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_m2Rad_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (double) ((arg1)->m2Rad);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_mRec_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_mRec_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_mRec_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_mRec_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->mRec = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_mRec_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_mRec_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_mRec_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (double) ((arg1)->mRec);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_m2Rec_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_m2Rec_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_m2Rec_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_m2Rec_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->m2Rec = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_m2Rec_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_m2Rec_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_m2Rec_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (double) ((arg1)->m2Rec);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_mDip_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_mDip_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_mDip_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_mDip_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->mDip = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_mDip_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_mDip_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_mDip_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (double) ((arg1)->mDip);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_m2Dip_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_m2Dip_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_m2Dip_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_m2Dip_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->m2Dip = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_m2Dip_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_m2Dip_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_m2Dip_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (double) ((arg1)->m2Dip);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_m2DipCorr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_m2DipCorr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_m2DipCorr_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_m2DipCorr_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->m2DipCorr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_m2DipCorr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_m2DipCorr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_m2DipCorr_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (double) ((arg1)->m2DipCorr);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_pT2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_pT2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_pT2_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_pT2_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pT2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_pT2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_pT2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_pT2_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (double) ((arg1)->pT2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_m2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_m2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_m2_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_m2_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->m2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_m2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_m2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_m2_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (double) ((arg1)->m2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_z_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_z_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_z_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_z_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->z = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_z_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_z_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_z_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (double) ((arg1)->z);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_mFlavour_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_mFlavour_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_mFlavour_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_mFlavour_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->mFlavour = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_mFlavour_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_mFlavour_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_mFlavour_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (double) ((arg1)->mFlavour);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_asymPol_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_asymPol_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_asymPol_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_asymPol_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->asymPol = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_asymPol_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_asymPol_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_asymPol_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (double) ((arg1)->asymPol);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_flexFactor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_flexFactor_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_flexFactor_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_flexFactor_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->flexFactor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_flexFactor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_flexFactor_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_flexFactor_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (double) ((arg1)->flexFactor);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_pAccept_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeDipoleEnd_pAccept_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_pAccept_set" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDipoleEnd_pAccept_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pAccept = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeDipoleEnd_pAccept_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeDipoleEnd_pAccept_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDipoleEnd_pAccept_get" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  result = (double) ((arg1)->pAccept);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TimeDipoleEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeDipoleEnd *arg1 = (Pythia8::TimeDipoleEnd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TimeDipoleEnd",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeDipoleEnd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeDipoleEnd" "', argument " "1"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TimeDipoleEnd_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__TimeDipoleEnd, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TimeShower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::TimeShower *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TimeShower",&obj0)) SWIG_fail;
  arg1 = obj0;
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (Pythia8::TimeShower *)new SwigDirector_TimeShower(arg1); 
  } else {
    result = (Pythia8::TimeShower *)new Pythia8::TimeShower(); 
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TimeShower, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TimeShower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TimeShower",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeShower" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_initPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = (Pythia8::Settings *) 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  Pythia8::CoupSM *arg6 = (Pythia8::CoupSM *) 0 ;
  Pythia8::PartonSystems *arg7 = (Pythia8::PartonSystems *) 0 ;
  Pythia8::UserHooks *arg8 = (Pythia8::UserHooks *) 0 ;
  Pythia8::MergingHooks *arg9 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::PartonVertex *arg10 = (Pythia8::PartonVertex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:TimeShower_initPtr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_initPtr" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_initPtr" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeShower_initPtr" "', argument " "3"" of type '" "Pythia8::Settings *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TimeShower_initPtr" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TimeShower_initPtr" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TimeShower_initPtr" "', argument " "6"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::CoupSM * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "TimeShower_initPtr" "', argument " "7"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::PartonSystems * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "TimeShower_initPtr" "', argument " "8"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::UserHooks * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "TimeShower_initPtr" "', argument " "9"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::MergingHooks * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_Pythia8__PartonVertex, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "TimeShower_initPtr" "', argument " "10"" of type '" "Pythia8::PartonVertex *""'"); 
  }
  arg10 = reinterpret_cast< Pythia8::PartonVertex * >(argp10);
  (arg1)->initPtr(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_init__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::BeamParticle *arg2 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg3 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TimeShower_init",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_init" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_init" "', argument " "2"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::BeamParticle * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeShower_init" "', argument " "3"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::BeamParticle * >(argp3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::TimeShower::init(arg2,arg3);
    } else {
      (arg1)->init(arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_init__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::BeamParticle *arg2 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeShower_init",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_init" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_init" "', argument " "2"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::BeamParticle * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::TimeShower::init(arg2);
    } else {
      (arg1)->init(arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_init__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeShower_init",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_init" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::TimeShower::init();
    } else {
      (arg1)->init();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_init(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__TimeShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TimeShower_init__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__TimeShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TimeShower_init__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__TimeShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_TimeShower_init__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TimeShower_init'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::TimeShower::init(Pythia8::BeamParticle *,Pythia8::BeamParticle *)\n"
    "    Pythia8::TimeShower::init(Pythia8::BeamParticle *)\n"
    "    Pythia8::TimeShower::init()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TimeShower_reassignBeamPtrs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::BeamParticle *arg2 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg3 = (Pythia8::BeamParticle *) 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:TimeShower_reassignBeamPtrs",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_reassignBeamPtrs" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_reassignBeamPtrs" "', argument " "2"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::BeamParticle * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeShower_reassignBeamPtrs" "', argument " "3"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::BeamParticle * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TimeShower_reassignBeamPtrs" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->reassignBeamPtrs(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_reassignBeamPtrs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::BeamParticle *arg2 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg3 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TimeShower_reassignBeamPtrs",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_reassignBeamPtrs" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_reassignBeamPtrs" "', argument " "2"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::BeamParticle * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeShower_reassignBeamPtrs" "', argument " "3"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::BeamParticle * >(argp3);
  (arg1)->reassignBeamPtrs(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_reassignBeamPtrs(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__TimeShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_TimeShower_reassignBeamPtrs__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__TimeShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__BeamParticle, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TimeShower_reassignBeamPtrs__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TimeShower_reassignBeamPtrs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::TimeShower::reassignBeamPtrs(Pythia8::BeamParticle *,Pythia8::BeamParticle *,int)\n"
    "    Pythia8::TimeShower::reassignBeamPtrs(Pythia8::BeamParticle *,Pythia8::BeamParticle *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TimeShower_limitPTmax__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:TimeShower_limitPTmax",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_limitPTmax" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_limitPTmax" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeShower_limitPTmax" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimeShower_limitPTmax" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TimeShower_limitPTmax" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::TimeShower::limitPTmax(*arg2,arg3,arg4);
    } else {
      result = (bool)(arg1)->limitPTmax(*arg2,arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_limitPTmax__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TimeShower_limitPTmax",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_limitPTmax" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_limitPTmax" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeShower_limitPTmax" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimeShower_limitPTmax" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::TimeShower::limitPTmax(*arg2,arg3);
    } else {
      result = (bool)(arg1)->limitPTmax(*arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_limitPTmax__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeShower_limitPTmax",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_limitPTmax" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_limitPTmax" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeShower_limitPTmax" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::TimeShower::limitPTmax(*arg2);
    } else {
      result = (bool)(arg1)->limitPTmax(*arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_limitPTmax(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__TimeShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TimeShower_limitPTmax__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__TimeShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TimeShower_limitPTmax__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__TimeShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TimeShower_limitPTmax__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TimeShower_limitPTmax'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::TimeShower::limitPTmax(Pythia8::Event &,double,double)\n"
    "    Pythia8::TimeShower::limitPTmax(Pythia8::Event &,double)\n"
    "    Pythia8::TimeShower::limitPTmax(Pythia8::Event &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TimeShower_enhancePTmax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeShower_enhancePTmax",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_enhancePTmax" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::TimeShower::enhancePTmax();
    } else {
      result = (double)(arg1)->enhancePTmax();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_shower__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  int arg2 ;
  int arg3 ;
  Pythia8::Event *arg4 = 0 ;
  double arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:TimeShower_shower",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_shower" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeShower_shower" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimeShower_shower" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TimeShower_shower" "', argument " "4"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeShower_shower" "', argument " "4"" of type '" "Pythia8::Event &""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Event * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TimeShower_shower" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TimeShower_shower" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Pythia8::TimeShower::shower(arg2,arg3,*arg4,arg5,arg6);
    } else {
      result = (int)(arg1)->shower(arg2,arg3,*arg4,arg5,arg6);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_shower__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  int arg2 ;
  int arg3 ;
  Pythia8::Event *arg4 = 0 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:TimeShower_shower",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_shower" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeShower_shower" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimeShower_shower" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TimeShower_shower" "', argument " "4"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeShower_shower" "', argument " "4"" of type '" "Pythia8::Event &""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Event * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TimeShower_shower" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Pythia8::TimeShower::shower(arg2,arg3,*arg4,arg5);
    } else {
      result = (int)(arg1)->shower(arg2,arg3,*arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_shower(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__TimeShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_TimeShower_shower__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__TimeShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_TimeShower_shower__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TimeShower_shower'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::TimeShower::shower(int,int,Pythia8::Event &,double,int)\n"
    "    Pythia8::TimeShower::shower(int,int,Pythia8::Event &,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TimeShower_showerQED(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  int arg2 ;
  int arg3 ;
  Pythia8::Event *arg4 = 0 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:TimeShower_showerQED",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_showerQED" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeShower_showerQED" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimeShower_showerQED" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TimeShower_showerQED" "', argument " "4"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeShower_showerQED" "', argument " "4"" of type '" "Pythia8::Event &""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Event * >(argp4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TimeShower_showerQED" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)(arg1)->Pythia8::TimeShower::showerQED(arg2,arg3,*arg4,arg5);
    } else {
      result = (int)(arg1)->showerQED(arg2,arg3,*arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_pTLastInShower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeShower_pTLastInShower",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_pTLastInShower" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  result = (double)(arg1)->pTLastInShower();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_prepareGlobal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeShower_prepareGlobal",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_prepareGlobal" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_prepareGlobal" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeShower_prepareGlobal" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::TimeShower::prepareGlobal(*arg2);
    } else {
      (arg1)->prepareGlobal(*arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_prepare__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:TimeShower_prepare",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_prepare" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeShower_prepare" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeShower_prepare" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeShower_prepare" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TimeShower_prepare" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::TimeShower::prepare(arg2,*arg3,arg4);
    } else {
      (arg1)->prepare(arg2,*arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_prepare__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TimeShower_prepare",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_prepare" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeShower_prepare" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeShower_prepare" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeShower_prepare" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::TimeShower::prepare(arg2,*arg3);
    } else {
      (arg1)->prepare(arg2,*arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_prepare(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__TimeShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_TimeShower_prepare__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__TimeShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TimeShower_prepare__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TimeShower_prepare'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::TimeShower::prepare(int,Pythia8::Event &,bool)\n"
    "    Pythia8::TimeShower::prepare(int,Pythia8::Event &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TimeShower_rescatterUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TimeShower_rescatterUpdate",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_rescatterUpdate" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeShower_rescatterUpdate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeShower_rescatterUpdate" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeShower_rescatterUpdate" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::TimeShower::rescatterUpdate(arg2,*arg3);
    } else {
      (arg1)->rescatterUpdate(arg2,*arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_update__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:TimeShower_update",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_update" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeShower_update" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeShower_update" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeShower_update" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TimeShower_update" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::TimeShower::update(arg2,*arg3,arg4);
    } else {
      (arg1)->update(arg2,*arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_update__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TimeShower_update",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_update" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeShower_update" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeShower_update" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeShower_update" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      (arg1)->Pythia8::TimeShower::update(arg2,*arg3);
    } else {
      (arg1)->update(arg2,*arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_update(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__TimeShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_TimeShower_update__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__TimeShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TimeShower_update__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TimeShower_update'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::TimeShower::update(int,Pythia8::Event &,bool)\n"
    "    Pythia8::TimeShower::update(int,Pythia8::Event &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TimeShower_pTnext__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  bool arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:TimeShower_pTnext",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_pTnext" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_pTnext" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeShower_pTnext" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimeShower_pTnext" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TimeShower_pTnext" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TimeShower_pTnext" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TimeShower_pTnext" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::TimeShower::pTnext(*arg2,arg3,arg4,arg5,arg6);
    } else {
      result = (double)(arg1)->pTnext(*arg2,arg3,arg4,arg5,arg6);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_pTnext__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:TimeShower_pTnext",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_pTnext" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_pTnext" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeShower_pTnext" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimeShower_pTnext" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TimeShower_pTnext" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TimeShower_pTnext" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::TimeShower::pTnext(*arg2,arg3,arg4,arg5);
    } else {
      result = (double)(arg1)->pTnext(*arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_pTnext__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:TimeShower_pTnext",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_pTnext" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_pTnext" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeShower_pTnext" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimeShower_pTnext" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TimeShower_pTnext" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::TimeShower::pTnext(*arg2,arg3,arg4);
    } else {
      result = (double)(arg1)->pTnext(*arg2,arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_pTnext(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__TimeShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TimeShower_pTnext__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__TimeShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_TimeShower_pTnext__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__TimeShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_TimeShower_pTnext__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TimeShower_pTnext'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::TimeShower::pTnext(Pythia8::Event &,double,double,bool,bool)\n"
    "    Pythia8::TimeShower::pTnext(Pythia8::Event &,double,double,bool)\n"
    "    Pythia8::TimeShower::pTnext(Pythia8::Event &,double,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TimeShower_branch__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TimeShower_branch",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_branch" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_branch" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeShower_branch" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimeShower_branch" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::TimeShower::branch(*arg2,arg3);
    } else {
      result = (bool)(arg1)->branch(*arg2,arg3);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_branch__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeShower_branch",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_branch" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_branch" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeShower_branch" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::TimeShower::branch(*arg2);
    } else {
      result = (bool)(arg1)->branch(*arg2);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_branch(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__TimeShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TimeShower_branch__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__TimeShower, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TimeShower_branch__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'TimeShower_branch'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::TimeShower::branch(Pythia8::Event &,bool)\n"
    "    Pythia8::TimeShower::branch(Pythia8::Event &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TimeShower_initUncertainties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeShower_initUncertainties",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_initUncertainties" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  result = (bool)(arg1)->initUncertainties();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_calcUncertainties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  bool arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  Pythia8::TimeDipoleEnd *arg6 = (Pythia8::TimeDipoleEnd *) 0 ;
  Pythia8::Particle *arg7 = (Pythia8::Particle *) 0 ;
  Pythia8::Particle *arg8 = (Pythia8::Particle *) 0 ;
  Pythia8::Particle *arg9 = (Pythia8::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:TimeShower_calcUncertainties",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_calcUncertainties" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeShower_calcUncertainties" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimeShower_calcUncertainties" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TimeShower_calcUncertainties" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TimeShower_calcUncertainties" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__TimeDipoleEnd, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TimeShower_calcUncertainties" "', argument " "6"" of type '" "Pythia8::TimeDipoleEnd *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::TimeDipoleEnd * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "TimeShower_calcUncertainties" "', argument " "7"" of type '" "Pythia8::Particle *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::Particle * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "TimeShower_calcUncertainties" "', argument " "8"" of type '" "Pythia8::Particle *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::Particle * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__Particle, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "TimeShower_calcUncertainties" "', argument " "9"" of type '" "Pythia8::Particle *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::Particle * >(argp9);
  (arg1)->calcUncertainties(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_system(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeShower_system",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_system" "', argument " "1"" of type '" "Pythia8::TimeShower const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (int)((Pythia8::TimeShower const *)arg1)->Pythia8::TimeShower::system();
    } else {
      result = (int)((Pythia8::TimeShower const *)arg1)->system();
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_getHasWeaklyRadiated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeShower_getHasWeaklyRadiated",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_getHasWeaklyRadiated" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  result = (bool)(arg1)->getHasWeaklyRadiated();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_clustered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  Pythia8::Event result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:TimeShower_clustered",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_clustered" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_clustered" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeShower_clustered" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimeShower_clustered" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TimeShower_clustered" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TimeShower_clustered" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TimeShower_clustered" "', argument " "6"" of type '" "std::string""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (arg1)->Pythia8::TimeShower::clustered((Pythia8::Event const &)*arg2,arg3,arg4,arg5,arg6);
    } else {
      result = (arg1)->clustered((Pythia8::Event const &)*arg2,arg3,arg4,arg5,arg6);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj((new Pythia8::Event(static_cast< const Pythia8::Event& >(result))), SWIGTYPE_p_Pythia8__Event, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_getStateVariables(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  SwigValueWrapper< std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:TimeShower_getStateVariables",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_getStateVariables" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_getStateVariables" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeShower_getStateVariables" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimeShower_getStateVariables" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TimeShower_getStateVariables" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TimeShower_getStateVariables" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TimeShower_getStateVariables" "', argument " "6"" of type '" "std::string""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (arg1)->Pythia8::TimeShower::getStateVariables((Pythia8::Event const &)*arg2,arg3,arg4,arg5,arg6);
    } else {
      result = (arg1)->getStateVariables((Pythia8::Event const &)*arg2,arg3,arg4,arg5,arg6);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_NewPointerObj((new std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > >(static_cast< const std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > >& >(result))), SWIGTYPE_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_isTimelike(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:TimeShower_isTimelike",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_isTimelike" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_isTimelike" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeShower_isTimelike" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimeShower_isTimelike" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TimeShower_isTimelike" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TimeShower_isTimelike" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TimeShower_isTimelike" "', argument " "6"" of type '" "std::string""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::TimeShower::isTimelike((Pythia8::Event const &)*arg2,arg3,arg4,arg5,arg6);
    } else {
      result = (bool)(arg1)->isTimelike((Pythia8::Event const &)*arg2,arg3,arg4,arg5,arg6);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_getSplittingName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:TimeShower_getSplittingName",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_getSplittingName" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_getSplittingName" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeShower_getSplittingName" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimeShower_getSplittingName" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TimeShower_getSplittingName" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TimeShower_getSplittingName" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (arg1)->Pythia8::TimeShower::getSplittingName((Pythia8::Event const &)*arg2,arg3,arg4,arg5);
    } else {
      result = (arg1)->getSplittingName((Pythia8::Event const &)*arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_getSplittingProb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  std::string arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:TimeShower_getSplittingProb",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_getSplittingProb" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_getSplittingProb" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeShower_getSplittingProb" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimeShower_getSplittingProb" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TimeShower_getSplittingProb" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "TimeShower_getSplittingProb" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj5, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TimeShower_getSplittingProb" "', argument " "6"" of type '" "std::string""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (double)(arg1)->Pythia8::TimeShower::getSplittingProb((Pythia8::Event const &)*arg2,arg3,arg4,arg5,arg6);
    } else {
      result = (double)(arg1)->getSplittingProb((Pythia8::Event const &)*arg2,arg3,arg4,arg5,arg6);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_allowedSplitting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:TimeShower_allowedSplitting",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_allowedSplitting" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_allowedSplitting" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeShower_allowedSplitting" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimeShower_allowedSplitting" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TimeShower_allowedSplitting" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::TimeShower::allowedSplitting((Pythia8::Event const &)*arg2,arg3,arg4);
    } else {
      result = (bool)(arg1)->allowedSplitting((Pythia8::Event const &)*arg2,arg3,arg4);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_getRecoilers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  std::string arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  std::vector< int,std::allocator< int > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:TimeShower_getRecoilers",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_getRecoilers" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_getRecoilers" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeShower_getRecoilers" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimeShower_getRecoilers" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TimeShower_getRecoilers" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "TimeShower_getRecoilers" "', argument " "5"" of type '" "std::string""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (arg1)->Pythia8::TimeShower::getRecoilers((Pythia8::Event const &)*arg2,arg3,arg4,arg5);
    } else {
      result = (arg1)->getRecoilers((Pythia8::Event const &)*arg2,arg3,arg4,arg5);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_mergingHooksPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::MergingHooks *arg2 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeShower_mergingHooksPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_mergingHooksPtr_set" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__MergingHooks, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_mergingHooksPtr_set" "', argument " "2"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::MergingHooks * >(argp2);
  if (arg1) (arg1)->mergingHooksPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_mergingHooksPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::MergingHooks *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeShower_mergingHooksPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_mergingHooksPtr_get" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  result = (Pythia8::MergingHooks *) ((arg1)->mergingHooksPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_infoPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeShower_infoPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_infoPtr_set" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_infoPtr_set" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  if (arg1) darg->infoPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_infoPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  Pythia8::Info *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeShower_infoPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_infoPtr_get" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  result = (Pythia8::Info *) (darg->infoPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_settingsPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::Settings *arg2 = (Pythia8::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeShower_settingsPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_settingsPtr_set" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Settings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_settingsPtr_set" "', argument " "2"" of type '" "Pythia8::Settings *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  if (arg1) darg->settingsPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_settingsPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  Pythia8::Settings *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeShower_settingsPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_settingsPtr_get" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  result = (Pythia8::Settings *) (darg->settingsPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_particleDataPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::ParticleData *arg2 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeShower_particleDataPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_particleDataPtr_set" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ParticleData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_particleDataPtr_set" "', argument " "2"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ParticleData * >(argp2);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  if (arg1) darg->particleDataPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_particleDataPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  Pythia8::ParticleData *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeShower_particleDataPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_particleDataPtr_get" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  result = (Pythia8::ParticleData *) (darg->particleDataPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_rndmPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::Rndm *arg2 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeShower_rndmPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_rndmPtr_set" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Rndm, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_rndmPtr_set" "', argument " "2"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Rndm * >(argp2);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  if (arg1) darg->rndmPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_rndmPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  Pythia8::Rndm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeShower_rndmPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_rndmPtr_get" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  result = (Pythia8::Rndm *) (darg->rndmPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_coupSMPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::CoupSM *arg2 = (Pythia8::CoupSM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeShower_coupSMPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_coupSMPtr_set" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__CoupSM, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_coupSMPtr_set" "', argument " "2"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::CoupSM * >(argp2);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  if (arg1) darg->coupSMPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_coupSMPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  Pythia8::CoupSM *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeShower_coupSMPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_coupSMPtr_get" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  result = (Pythia8::CoupSM *) (darg->coupSMPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_beamAPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::BeamParticle *arg2 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeShower_beamAPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_beamAPtr_set" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__BeamParticle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_beamAPtr_set" "', argument " "2"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::BeamParticle * >(argp2);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  if (arg1) darg->beamAPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_beamAPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  Pythia8::BeamParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeShower_beamAPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_beamAPtr_get" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  result = (Pythia8::BeamParticle *) (darg->beamAPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_beamBPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::BeamParticle *arg2 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeShower_beamBPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_beamBPtr_set" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__BeamParticle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_beamBPtr_set" "', argument " "2"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::BeamParticle * >(argp2);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  if (arg1) darg->beamBPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_beamBPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  Pythia8::BeamParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeShower_beamBPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_beamBPtr_get" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  result = (Pythia8::BeamParticle *) (darg->beamBPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_beamOffset_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeShower_beamOffset_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_beamOffset_set" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeShower_beamOffset_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  if (arg1) darg->beamOffset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_beamOffset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeShower_beamOffset_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_beamOffset_get" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  result = (int) (darg->beamOffset);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_partonSystemsPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::PartonSystems *arg2 = (Pythia8::PartonSystems *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeShower_partonSystemsPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_partonSystemsPtr_set" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PartonSystems, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_partonSystemsPtr_set" "', argument " "2"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PartonSystems * >(argp2);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  if (arg1) darg->partonSystemsPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_partonSystemsPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  Pythia8::PartonSystems *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeShower_partonSystemsPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_partonSystemsPtr_get" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  result = (Pythia8::PartonSystems *) (darg->partonSystemsPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_userHooksPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::UserHooks *arg2 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeShower_userHooksPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_userHooksPtr_set" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__UserHooks, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_userHooksPtr_set" "', argument " "2"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::UserHooks * >(argp2);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  if (arg1) darg->userHooksPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_userHooksPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  Pythia8::UserHooks *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeShower_userHooksPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_userHooksPtr_get" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  result = (Pythia8::UserHooks *) (darg->userHooksPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_partonVertexPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::PartonVertex *arg2 = (Pythia8::PartonVertex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeShower_partonVertexPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_partonVertexPtr_set" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PartonVertex, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_partonVertexPtr_set" "', argument " "2"" of type '" "Pythia8::PartonVertex *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PartonVertex * >(argp2);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  if (arg1) darg->partonVertexPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_partonVertexPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  Pythia8::PartonVertex *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeShower_partonVertexPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_partonVertexPtr_get" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  result = (Pythia8::PartonVertex *) (darg->partonVertexPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PartonVertex, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_weakShowerMEs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  Pythia8::WeakShowerMEs *arg2 = (Pythia8::WeakShowerMEs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeShower_weakShowerMEs_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_weakShowerMEs_set" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__WeakShowerMEs, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeShower_weakShowerMEs_set" "', argument " "2"" of type '" "Pythia8::WeakShowerMEs *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::WeakShowerMEs * >(argp2);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  if (arg1) darg->weakShowerMEs = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_weakShowerMEs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  Pythia8::WeakShowerMEs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeShower_weakShowerMEs_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_weakShowerMEs_get" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  result = (Pythia8::WeakShowerMEs *)& (darg->weakShowerMEs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__WeakShowerMEs, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_iSysSel_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeShower_iSysSel_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_iSysSel_set" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeShower_iSysSel_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  if (arg1) darg->iSysSel = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_iSysSel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeShower_iSysSel_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_iSysSel_get" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  result = (int) (darg->iSysSel);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_pTmaxFudge_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeShower_pTmaxFudge_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_pTmaxFudge_set" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeShower_pTmaxFudge_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  if (arg1) darg->pTmaxFudge = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_pTmaxFudge_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeShower_pTmaxFudge_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_pTmaxFudge_get" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  result = (double) (darg->pTmaxFudge);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_pTLastBranch_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TimeShower_pTLastBranch_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_pTLastBranch_set" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeShower_pTLastBranch_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  if (arg1) darg->pTLastBranch = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower_pTLastBranch_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigDirector_TimeShower *darg = 0;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeShower_pTLastBranch_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower_pTLastBranch_get" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  darg = dynamic_cast<SwigDirector_TimeShower *>(arg1);
  result = (double) (darg->pTLastBranch);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TimeShower___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TimeShower___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeShower___str__" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  result = Pythia8_TimeShower___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_TimeShower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TimeShower *arg1 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:disown_TimeShower",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_TimeShower" "', argument " "1"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TimeShower * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TimeShower_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__TimeShower, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ColourDipole__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  bool arg5 ;
  bool arg6 ;
  bool arg7 ;
  bool arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  Pythia8::ColourDipole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:new_ColourDipole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ColourDipole" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ColourDipole" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ColourDipole" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ColourDipole" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ColourDipole" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ColourDipole" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ColourDipole" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ColourDipole" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  result = (Pythia8::ColourDipole *)new Pythia8::ColourDipole(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ColourDipole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ColourDipole__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  bool arg5 ;
  bool arg6 ;
  bool arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Pythia8::ColourDipole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_ColourDipole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ColourDipole" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ColourDipole" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ColourDipole" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ColourDipole" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ColourDipole" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ColourDipole" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_bool(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ColourDipole" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  result = (Pythia8::ColourDipole *)new Pythia8::ColourDipole(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ColourDipole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ColourDipole__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  bool arg5 ;
  bool arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::ColourDipole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_ColourDipole",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ColourDipole" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ColourDipole" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ColourDipole" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ColourDipole" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ColourDipole" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ColourDipole" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  result = (Pythia8::ColourDipole *)new Pythia8::ColourDipole(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ColourDipole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ColourDipole__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  bool arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::ColourDipole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_ColourDipole",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ColourDipole" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ColourDipole" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ColourDipole" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ColourDipole" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ColourDipole" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (Pythia8::ColourDipole *)new Pythia8::ColourDipole(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ColourDipole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ColourDipole__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::ColourDipole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_ColourDipole",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ColourDipole" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ColourDipole" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ColourDipole" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ColourDipole" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (Pythia8::ColourDipole *)new Pythia8::ColourDipole(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ColourDipole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ColourDipole__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::ColourDipole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_ColourDipole",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ColourDipole" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ColourDipole" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ColourDipole" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::ColourDipole *)new Pythia8::ColourDipole(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ColourDipole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ColourDipole__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::ColourDipole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_ColourDipole",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ColourDipole" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ColourDipole" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::ColourDipole *)new Pythia8::ColourDipole(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ColourDipole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ColourDipole__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ColourDipole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ColourDipole",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ColourDipole" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::ColourDipole *)new Pythia8::ColourDipole(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ColourDipole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ColourDipole__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ColourDipole")) SWIG_fail;
  result = (Pythia8::ColourDipole *)new Pythia8::ColourDipole();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ColourDipole, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ColourDipole(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 8) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_ColourDipole__SWIG_8(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ColourDipole__SWIG_7(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ColourDipole__SWIG_6(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_ColourDipole__SWIG_5(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_ColourDipole__SWIG_4(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_ColourDipole__SWIG_3(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_ColourDipole__SWIG_2(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_ColourDipole__SWIG_1(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_ColourDipole__SWIG_0(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ColourDipole'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ColourDipole::ColourDipole(int,int,int,int,bool,bool,bool,bool)\n"
    "    Pythia8::ColourDipole::ColourDipole(int,int,int,int,bool,bool,bool)\n"
    "    Pythia8::ColourDipole::ColourDipole(int,int,int,int,bool,bool)\n"
    "    Pythia8::ColourDipole::ColourDipole(int,int,int,int,bool)\n"
    "    Pythia8::ColourDipole::ColourDipole(int,int,int,int)\n"
    "    Pythia8::ColourDipole::ColourDipole(int,int,int)\n"
    "    Pythia8::ColourDipole::ColourDipole(int,int)\n"
    "    Pythia8::ColourDipole::ColourDipole(int)\n"
    "    Pythia8::ColourDipole::ColourDipole()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ColourDipole_mDip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourDipole_mDip",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_mDip" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColourDipole_mDip" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ColourDipole_mDip" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (double)(arg1)->mDip(*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_col_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourDipole_col_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_col_set" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColourDipole_col_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->col = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_col_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourDipole_col_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_col_get" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  result = (int) ((arg1)->col);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_iCol_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourDipole_iCol_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_iCol_set" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColourDipole_iCol_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iCol = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_iCol_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourDipole_iCol_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_iCol_get" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  result = (int) ((arg1)->iCol);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_iAcol_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourDipole_iAcol_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_iAcol_set" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColourDipole_iAcol_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iAcol = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_iAcol_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourDipole_iAcol_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_iAcol_get" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  result = (int) ((arg1)->iAcol);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_iColLeg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourDipole_iColLeg_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_iColLeg_set" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColourDipole_iColLeg_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iColLeg = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_iColLeg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourDipole_iColLeg_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_iColLeg_get" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  result = (int) ((arg1)->iColLeg);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_iAcolLeg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourDipole_iAcolLeg_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_iAcolLeg_set" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColourDipole_iAcolLeg_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->iAcolLeg = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_iAcolLeg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourDipole_iAcolLeg_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_iAcolLeg_get" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  result = (int) ((arg1)->iAcolLeg);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_colReconnection_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourDipole_colReconnection_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_colReconnection_set" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColourDipole_colReconnection_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->colReconnection = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_colReconnection_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourDipole_colReconnection_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_colReconnection_get" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  result = (int) ((arg1)->colReconnection);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_isJun_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourDipole_isJun_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_isJun_set" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColourDipole_isJun_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isJun = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_isJun_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourDipole_isJun_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_isJun_get" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  result = (bool) ((arg1)->isJun);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_isAntiJun_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourDipole_isAntiJun_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_isAntiJun_set" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColourDipole_isAntiJun_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isAntiJun = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_isAntiJun_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourDipole_isAntiJun_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_isAntiJun_get" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  result = (bool) ((arg1)->isAntiJun);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_isActive_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourDipole_isActive_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_isActive_set" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColourDipole_isActive_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isActive = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_isActive_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourDipole_isActive_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_isActive_get" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  result = (bool) ((arg1)->isActive);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_isReal_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourDipole_isReal_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_isReal_set" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColourDipole_isReal_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isReal = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_isReal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourDipole_isReal_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_isReal_get" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  result = (bool) ((arg1)->isReal);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_printed_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourDipole_printed_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_printed_set" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColourDipole_printed_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->printed = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_printed_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourDipole_printed_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_printed_get" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  result = (bool) ((arg1)->printed);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_leftDip_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  Pythia8::ColourDipole *arg2 = (Pythia8::ColourDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourDipole_leftDip_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_leftDip_set" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ColourDipole, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColourDipole_leftDip_set" "', argument " "2"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ColourDipole * >(argp2);
  if (arg1) (arg1)->leftDip = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_leftDip_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ColourDipole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourDipole_leftDip_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_leftDip_get" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  result = (Pythia8::ColourDipole *) ((arg1)->leftDip);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_rightDip_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  Pythia8::ColourDipole *arg2 = (Pythia8::ColourDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourDipole_rightDip_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_rightDip_set" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ColourDipole, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColourDipole_rightDip_set" "', argument " "2"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ColourDipole * >(argp2);
  if (arg1) (arg1)->rightDip = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_rightDip_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ColourDipole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourDipole_rightDip_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_rightDip_get" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  result = (Pythia8::ColourDipole *) ((arg1)->rightDip);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_colDips_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > *arg2 = (std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourDipole_colDips_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_colDips_set" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColourDipole_colDips_set" "', argument " "2"" of type '" "std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > * >(argp2);
  if (arg1) (arg1)->colDips = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_colDips_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourDipole_colDips_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_colDips_get" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  result = (std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > *)& ((arg1)->colDips);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_acolDips_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > *arg2 = (std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourDipole_acolDips_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_acolDips_set" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColourDipole_acolDips_set" "', argument " "2"" of type '" "std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > * >(argp2);
  if (arg1) (arg1)->acolDips = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_acolDips_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourDipole_acolDips_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_acolDips_get" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  result = (std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > *)& ((arg1)->acolDips);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_p1p2_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourDipole_p1p2_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_p1p2_set" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColourDipole_p1p2_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->p1p2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole_p1p2_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourDipole_p1p2_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole_p1p2_get" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  result = (double) ((arg1)->p1p2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourDipole___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourDipole___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourDipole___str__" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  result = Pythia8_ColourDipole___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ColourDipole(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ColourDipole",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ColourDipole" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ColourDipole_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ColourDipole, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ColourJunction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Junction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ColourJunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ColourJunction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Junction,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ColourJunction" "', argument " "1"" of type '" "Pythia8::Junction const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ColourJunction" "', argument " "1"" of type '" "Pythia8::Junction const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Junction * >(argp1);
  result = (Pythia8::ColourJunction *)new Pythia8::ColourJunction((Pythia8::Junction const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ColourJunction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ColourJunction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourJunction *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ColourJunction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ColourJunction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__ColourJunction,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ColourJunction" "', argument " "1"" of type '" "Pythia8::ColourJunction const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ColourJunction" "', argument " "1"" of type '" "Pythia8::ColourJunction const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourJunction * >(argp1);
  result = (Pythia8::ColourJunction *)new Pythia8::ColourJunction((Pythia8::ColourJunction const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ColourJunction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ColourJunction(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__ColourJunction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ColourJunction__SWIG_1(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Junction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ColourJunction__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ColourJunction'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ColourJunction::ColourJunction(Pythia8::Junction const &)\n"
    "    Pythia8::ColourJunction::ColourJunction(Pythia8::ColourJunction const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ColourJunction_getColDip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourJunction *arg1 = (Pythia8::ColourJunction *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::ColourDipole *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourJunction_getColDip",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourJunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourJunction_getColDip" "', argument " "1"" of type '" "Pythia8::ColourJunction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourJunction * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColourJunction_getColDip" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::ColourDipole *)(arg1)->getColDip(arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourJunction_setColDip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourJunction *arg1 = (Pythia8::ColourJunction *) 0 ;
  int arg2 ;
  Pythia8::ColourDipole *arg3 = (Pythia8::ColourDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ColourJunction_setColDip",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourJunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourJunction_setColDip" "', argument " "1"" of type '" "Pythia8::ColourJunction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourJunction * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColourJunction_setColDip" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ColourJunction_setColDip" "', argument " "3"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ColourDipole * >(argp3);
  (arg1)->setColDip(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourJunction_dips_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourJunction *arg1 = (Pythia8::ColourJunction *) 0 ;
  Pythia8::ColourDipole **arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourJunction_dips_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourJunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourJunction_dips_set" "', argument " "1"" of type '" "Pythia8::ColourJunction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourJunction * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColourJunction_dips_set" "', argument " "2"" of type '" "Pythia8::ColourDipole *[3]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::ColourDipole ** >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)3; ++ii) *(Pythia8::ColourDipole * *)&arg1->dips[ii] = *((Pythia8::ColourDipole * *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""dips""' of type '""Pythia8::ColourDipole *[3]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourJunction_dips_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourJunction *arg1 = (Pythia8::ColourJunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ColourDipole **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourJunction_dips_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourJunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourJunction_dips_get" "', argument " "1"" of type '" "Pythia8::ColourJunction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourJunction * >(argp1);
  result = (Pythia8::ColourDipole **)(Pythia8::ColourDipole **) ((arg1)->dips);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_Pythia8__ColourDipole, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourJunction_dipsOrig_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourJunction *arg1 = (Pythia8::ColourJunction *) 0 ;
  Pythia8::ColourDipole **arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourJunction_dipsOrig_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourJunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourJunction_dipsOrig_set" "', argument " "1"" of type '" "Pythia8::ColourJunction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourJunction * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColourJunction_dipsOrig_set" "', argument " "2"" of type '" "Pythia8::ColourDipole *[3]""'"); 
  } 
  arg2 = reinterpret_cast< Pythia8::ColourDipole ** >(argp2);
  {
    if (arg2) {
      size_t ii = 0;
      for (; ii < (size_t)3; ++ii) *(Pythia8::ColourDipole * *)&arg1->dipsOrig[ii] = *((Pythia8::ColourDipole * *)arg2 + ii);
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""dipsOrig""' of type '""Pythia8::ColourDipole *[3]""'");
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourJunction_dipsOrig_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourJunction *arg1 = (Pythia8::ColourJunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ColourDipole **result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourJunction_dipsOrig_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourJunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourJunction_dipsOrig_get" "', argument " "1"" of type '" "Pythia8::ColourJunction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourJunction * >(argp1);
  result = (Pythia8::ColourDipole **)(Pythia8::ColourDipole **) ((arg1)->dipsOrig);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_Pythia8__ColourDipole, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourJunction___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourJunction *arg1 = (Pythia8::ColourJunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourJunction___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourJunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourJunction___str__" "', argument " "1"" of type '" "Pythia8::ColourJunction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourJunction * >(argp1);
  result = Pythia8_ColourJunction___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ColourJunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourJunction *arg1 = (Pythia8::ColourJunction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ColourJunction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourJunction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ColourJunction" "', argument " "1"" of type '" "Pythia8::ColourJunction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourJunction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ColourJunction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ColourJunction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TrialReconnection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  Pythia8::ColourDipole *arg2 = (Pythia8::ColourDipole *) 0 ;
  Pythia8::ColourDipole *arg3 = (Pythia8::ColourDipole *) 0 ;
  Pythia8::ColourDipole *arg4 = (Pythia8::ColourDipole *) 0 ;
  int arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::TrialReconnection *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_TrialReconnection",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TrialReconnection" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TrialReconnection" "', argument " "2"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ColourDipole * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_TrialReconnection" "', argument " "3"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ColourDipole * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_TrialReconnection" "', argument " "4"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ColourDipole * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TrialReconnection" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_TrialReconnection" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (Pythia8::TrialReconnection *)new Pythia8::TrialReconnection(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TrialReconnection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrialReconnection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  Pythia8::ColourDipole *arg2 = (Pythia8::ColourDipole *) 0 ;
  Pythia8::ColourDipole *arg3 = (Pythia8::ColourDipole *) 0 ;
  Pythia8::ColourDipole *arg4 = (Pythia8::ColourDipole *) 0 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::TrialReconnection *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_TrialReconnection",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TrialReconnection" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TrialReconnection" "', argument " "2"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ColourDipole * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_TrialReconnection" "', argument " "3"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ColourDipole * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_TrialReconnection" "', argument " "4"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ColourDipole * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TrialReconnection" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (Pythia8::TrialReconnection *)new Pythia8::TrialReconnection(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TrialReconnection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrialReconnection__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  Pythia8::ColourDipole *arg2 = (Pythia8::ColourDipole *) 0 ;
  Pythia8::ColourDipole *arg3 = (Pythia8::ColourDipole *) 0 ;
  Pythia8::ColourDipole *arg4 = (Pythia8::ColourDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::TrialReconnection *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_TrialReconnection",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TrialReconnection" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TrialReconnection" "', argument " "2"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ColourDipole * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_TrialReconnection" "', argument " "3"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ColourDipole * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_TrialReconnection" "', argument " "4"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ColourDipole * >(argp4);
  result = (Pythia8::TrialReconnection *)new Pythia8::TrialReconnection(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TrialReconnection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrialReconnection__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  Pythia8::ColourDipole *arg2 = (Pythia8::ColourDipole *) 0 ;
  Pythia8::ColourDipole *arg3 = (Pythia8::ColourDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::TrialReconnection *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_TrialReconnection",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TrialReconnection" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TrialReconnection" "', argument " "2"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ColourDipole * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_TrialReconnection" "', argument " "3"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ColourDipole * >(argp3);
  result = (Pythia8::TrialReconnection *)new Pythia8::TrialReconnection(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TrialReconnection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrialReconnection__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  Pythia8::ColourDipole *arg2 = (Pythia8::ColourDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::TrialReconnection *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_TrialReconnection",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TrialReconnection" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TrialReconnection" "', argument " "2"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ColourDipole * >(argp2);
  result = (Pythia8::TrialReconnection *)new Pythia8::TrialReconnection(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TrialReconnection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrialReconnection__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourDipole *arg1 = (Pythia8::ColourDipole *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::TrialReconnection *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TrialReconnection",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourDipole, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TrialReconnection" "', argument " "1"" of type '" "Pythia8::ColourDipole *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourDipole * >(argp1);
  result = (Pythia8::TrialReconnection *)new Pythia8::TrialReconnection(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TrialReconnection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrialReconnection__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TrialReconnection *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TrialReconnection")) SWIG_fail;
  result = (Pythia8::TrialReconnection *)new Pythia8::TrialReconnection();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TrialReconnection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TrialReconnection(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_TrialReconnection__SWIG_6(self, args);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ColourDipole, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TrialReconnection__SWIG_5(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ColourDipole, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__ColourDipole, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_TrialReconnection__SWIG_4(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ColourDipole, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__ColourDipole, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__ColourDipole, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_TrialReconnection__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ColourDipole, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__ColourDipole, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__ColourDipole, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__ColourDipole, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_TrialReconnection__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ColourDipole, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__ColourDipole, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__ColourDipole, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__ColourDipole, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_TrialReconnection__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ColourDipole, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__ColourDipole, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__ColourDipole, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__ColourDipole, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_TrialReconnection__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TrialReconnection'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::TrialReconnection::TrialReconnection(Pythia8::ColourDipole *,Pythia8::ColourDipole *,Pythia8::ColourDipole *,Pythia8::ColourDipole *,int,double)\n"
    "    Pythia8::TrialReconnection::TrialReconnection(Pythia8::ColourDipole *,Pythia8::ColourDipole *,Pythia8::ColourDipole *,Pythia8::ColourDipole *,int)\n"
    "    Pythia8::TrialReconnection::TrialReconnection(Pythia8::ColourDipole *,Pythia8::ColourDipole *,Pythia8::ColourDipole *,Pythia8::ColourDipole *)\n"
    "    Pythia8::TrialReconnection::TrialReconnection(Pythia8::ColourDipole *,Pythia8::ColourDipole *,Pythia8::ColourDipole *)\n"
    "    Pythia8::TrialReconnection::TrialReconnection(Pythia8::ColourDipole *,Pythia8::ColourDipole *)\n"
    "    Pythia8::TrialReconnection::TrialReconnection(Pythia8::ColourDipole *)\n"
    "    Pythia8::TrialReconnection::TrialReconnection()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_TrialReconnection_dips_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TrialReconnection *arg1 = (Pythia8::TrialReconnection *) 0 ;
  std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > *arg2 = (std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TrialReconnection_dips_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TrialReconnection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TrialReconnection_dips_set" "', argument " "1"" of type '" "Pythia8::TrialReconnection *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TrialReconnection * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TrialReconnection_dips_set" "', argument " "2"" of type '" "std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > * >(argp2);
  if (arg1) (arg1)->dips = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TrialReconnection_dips_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TrialReconnection *arg1 = (Pythia8::TrialReconnection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TrialReconnection_dips_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TrialReconnection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TrialReconnection_dips_get" "', argument " "1"" of type '" "Pythia8::TrialReconnection *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TrialReconnection * >(argp1);
  result = (std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > *)& ((arg1)->dips);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TrialReconnection_mode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TrialReconnection *arg1 = (Pythia8::TrialReconnection *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TrialReconnection_mode_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TrialReconnection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TrialReconnection_mode_set" "', argument " "1"" of type '" "Pythia8::TrialReconnection *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TrialReconnection * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TrialReconnection_mode_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->mode = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TrialReconnection_mode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TrialReconnection *arg1 = (Pythia8::TrialReconnection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TrialReconnection_mode_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TrialReconnection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TrialReconnection_mode_get" "', argument " "1"" of type '" "Pythia8::TrialReconnection *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TrialReconnection * >(argp1);
  result = (int) ((arg1)->mode);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TrialReconnection_lambdaDiff_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TrialReconnection *arg1 = (Pythia8::TrialReconnection *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:TrialReconnection_lambdaDiff_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TrialReconnection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TrialReconnection_lambdaDiff_set" "', argument " "1"" of type '" "Pythia8::TrialReconnection *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TrialReconnection * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TrialReconnection_lambdaDiff_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->lambdaDiff = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TrialReconnection_lambdaDiff_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TrialReconnection *arg1 = (Pythia8::TrialReconnection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TrialReconnection_lambdaDiff_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TrialReconnection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TrialReconnection_lambdaDiff_get" "', argument " "1"" of type '" "Pythia8::TrialReconnection *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TrialReconnection * >(argp1);
  result = (double) ((arg1)->lambdaDiff);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_TrialReconnection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TrialReconnection *arg1 = (Pythia8::TrialReconnection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TrialReconnection",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TrialReconnection, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TrialReconnection" "', argument " "1"" of type '" "Pythia8::TrialReconnection *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TrialReconnection * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TrialReconnection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__TrialReconnection, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ColourParticle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Particle *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ColourParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ColourParticle",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Particle,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ColourParticle" "', argument " "1"" of type '" "Pythia8::Particle const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ColourParticle" "', argument " "1"" of type '" "Pythia8::Particle const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Particle * >(argp1);
  result = (Pythia8::ColourParticle *)new Pythia8::ColourParticle((Pythia8::Particle const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ColourParticle, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourParticle_dips_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourParticle *arg1 = (Pythia8::ColourParticle *) 0 ;
  std::vector< std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > >,std::allocator< std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > > > *arg2 = (std::vector< std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > >,std::allocator< std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourParticle_dips_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourParticle_dips_set" "', argument " "1"" of type '" "Pythia8::ColourParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourParticle * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t_std__allocatorT_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColourParticle_dips_set" "', argument " "2"" of type '" "std::vector< std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > >,std::allocator< std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > >,std::allocator< std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > > > * >(argp2);
  if (arg1) (arg1)->dips = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourParticle_dips_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourParticle *arg1 = (Pythia8::ColourParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > >,std::allocator< std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourParticle_dips_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourParticle_dips_get" "', argument " "1"" of type '" "Pythia8::ColourParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourParticle * >(argp1);
  result = (std::vector< std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > >,std::allocator< std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > > > *)& ((arg1)->dips);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t_std__allocatorT_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourParticle_colEndIncluded_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourParticle *arg1 = (Pythia8::ColourParticle *) 0 ;
  std::vector< bool,std::allocator< bool > > *arg2 = (std::vector< bool,std::allocator< bool > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourParticle_colEndIncluded_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourParticle_colEndIncluded_set" "', argument " "1"" of type '" "Pythia8::ColourParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourParticle * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColourParticle_colEndIncluded_set" "', argument " "2"" of type '" "std::vector< bool,std::allocator< bool > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< bool,std::allocator< bool > > * >(argp2);
  if (arg1) (arg1)->colEndIncluded = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourParticle_colEndIncluded_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourParticle *arg1 = (Pythia8::ColourParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< bool,std::allocator< bool > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourParticle_colEndIncluded_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourParticle_colEndIncluded_get" "', argument " "1"" of type '" "Pythia8::ColourParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourParticle * >(argp1);
  result = (std::vector< bool,std::allocator< bool > > *)& ((arg1)->colEndIncluded);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourParticle_acolEndIncluded_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourParticle *arg1 = (Pythia8::ColourParticle *) 0 ;
  std::vector< bool,std::allocator< bool > > *arg2 = (std::vector< bool,std::allocator< bool > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourParticle_acolEndIncluded_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourParticle_acolEndIncluded_set" "', argument " "1"" of type '" "Pythia8::ColourParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourParticle * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColourParticle_acolEndIncluded_set" "', argument " "2"" of type '" "std::vector< bool,std::allocator< bool > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< bool,std::allocator< bool > > * >(argp2);
  if (arg1) (arg1)->acolEndIncluded = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourParticle_acolEndIncluded_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourParticle *arg1 = (Pythia8::ColourParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< bool,std::allocator< bool > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourParticle_acolEndIncluded_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourParticle_acolEndIncluded_get" "', argument " "1"" of type '" "Pythia8::ColourParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourParticle * >(argp1);
  result = (std::vector< bool,std::allocator< bool > > *)& ((arg1)->acolEndIncluded);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourParticle_activeDips_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourParticle *arg1 = (Pythia8::ColourParticle *) 0 ;
  std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > *arg2 = (std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourParticle_activeDips_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourParticle_activeDips_set" "', argument " "1"" of type '" "Pythia8::ColourParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourParticle * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColourParticle_activeDips_set" "', argument " "2"" of type '" "std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > * >(argp2);
  if (arg1) (arg1)->activeDips = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourParticle_activeDips_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourParticle *arg1 = (Pythia8::ColourParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourParticle_activeDips_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourParticle_activeDips_get" "', argument " "1"" of type '" "Pythia8::ColourParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourParticle * >(argp1);
  result = (std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > *)& ((arg1)->activeDips);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourParticle_isJun_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourParticle *arg1 = (Pythia8::ColourParticle *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourParticle_isJun_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourParticle_isJun_set" "', argument " "1"" of type '" "Pythia8::ColourParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourParticle * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColourParticle_isJun_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isJun = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourParticle_isJun_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourParticle *arg1 = (Pythia8::ColourParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourParticle_isJun_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourParticle_isJun_get" "', argument " "1"" of type '" "Pythia8::ColourParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourParticle * >(argp1);
  result = (bool) ((arg1)->isJun);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourParticle_junKind_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourParticle *arg1 = (Pythia8::ColourParticle *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ColourParticle_junKind_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourParticle_junKind_set" "', argument " "1"" of type '" "Pythia8::ColourParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourParticle * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColourParticle_junKind_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->junKind = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourParticle_junKind_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourParticle *arg1 = (Pythia8::ColourParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourParticle_junKind_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourParticle_junKind_get" "', argument " "1"" of type '" "Pythia8::ColourParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourParticle * >(argp1);
  result = (int) ((arg1)->junKind);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourParticle_listParticle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourParticle *arg1 = (Pythia8::ColourParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourParticle_listParticle",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourParticle_listParticle" "', argument " "1"" of type '" "Pythia8::ColourParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourParticle * >(argp1);
  (arg1)->listParticle();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourParticle_listActiveDips(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourParticle *arg1 = (Pythia8::ColourParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourParticle_listActiveDips",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourParticle_listActiveDips" "', argument " "1"" of type '" "Pythia8::ColourParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourParticle * >(argp1);
  (arg1)->listActiveDips();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourParticle_listDips(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourParticle *arg1 = (Pythia8::ColourParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ColourParticle_listDips",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourParticle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourParticle_listDips" "', argument " "1"" of type '" "Pythia8::ColourParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourParticle * >(argp1);
  (arg1)->listDips();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ColourParticle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourParticle *arg1 = (Pythia8::ColourParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ColourParticle",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourParticle, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ColourParticle" "', argument " "1"" of type '" "Pythia8::ColourParticle *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourParticle * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ColourParticle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ColourParticle, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ColourReconnection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourReconnection *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ColourReconnection")) SWIG_fail;
  result = (Pythia8::ColourReconnection *)new Pythia8::ColourReconnection();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ColourReconnection, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourReconnection_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourReconnection *arg1 = (Pythia8::ColourReconnection *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::Rndm *arg4 = (Pythia8::Rndm *) 0 ;
  Pythia8::ParticleData *arg5 = (Pythia8::ParticleData *) 0 ;
  Pythia8::BeamParticle *arg6 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg7 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::PartonSystems *arg8 = (Pythia8::PartonSystems *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:ColourReconnection_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourReconnection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourReconnection_init" "', argument " "1"" of type '" "Pythia8::ColourReconnection *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourReconnection * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColourReconnection_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ColourReconnection_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ColourReconnection_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ColourReconnection_init" "', argument " "4"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Rndm * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ColourReconnection_init" "', argument " "5"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::ParticleData * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ColourReconnection_init" "', argument " "6"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::BeamParticle * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ColourReconnection_init" "', argument " "7"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::BeamParticle * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ColourReconnection_init" "', argument " "8"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::PartonSystems * >(argp8);
  result = (bool)(arg1)->init(arg2,*arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourReconnection_reassignBeamPtrs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourReconnection *arg1 = (Pythia8::ColourReconnection *) 0 ;
  Pythia8::BeamParticle *arg2 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg3 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ColourReconnection_reassignBeamPtrs",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourReconnection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourReconnection_reassignBeamPtrs" "', argument " "1"" of type '" "Pythia8::ColourReconnection *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourReconnection * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColourReconnection_reassignBeamPtrs" "', argument " "2"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::BeamParticle * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ColourReconnection_reassignBeamPtrs" "', argument " "3"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::BeamParticle * >(argp3);
  (arg1)->reassignBeamPtrs(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ColourReconnection_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourReconnection *arg1 = (Pythia8::ColourReconnection *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ColourReconnection_next",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourReconnection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColourReconnection_next" "', argument " "1"" of type '" "Pythia8::ColourReconnection *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourReconnection * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ColourReconnection_next" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ColourReconnection_next" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ColourReconnection_next" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (bool)(arg1)->next(*arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ColourReconnection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ColourReconnection *arg1 = (Pythia8::ColourReconnection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ColourReconnection",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ColourReconnection, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ColourReconnection" "', argument " "1"" of type '" "Pythia8::ColourReconnection *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ColourReconnection * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ColourReconnection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ColourReconnection, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_HVStringFlav(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HVStringFlav *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HVStringFlav")) SWIG_fail;
  result = (Pythia8::HVStringFlav *)new Pythia8::HVStringFlav();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HVStringFlav, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HVStringFlav(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HVStringFlav *arg1 = (Pythia8::HVStringFlav *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HVStringFlav",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HVStringFlav, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HVStringFlav" "', argument " "1"" of type '" "Pythia8::HVStringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HVStringFlav * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HVStringFlav_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HVStringFlav *arg1 = (Pythia8::HVStringFlav *) 0 ;
  Pythia8::Settings *arg2 = 0 ;
  Pythia8::ParticleData *arg3 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg4 = (Pythia8::Rndm *) 0 ;
  Pythia8::Info *arg5 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:HVStringFlav_init",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HVStringFlav, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HVStringFlav_init" "', argument " "1"" of type '" "Pythia8::HVStringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HVStringFlav * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HVStringFlav_init" "', argument " "2"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HVStringFlav_init" "', argument " "2"" of type '" "Pythia8::Settings &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HVStringFlav_init" "', argument " "3"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ParticleData * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "HVStringFlav_init" "', argument " "4"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Rndm * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "HVStringFlav_init" "', argument " "5"" of type '" "Pythia8::Info *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Info * >(argp5);
  (arg1)->init(*arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HVStringFlav_pick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HVStringFlav *arg1 = (Pythia8::HVStringFlav *) 0 ;
  Pythia8::FlavContainer *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::FlavContainer result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:HVStringFlav_pick",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HVStringFlav, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HVStringFlav_pick" "', argument " "1"" of type '" "Pythia8::HVStringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HVStringFlav * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__FlavContainer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HVStringFlav_pick" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HVStringFlav_pick" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::FlavContainer * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HVStringFlav_pick" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HVStringFlav_pick" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (arg1)->pick(*arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj((new Pythia8::FlavContainer(static_cast< const Pythia8::FlavContainer& >(result))), SWIGTYPE_p_Pythia8__FlavContainer, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HVStringFlav_combine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HVStringFlav *arg1 = (Pythia8::HVStringFlav *) 0 ;
  Pythia8::FlavContainer *arg2 = 0 ;
  Pythia8::FlavContainer *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:HVStringFlav_combine",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HVStringFlav, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HVStringFlav_combine" "', argument " "1"" of type '" "Pythia8::HVStringFlav *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HVStringFlav * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__FlavContainer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HVStringFlav_combine" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HVStringFlav_combine" "', argument " "2"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::FlavContainer * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__FlavContainer,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HVStringFlav_combine" "', argument " "3"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HVStringFlav_combine" "', argument " "3"" of type '" "Pythia8::FlavContainer &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::FlavContainer * >(argp3);
  result = (int)(arg1)->combine(*arg2,*arg3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HVStringFlav_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HVStringFlav, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_HVStringPT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HVStringPT *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HVStringPT")) SWIG_fail;
  result = (Pythia8::HVStringPT *)new Pythia8::HVStringPT();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HVStringPT, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HVStringPT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HVStringPT *arg1 = (Pythia8::HVStringPT *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HVStringPT",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HVStringPT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HVStringPT" "', argument " "1"" of type '" "Pythia8::HVStringPT *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HVStringPT * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HVStringPT_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HVStringPT *arg1 = (Pythia8::HVStringPT *) 0 ;
  Pythia8::Settings *arg2 = 0 ;
  Pythia8::ParticleData *arg3 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg4 = (Pythia8::Rndm *) 0 ;
  Pythia8::Info *arg5 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:HVStringPT_init",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HVStringPT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HVStringPT_init" "', argument " "1"" of type '" "Pythia8::HVStringPT *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HVStringPT * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HVStringPT_init" "', argument " "2"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HVStringPT_init" "', argument " "2"" of type '" "Pythia8::Settings &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HVStringPT_init" "', argument " "3"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ParticleData * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "HVStringPT_init" "', argument " "4"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Rndm * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "HVStringPT_init" "', argument " "5"" of type '" "Pythia8::Info *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Info * >(argp5);
  (arg1)->init(*arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HVStringPT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HVStringPT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_HVStringZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HVStringZ *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HVStringZ")) SWIG_fail;
  result = (Pythia8::HVStringZ *)new Pythia8::HVStringZ();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HVStringZ, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HVStringZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HVStringZ *arg1 = (Pythia8::HVStringZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HVStringZ",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HVStringZ, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HVStringZ" "', argument " "1"" of type '" "Pythia8::HVStringZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HVStringZ * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HVStringZ_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HVStringZ *arg1 = (Pythia8::HVStringZ *) 0 ;
  Pythia8::Settings *arg2 = 0 ;
  Pythia8::ParticleData *arg3 = 0 ;
  Pythia8::Rndm *arg4 = (Pythia8::Rndm *) 0 ;
  Pythia8::Info *arg5 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:HVStringZ_init",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HVStringZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HVStringZ_init" "', argument " "1"" of type '" "Pythia8::HVStringZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HVStringZ * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HVStringZ_init" "', argument " "2"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HVStringZ_init" "', argument " "2"" of type '" "Pythia8::Settings &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__ParticleData,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HVStringZ_init" "', argument " "3"" of type '" "Pythia8::ParticleData &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HVStringZ_init" "', argument " "3"" of type '" "Pythia8::ParticleData &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ParticleData * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "HVStringZ_init" "', argument " "4"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Rndm * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "HVStringZ_init" "', argument " "5"" of type '" "Pythia8::Info *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Info * >(argp5);
  (arg1)->init(*arg2,*arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HVStringZ_zFrag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HVStringZ *arg1 = (Pythia8::HVStringZ *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:HVStringZ_zFrag",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HVStringZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HVStringZ_zFrag" "', argument " "1"" of type '" "Pythia8::HVStringZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HVStringZ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HVStringZ_zFrag" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HVStringZ_zFrag" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HVStringZ_zFrag" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)(arg1)->zFrag(arg2,arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HVStringZ_zFrag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HVStringZ *arg1 = (Pythia8::HVStringZ *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:HVStringZ_zFrag",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HVStringZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HVStringZ_zFrag" "', argument " "1"" of type '" "Pythia8::HVStringZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HVStringZ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HVStringZ_zFrag" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HVStringZ_zFrag" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)(arg1)->zFrag(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HVStringZ_zFrag__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HVStringZ *arg1 = (Pythia8::HVStringZ *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HVStringZ_zFrag",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HVStringZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HVStringZ_zFrag" "', argument " "1"" of type '" "Pythia8::HVStringZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HVStringZ * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HVStringZ_zFrag" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (double)(arg1)->zFrag(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HVStringZ_zFrag(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HVStringZ, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_HVStringZ_zFrag__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HVStringZ, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_HVStringZ_zFrag__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HVStringZ, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_HVStringZ_zFrag__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'HVStringZ_zFrag'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::HVStringZ::zFrag(int,int,double)\n"
    "    Pythia8::HVStringZ::zFrag(int,int)\n"
    "    Pythia8::HVStringZ::zFrag(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HVStringZ_stopMass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HVStringZ *arg1 = (Pythia8::HVStringZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HVStringZ_stopMass",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HVStringZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HVStringZ_stopMass" "', argument " "1"" of type '" "Pythia8::HVStringZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HVStringZ * >(argp1);
  result = (double)(arg1)->stopMass();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HVStringZ_stopNewFlav(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HVStringZ *arg1 = (Pythia8::HVStringZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HVStringZ_stopNewFlav",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HVStringZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HVStringZ_stopNewFlav" "', argument " "1"" of type '" "Pythia8::HVStringZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HVStringZ * >(argp1);
  result = (double)(arg1)->stopNewFlav();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HVStringZ_stopSmear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HVStringZ *arg1 = (Pythia8::HVStringZ *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HVStringZ_stopSmear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HVStringZ, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HVStringZ_stopSmear" "', argument " "1"" of type '" "Pythia8::HVStringZ *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HVStringZ * >(argp1);
  result = (double)(arg1)->stopSmear();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HVStringZ_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HVStringZ, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_HiddenValleyFragmentation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HiddenValleyFragmentation *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HiddenValleyFragmentation")) SWIG_fail;
  result = (Pythia8::HiddenValleyFragmentation *)new Pythia8::HiddenValleyFragmentation();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HiddenValleyFragmentation, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HiddenValleyFragmentation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HiddenValleyFragmentation *arg1 = (Pythia8::HiddenValleyFragmentation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HiddenValleyFragmentation",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HiddenValleyFragmentation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HiddenValleyFragmentation" "', argument " "1"" of type '" "Pythia8::HiddenValleyFragmentation *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HiddenValleyFragmentation * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HiddenValleyFragmentation_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HiddenValleyFragmentation *arg1 = (Pythia8::HiddenValleyFragmentation *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:HiddenValleyFragmentation_init",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HiddenValleyFragmentation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HiddenValleyFragmentation_init" "', argument " "1"" of type '" "Pythia8::HiddenValleyFragmentation *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HiddenValleyFragmentation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HiddenValleyFragmentation_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HiddenValleyFragmentation_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HiddenValleyFragmentation_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "HiddenValleyFragmentation_init" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "HiddenValleyFragmentation_init" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  result = (bool)(arg1)->init(arg2,*arg3,arg4,arg5);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HiddenValleyFragmentation_fragment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HiddenValleyFragmentation *arg1 = (Pythia8::HiddenValleyFragmentation *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HiddenValleyFragmentation_fragment",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HiddenValleyFragmentation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HiddenValleyFragmentation_fragment" "', argument " "1"" of type '" "Pythia8::HiddenValleyFragmentation *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HiddenValleyFragmentation * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HiddenValleyFragmentation_fragment" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HiddenValleyFragmentation_fragment" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->fragment(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HiddenValleyFragmentation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HiddenValleyFragmentation, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_JunctionSplitting_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JunctionSplitting *arg1 = (Pythia8::JunctionSplitting *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::Rndm *arg4 = (Pythia8::Rndm *) 0 ;
  Pythia8::ParticleData *arg5 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:JunctionSplitting_init",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JunctionSplitting, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JunctionSplitting_init" "', argument " "1"" of type '" "Pythia8::JunctionSplitting *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JunctionSplitting * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JunctionSplitting_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "JunctionSplitting_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JunctionSplitting_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "JunctionSplitting_init" "', argument " "4"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Rndm * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "JunctionSplitting_init" "', argument " "5"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::ParticleData * >(argp5);
  (arg1)->init(arg2,*arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JunctionSplitting_checkColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JunctionSplitting *arg1 = (Pythia8::JunctionSplitting *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:JunctionSplitting_checkColours",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JunctionSplitting, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JunctionSplitting_checkColours" "', argument " "1"" of type '" "Pythia8::JunctionSplitting *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JunctionSplitting * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JunctionSplitting_checkColours" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JunctionSplitting_checkColours" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->checkColours(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_JunctionSplitting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JunctionSplitting *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_JunctionSplitting")) SWIG_fail;
  result = (Pythia8::JunctionSplitting *)new Pythia8::JunctionSplitting();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__JunctionSplitting, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_JunctionSplitting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JunctionSplitting *arg1 = (Pythia8::JunctionSplitting *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_JunctionSplitting",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JunctionSplitting, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_JunctionSplitting" "', argument " "1"" of type '" "Pythia8::JunctionSplitting *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JunctionSplitting * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *JunctionSplitting_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__JunctionSplitting, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_DecayHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayHandler *arg1 = (Pythia8::DecayHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DecayHandler",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayHandler, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DecayHandler" "', argument " "1"" of type '" "Pythia8::DecayHandler *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayHandler * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayHandler_decay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayHandler *arg1 = (Pythia8::DecayHandler *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > *arg4 = 0 ;
  int arg5 ;
  Pythia8::Event *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:DecayHandler_decay",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayHandler_decay" "', argument " "1"" of type '" "Pythia8::DecayHandler *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayHandler * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DecayHandler_decay" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DecayHandler_decay" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DecayHandler_decay" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DecayHandler_decay" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DecayHandler_decay" "', argument " "4"" of type '" "std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DecayHandler_decay" "', argument " "4"" of type '" "std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DecayHandler_decay" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DecayHandler_decay" "', argument " "6"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DecayHandler_decay" "', argument " "6"" of type '" "Pythia8::Event const &""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::Event * >(argp6);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::DecayHandler::decay(*arg2,*arg3,*arg4,arg5,(Pythia8::Event const &)*arg6);
    } else {
      result = (bool)(arg1)->decay(*arg2,*arg3,*arg4,arg5,(Pythia8::Event const &)*arg6);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DecayHandler_chainDecay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayHandler *arg1 = (Pythia8::DecayHandler *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ;
  std::vector< int,std::allocator< int > > *arg3 = 0 ;
  std::vector< double,std::allocator< double > > *arg4 = 0 ;
  std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > *arg5 = 0 ;
  int arg6 ;
  Pythia8::Event *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:DecayHandler_chainDecay",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DecayHandler_chainDecay" "', argument " "1"" of type '" "Pythia8::DecayHandler *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayHandler * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DecayHandler_chainDecay" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DecayHandler_chainDecay" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DecayHandler_chainDecay" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DecayHandler_chainDecay" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DecayHandler_chainDecay" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DecayHandler_chainDecay" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DecayHandler_chainDecay" "', argument " "5"" of type '" "std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DecayHandler_chainDecay" "', argument " "5"" of type '" "std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > * >(argp5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DecayHandler_chainDecay" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "DecayHandler_chainDecay" "', argument " "7"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DecayHandler_chainDecay" "', argument " "7"" of type '" "Pythia8::Event const &""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::Event * >(argp7);
  director = SWIG_DIRECTOR_CAST(arg1);
  upcall = (director && (director->swig_get_self()==obj0));
  try {
    if (upcall) {
      result = (bool)(arg1)->Pythia8::DecayHandler::chainDecay(*arg2,*arg3,*arg4,*arg5,arg6,(Pythia8::Event const &)*arg7);
    } else {
      result = (bool)(arg1)->chainDecay(*arg2,*arg3,*arg4,*arg5,arg6,(Pythia8::Event const &)*arg7);
    }
  } catch (Swig::DirectorException&) {
    SWIG_fail;
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DecayHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  PyObject *arg1 = (PyObject *) 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::DecayHandler *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DecayHandler",&obj0)) SWIG_fail;
  arg1 = obj0;
  if ( arg1 != Py_None ) {
    /* subclassed */
    result = (Pythia8::DecayHandler *)new SwigDirector_DecayHandler(arg1); 
  } else {
    result = (Pythia8::DecayHandler *)new Pythia8::DecayHandler(); 
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__DecayHandler, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_disown_DecayHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DecayHandler *arg1 = (Pythia8::DecayHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:disown_DecayHandler",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DecayHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_DecayHandler" "', argument " "1"" of type '" "Pythia8::DecayHandler *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DecayHandler * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DecayHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__DecayHandler, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ParticleDecays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDecays *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ParticleDecays")) SWIG_fail;
  result = (Pythia8::ParticleDecays *)new Pythia8::ParticleDecays();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleDecays, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDecays_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDecays *arg1 = (Pythia8::ParticleDecays *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  Pythia8::Couplings *arg6 = (Pythia8::Couplings *) 0 ;
  Pythia8::TimeShower *arg7 = (Pythia8::TimeShower *) 0 ;
  Pythia8::StringFlav *arg8 = (Pythia8::StringFlav *) 0 ;
  Pythia8::DecayHandler *arg9 = (Pythia8::DecayHandler *) 0 ;
  std::vector< int,std::allocator< int > > arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:ParticleDecays_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDecays, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDecays_init" "', argument " "1"" of type '" "Pythia8::ParticleDecays *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDecays * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParticleDecays_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParticleDecays_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParticleDecays_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParticleDecays_init" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ParticleDecays_init" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ParticleDecays_init" "', argument " "6"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::Couplings * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ParticleDecays_init" "', argument " "7"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::TimeShower * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ParticleDecays_init" "', argument " "8"" of type '" "Pythia8::StringFlav *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::StringFlav * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__DecayHandler, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ParticleDecays_init" "', argument " "9"" of type '" "Pythia8::DecayHandler *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::DecayHandler * >(argp9);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleDecays_init" "', argument " "10"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->init(arg2,*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDecays_decay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDecays *arg1 = (Pythia8::ParticleDecays *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ParticleDecays_decay",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDecays, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDecays_decay" "', argument " "1"" of type '" "Pythia8::ParticleDecays *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDecays * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParticleDecays_decay" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParticleDecays_decay" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParticleDecays_decay" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  result = (bool)(arg1)->decay(arg2,*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ParticleDecays_moreToDo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDecays *arg1 = (Pythia8::ParticleDecays *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ParticleDecays_moreToDo",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDecays, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParticleDecays_moreToDo" "', argument " "1"" of type '" "Pythia8::ParticleDecays const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDecays * >(argp1);
  result = (bool)((Pythia8::ParticleDecays const *)arg1)->moreToDo();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ParticleDecays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ParticleDecays *arg1 = (Pythia8::ParticleDecays *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ParticleDecays",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ParticleDecays, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ParticleDecays" "', argument " "1"" of type '" "Pythia8::ParticleDecays *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ParticleDecays * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ParticleDecays_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ParticleDecays, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ProcessContainer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  bool arg2 ;
  Pythia8::PhaseSpace *arg3 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::ProcessContainer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_ProcessContainer",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ProcessContainer" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessContainer" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ProcessContainer" "', argument " "3"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PhaseSpace * >(argp3);
  result = (Pythia8::ProcessContainer *)new Pythia8::ProcessContainer(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ProcessContainer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProcessContainer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::ProcessContainer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_ProcessContainer",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ProcessContainer" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessContainer" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (Pythia8::ProcessContainer *)new Pythia8::ProcessContainer(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ProcessContainer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProcessContainer__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SigmaProcess *arg1 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ProcessContainer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_ProcessContainer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ProcessContainer" "', argument " "1"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SigmaProcess * >(argp1);
  result = (Pythia8::ProcessContainer *)new Pythia8::ProcessContainer(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ProcessContainer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProcessContainer__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ProcessContainer")) SWIG_fail;
  result = (Pythia8::ProcessContainer *)new Pythia8::ProcessContainer();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ProcessContainer, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ProcessContainer(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_ProcessContainer__SWIG_3(self, args);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ProcessContainer__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ProcessContainer__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_ProcessContainer__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ProcessContainer'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ProcessContainer::ProcessContainer(Pythia8::SigmaProcess *,bool,Pythia8::PhaseSpace *)\n"
    "    Pythia8::ProcessContainer::ProcessContainer(Pythia8::SigmaProcess *,bool)\n"
    "    Pythia8::ProcessContainer::ProcessContainer(Pythia8::SigmaProcess *)\n"
    "    Pythia8::ProcessContainer::ProcessContainer()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ProcessContainer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ProcessContainer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ProcessContainer" "', argument " "1"" of type '" "Pythia8::ProcessContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  bool arg2 ;
  Pythia8::Info *arg3 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg4 = 0 ;
  Pythia8::ParticleData *arg5 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg6 = (Pythia8::Rndm *) 0 ;
  Pythia8::BeamParticle *arg7 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg8 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::Couplings *arg9 = (Pythia8::Couplings *) 0 ;
  Pythia8::SigmaTotal *arg10 = (Pythia8::SigmaTotal *) 0 ;
  Pythia8::ResonanceDecays *arg11 = (Pythia8::ResonanceDecays *) 0 ;
  Pythia8::SLHAinterface *arg12 = (Pythia8::SLHAinterface *) 0 ;
  Pythia8::UserHooks *arg13 = (Pythia8::UserHooks *) 0 ;
  Pythia8::GammaKinematics *arg14 = (Pythia8::GammaKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:ProcessContainer_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_init" "', argument " "1"" of type '" "Pythia8::ProcessContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessContainer_init" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ProcessContainer_init" "', argument " "3"" of type '" "Pythia8::Info *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Info * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ProcessContainer_init" "', argument " "4"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProcessContainer_init" "', argument " "4"" of type '" "Pythia8::Settings &""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Settings * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ProcessContainer_init" "', argument " "5"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::ParticleData * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ProcessContainer_init" "', argument " "6"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::Rndm * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ProcessContainer_init" "', argument " "7"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::BeamParticle * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ProcessContainer_init" "', argument " "8"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::BeamParticle * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ProcessContainer_init" "', argument " "9"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::Couplings * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ProcessContainer_init" "', argument " "10"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg10 = reinterpret_cast< Pythia8::SigmaTotal * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_Pythia8__ResonanceDecays, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ProcessContainer_init" "', argument " "11"" of type '" "Pythia8::ResonanceDecays *""'"); 
  }
  arg11 = reinterpret_cast< Pythia8::ResonanceDecays * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12,SWIGTYPE_p_Pythia8__SLHAinterface, 0 |  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ProcessContainer_init" "', argument " "12"" of type '" "Pythia8::SLHAinterface *""'"); 
  }
  arg12 = reinterpret_cast< Pythia8::SLHAinterface * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ProcessContainer_init" "', argument " "13"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg13 = reinterpret_cast< Pythia8::UserHooks * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14,SWIGTYPE_p_Pythia8__GammaKinematics, 0 |  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "ProcessContainer_init" "', argument " "14"" of type '" "Pythia8::GammaKinematics *""'"); 
  }
  arg14 = reinterpret_cast< Pythia8::GammaKinematics * >(argp14);
  result = (bool)(arg1)->init(arg2,arg3,*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_setLHAPtr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  Pythia8::LHAup *arg2 = (Pythia8::LHAup *) 0 ;
  Pythia8::ParticleData *arg3 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Settings *arg4 = (Pythia8::Settings *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:ProcessContainer_setLHAPtr",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_setLHAPtr" "', argument " "1"" of type '" "Pythia8::ProcessContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProcessContainer_setLHAPtr" "', argument " "2"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHAup * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ProcessContainer_setLHAPtr" "', argument " "3"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ParticleData * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ProcessContainer_setLHAPtr" "', argument " "4"" of type '" "Pythia8::Settings *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Settings * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ProcessContainer_setLHAPtr" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  (arg1)->setLHAPtr(arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_setLHAPtr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  Pythia8::LHAup *arg2 = (Pythia8::LHAup *) 0 ;
  Pythia8::ParticleData *arg3 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Settings *arg4 = (Pythia8::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:ProcessContainer_setLHAPtr",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_setLHAPtr" "', argument " "1"" of type '" "Pythia8::ProcessContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProcessContainer_setLHAPtr" "', argument " "2"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHAup * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ProcessContainer_setLHAPtr" "', argument " "3"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ParticleData * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ProcessContainer_setLHAPtr" "', argument " "4"" of type '" "Pythia8::Settings *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Settings * >(argp4);
  (arg1)->setLHAPtr(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_setLHAPtr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  Pythia8::LHAup *arg2 = (Pythia8::LHAup *) 0 ;
  Pythia8::ParticleData *arg3 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ProcessContainer_setLHAPtr",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_setLHAPtr" "', argument " "1"" of type '" "Pythia8::ProcessContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProcessContainer_setLHAPtr" "', argument " "2"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHAup * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ProcessContainer_setLHAPtr" "', argument " "3"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::ParticleData * >(argp3);
  (arg1)->setLHAPtr(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_setLHAPtr__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  Pythia8::LHAup *arg2 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProcessContainer_setLHAPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_setLHAPtr" "', argument " "1"" of type '" "Pythia8::ProcessContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProcessContainer_setLHAPtr" "', argument " "2"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHAup * >(argp2);
  (arg1)->setLHAPtr(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_setLHAPtr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ProcessContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ProcessContainer_setLHAPtr__SWIG_3(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ProcessContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ProcessContainer_setLHAPtr__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ProcessContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ProcessContainer_setLHAPtr__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ProcessContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__LHAup, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__Rndm, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_ProcessContainer_setLHAPtr__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ProcessContainer_setLHAPtr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ProcessContainer::setLHAPtr(Pythia8::LHAup *,Pythia8::ParticleData *,Pythia8::Settings *,Pythia8::Rndm *)\n"
    "    Pythia8::ProcessContainer::setLHAPtr(Pythia8::LHAup *,Pythia8::ParticleData *,Pythia8::Settings *)\n"
    "    Pythia8::ProcessContainer::setLHAPtr(Pythia8::LHAup *,Pythia8::ParticleData *)\n"
    "    Pythia8::ProcessContainer::setLHAPtr(Pythia8::LHAup *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_newECM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProcessContainer_newECM",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_newECM" "', argument " "1"" of type '" "Pythia8::ProcessContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessContainer_newECM" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->newECM(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_trialProcess(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_trialProcess",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_trialProcess" "', argument " "1"" of type '" "Pythia8::ProcessContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (bool)(arg1)->trialProcess();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_constructState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_constructState",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_constructState" "', argument " "1"" of type '" "Pythia8::ProcessContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (bool)(arg1)->constructState();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_constructProcess__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ProcessContainer_constructProcess",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_constructProcess" "', argument " "1"" of type '" "Pythia8::ProcessContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProcessContainer_constructProcess" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProcessContainer_constructProcess" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ProcessContainer_constructProcess" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->constructProcess(*arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_constructProcess__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProcessContainer_constructProcess",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_constructProcess" "', argument " "1"" of type '" "Pythia8::ProcessContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProcessContainer_constructProcess" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProcessContainer_constructProcess" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->constructProcess(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_constructProcess(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ProcessContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ProcessContainer_constructProcess__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ProcessContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ProcessContainer_constructProcess__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ProcessContainer_constructProcess'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ProcessContainer::constructProcess(Pythia8::Event &,bool)\n"
    "    Pythia8::ProcessContainer::constructProcess(Pythia8::Event &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_constructDecays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProcessContainer_constructDecays",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_constructDecays" "', argument " "1"" of type '" "Pythia8::ProcessContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProcessContainer_constructDecays" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProcessContainer_constructDecays" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->constructDecays(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_decayResonances(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProcessContainer_decayResonances",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_decayResonances" "', argument " "1"" of type '" "Pythia8::ProcessContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProcessContainer_decayResonances" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProcessContainer_decayResonances" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->decayResonances(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_accumulate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_accumulate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_accumulate" "', argument " "1"" of type '" "Pythia8::ProcessContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  (arg1)->accumulate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_reset",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_reset" "', argument " "1"" of type '" "Pythia8::ProcessContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  (arg1)->reset();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_setBeamModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_setBeamModes",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_setBeamModes" "', argument " "1"" of type '" "Pythia8::ProcessContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  (arg1)->setBeamModes();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_chooseVMDstates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::pair< int,int > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:ProcessContainer_chooseVMDstates",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_chooseVMDstates" "', argument " "1"" of type '" "Pythia8::ProcessContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessContainer_chooseVMDstates" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ProcessContainer_chooseVMDstates" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (arg1)->chooseVMDstates(arg2,arg3);
  resultobj = swig::from(static_cast< std::pair< int,int > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_name",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_name" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = ((Pythia8::ProcessContainer const *)arg1)->name();
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_code",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_code" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (int)((Pythia8::ProcessContainer const *)arg1)->code();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_nFinal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_nFinal",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_nFinal" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (int)((Pythia8::ProcessContainer const *)arg1)->nFinal();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_isSUSY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_isSUSY",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_isSUSY" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (bool)((Pythia8::ProcessContainer const *)arg1)->isSUSY();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_isNonDiffractive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_isNonDiffractive",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_isNonDiffractive" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (bool)((Pythia8::ProcessContainer const *)arg1)->isNonDiffractive();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_isSoftQCD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_isSoftQCD",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_isSoftQCD" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (bool)((Pythia8::ProcessContainer const *)arg1)->isSoftQCD();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_newSigmaMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_newSigmaMax",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_newSigmaMax" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (bool)((Pythia8::ProcessContainer const *)arg1)->newSigmaMax();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_sigmaMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_sigmaMax",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_sigmaMax" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (double)((Pythia8::ProcessContainer const *)arg1)->sigmaMax();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_nTried(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  long result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_nTried",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_nTried" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (long)((Pythia8::ProcessContainer const *)arg1)->nTried();
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_nSelected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  long result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_nSelected",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_nSelected" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (long)((Pythia8::ProcessContainer const *)arg1)->nSelected();
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_nAccepted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  long result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_nAccepted",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_nAccepted" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (long)((Pythia8::ProcessContainer const *)arg1)->nAccepted();
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_weightSum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_weightSum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_weightSum" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (double)((Pythia8::ProcessContainer const *)arg1)->weightSum();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_sigmaSelMC__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProcessContainer_sigmaSelMC",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_sigmaSelMC" "', argument " "1"" of type '" "Pythia8::ProcessContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessContainer_sigmaSelMC" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (double)(arg1)->sigmaSelMC(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_sigmaSelMC__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_sigmaSelMC",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_sigmaSelMC" "', argument " "1"" of type '" "Pythia8::ProcessContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (double)(arg1)->sigmaSelMC();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_sigmaSelMC(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ProcessContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ProcessContainer_sigmaSelMC__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ProcessContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ProcessContainer_sigmaSelMC__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ProcessContainer_sigmaSelMC'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ProcessContainer::sigmaSelMC(bool)\n"
    "    Pythia8::ProcessContainer::sigmaSelMC()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_sigmaMC__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProcessContainer_sigmaMC",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_sigmaMC" "', argument " "1"" of type '" "Pythia8::ProcessContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessContainer_sigmaMC" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (double)(arg1)->sigmaMC(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_sigmaMC__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_sigmaMC",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_sigmaMC" "', argument " "1"" of type '" "Pythia8::ProcessContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (double)(arg1)->sigmaMC();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_sigmaMC(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ProcessContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ProcessContainer_sigmaMC__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ProcessContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ProcessContainer_sigmaMC__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ProcessContainer_sigmaMC'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ProcessContainer::sigmaMC(bool)\n"
    "    Pythia8::ProcessContainer::sigmaMC()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_deltaMC__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProcessContainer_deltaMC",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_deltaMC" "', argument " "1"" of type '" "Pythia8::ProcessContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessContainer_deltaMC" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (double)(arg1)->deltaMC(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_deltaMC__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_deltaMC",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_deltaMC" "', argument " "1"" of type '" "Pythia8::ProcessContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (double)(arg1)->deltaMC();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_deltaMC(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ProcessContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ProcessContainer_deltaMC__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ProcessContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ProcessContainer_deltaMC__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ProcessContainer_deltaMC'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ProcessContainer::deltaMC(bool)\n"
    "    Pythia8::ProcessContainer::deltaMC()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_id1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_id1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_id1" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (int)((Pythia8::ProcessContainer const *)arg1)->id1();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_id2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_id2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_id2" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (int)((Pythia8::ProcessContainer const *)arg1)->id2();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_x1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_x1",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_x1" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (double)((Pythia8::ProcessContainer const *)arg1)->x1();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_x2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_x2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_x2" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (double)((Pythia8::ProcessContainer const *)arg1)->x2();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_Q2Fac(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_Q2Fac",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_Q2Fac" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (double)((Pythia8::ProcessContainer const *)arg1)->Q2Fac();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_mHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_mHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_mHat" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (double)((Pythia8::ProcessContainer const *)arg1)->mHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_pTHat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_pTHat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_pTHat" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (double)((Pythia8::ProcessContainer const *)arg1)->pTHat();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_isLHAContainer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_isLHAContainer",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_isLHAContainer" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (bool)((Pythia8::ProcessContainer const *)arg1)->isLHAContainer();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_lhaStrategy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_lhaStrategy",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_lhaStrategy" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (int)((Pythia8::ProcessContainer const *)arg1)->lhaStrategy();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_codeLHASize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_codeLHASize",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_codeLHASize" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (int)((Pythia8::ProcessContainer const *)arg1)->codeLHASize();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_subCodeLHA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProcessContainer_subCodeLHA",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_subCodeLHA" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessContainer_subCodeLHA" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (int)((Pythia8::ProcessContainer const *)arg1)->subCodeLHA(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_nTriedLHA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  long result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProcessContainer_nTriedLHA",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_nTriedLHA" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessContainer_nTriedLHA" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (long)((Pythia8::ProcessContainer const *)arg1)->nTriedLHA(arg2);
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_nSelectedLHA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  long result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProcessContainer_nSelectedLHA",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_nSelectedLHA" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessContainer_nSelectedLHA" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (long)((Pythia8::ProcessContainer const *)arg1)->nSelectedLHA(arg2);
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_nAcceptedLHA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  long result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProcessContainer_nAcceptedLHA",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_nAcceptedLHA" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessContainer_nAcceptedLHA" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (long)((Pythia8::ProcessContainer const *)arg1)->nAcceptedLHA(arg2);
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_isSame__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProcessContainer_isSame",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_isSame" "', argument " "1"" of type '" "Pythia8::ProcessContainer *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessContainer_isSame" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->isSame(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_isSame__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessContainer *arg1 = (Pythia8::ProcessContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessContainer_isSame",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessContainer_isSame" "', argument " "1"" of type '" "Pythia8::ProcessContainer const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessContainer * >(argp1);
  result = (bool)((Pythia8::ProcessContainer const *)arg1)->isSame();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessContainer_isSame(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ProcessContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ProcessContainer_isSame__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ProcessContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ProcessContainer_isSame__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ProcessContainer_isSame'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ProcessContainer::isSame(bool)\n"
    "    Pythia8::ProcessContainer::isSame() const\n");
  return 0;
}


SWIGINTERN PyObject *ProcessContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ProcessContainer, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SetupContainers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SetupContainers *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SetupContainers")) SWIG_fail;
  result = (Pythia8::SetupContainers *)new Pythia8::SetupContainers();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SetupContainers, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SetupContainers_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SetupContainers *arg1 = (Pythia8::SetupContainers *) 0 ;
  std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > *arg2 = 0 ;
  Pythia8::Info *arg3 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg4 = 0 ;
  Pythia8::ParticleData *arg5 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Couplings *arg6 = (Pythia8::Couplings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SetupContainers_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SetupContainers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetupContainers_init" "', argument " "1"" of type '" "Pythia8::SetupContainers *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SetupContainers * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetupContainers_init" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetupContainers_init" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SetupContainers_init" "', argument " "3"" of type '" "Pythia8::Info *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Info * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SetupContainers_init" "', argument " "4"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetupContainers_init" "', argument " "4"" of type '" "Pythia8::Settings &""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Settings * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SetupContainers_init" "', argument " "5"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::ParticleData * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SetupContainers_init" "', argument " "6"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::Couplings * >(argp6);
  result = (bool)(arg1)->init(*arg2,arg3,*arg4,arg5,arg6);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SetupContainers_init2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SetupContainers *arg1 = (Pythia8::SetupContainers *) 0 ;
  std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > *arg2 = 0 ;
  Pythia8::Settings *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SetupContainers_init2",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SetupContainers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetupContainers_init2" "', argument " "1"" of type '" "Pythia8::SetupContainers *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SetupContainers * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetupContainers_init2" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetupContainers_init2" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SetupContainers_init2" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetupContainers_init2" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  result = (bool)(arg1)->init2(*arg2,*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SetupContainers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SetupContainers *arg1 = (Pythia8::SetupContainers *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SetupContainers",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SetupContainers, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SetupContainers" "', argument " "1"" of type '" "Pythia8::SetupContainers *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SetupContainers * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SetupContainers_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SetupContainers, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ProcessLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessLevel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ProcessLevel")) SWIG_fail;
  result = (Pythia8::ProcessLevel *)new Pythia8::ProcessLevel();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ProcessLevel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ProcessLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessLevel *arg1 = (Pythia8::ProcessLevel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ProcessLevel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessLevel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ProcessLevel" "', argument " "1"" of type '" "Pythia8::ProcessLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessLevel * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessLevel_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessLevel *arg1 = (Pythia8::ProcessLevel *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  Pythia8::BeamParticle *arg6 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg7 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg8 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg9 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg10 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg11 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::Couplings *arg12 = (Pythia8::Couplings *) 0 ;
  Pythia8::SigmaTotal *arg13 = (Pythia8::SigmaTotal *) 0 ;
  bool arg14 ;
  Pythia8::SLHAinterface *arg15 = (Pythia8::SLHAinterface *) 0 ;
  Pythia8::UserHooks *arg16 = (Pythia8::UserHooks *) 0 ;
  std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > *arg17 = 0 ;
  std::vector< Pythia8::PhaseSpace *,std::allocator< Pythia8::PhaseSpace * > > *arg18 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOO:ProcessLevel_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessLevel_init" "', argument " "1"" of type '" "Pythia8::ProcessLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessLevel * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProcessLevel_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ProcessLevel_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProcessLevel_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ProcessLevel_init" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ProcessLevel_init" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ProcessLevel_init" "', argument " "6"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::BeamParticle * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ProcessLevel_init" "', argument " "7"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::BeamParticle * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ProcessLevel_init" "', argument " "8"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::BeamParticle * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "ProcessLevel_init" "', argument " "9"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::BeamParticle * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ProcessLevel_init" "', argument " "10"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg10 = reinterpret_cast< Pythia8::BeamParticle * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ProcessLevel_init" "', argument " "11"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg11 = reinterpret_cast< Pythia8::BeamParticle * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12,SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ProcessLevel_init" "', argument " "12"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg12 = reinterpret_cast< Pythia8::Couplings * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ProcessLevel_init" "', argument " "13"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg13 = reinterpret_cast< Pythia8::SigmaTotal * >(argp13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ProcessLevel_init" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  res15 = SWIG_ConvertPtr(obj14, &argp15,SWIGTYPE_p_Pythia8__SLHAinterface, 0 |  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "ProcessLevel_init" "', argument " "15"" of type '" "Pythia8::SLHAinterface *""'"); 
  }
  arg15 = reinterpret_cast< Pythia8::SLHAinterface * >(argp15);
  res16 = SWIG_ConvertPtr(obj15, &argp16,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "ProcessLevel_init" "', argument " "16"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg16 = reinterpret_cast< Pythia8::UserHooks * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17, SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t,  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "ProcessLevel_init" "', argument " "17"" of type '" "std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &""'"); 
  }
  if (!argp17) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProcessLevel_init" "', argument " "17"" of type '" "std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > &""'"); 
  }
  arg17 = reinterpret_cast< std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > * >(argp17);
  res18 = SWIG_ConvertPtr(obj17, &argp18, SWIGTYPE_p_std__vectorT_Pythia8__PhaseSpace_p_std__allocatorT_Pythia8__PhaseSpace_p_t_t,  0 );
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "ProcessLevel_init" "', argument " "18"" of type '" "std::vector< Pythia8::PhaseSpace *,std::allocator< Pythia8::PhaseSpace * > > &""'"); 
  }
  if (!argp18) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProcessLevel_init" "', argument " "18"" of type '" "std::vector< Pythia8::PhaseSpace *,std::allocator< Pythia8::PhaseSpace * > > &""'"); 
  }
  arg18 = reinterpret_cast< std::vector< Pythia8::PhaseSpace *,std::allocator< Pythia8::PhaseSpace * > > * >(argp18);
  result = (bool)(arg1)->init(arg2,*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,*arg17,*arg18);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessLevel_setLHAPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessLevel *arg1 = (Pythia8::ProcessLevel *) 0 ;
  Pythia8::LHAup *arg2 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProcessLevel_setLHAPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessLevel_setLHAPtr" "', argument " "1"" of type '" "Pythia8::ProcessLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessLevel * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProcessLevel_setLHAPtr" "', argument " "2"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHAup * >(argp2);
  (arg1)->setLHAPtr(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessLevel_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessLevel *arg1 = (Pythia8::ProcessLevel *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProcessLevel_next",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessLevel_next" "', argument " "1"" of type '" "Pythia8::ProcessLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessLevel * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProcessLevel_next" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProcessLevel_next" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->next(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessLevel_nextLHAdec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessLevel *arg1 = (Pythia8::ProcessLevel *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProcessLevel_nextLHAdec",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessLevel_nextLHAdec" "', argument " "1"" of type '" "Pythia8::ProcessLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessLevel * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProcessLevel_nextLHAdec" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProcessLevel_nextLHAdec" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->nextLHAdec(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessLevel_accumulate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessLevel *arg1 = (Pythia8::ProcessLevel *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProcessLevel_accumulate",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessLevel_accumulate" "', argument " "1"" of type '" "Pythia8::ProcessLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessLevel * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessLevel_accumulate" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->accumulate(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessLevel_accumulate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessLevel *arg1 = (Pythia8::ProcessLevel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessLevel_accumulate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessLevel_accumulate" "', argument " "1"" of type '" "Pythia8::ProcessLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessLevel * >(argp1);
  (arg1)->accumulate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessLevel_accumulate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ProcessLevel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ProcessLevel_accumulate__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ProcessLevel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ProcessLevel_accumulate__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ProcessLevel_accumulate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ProcessLevel::accumulate(bool)\n"
    "    Pythia8::ProcessLevel::accumulate()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ProcessLevel_statistics__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessLevel *arg1 = (Pythia8::ProcessLevel *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProcessLevel_statistics",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessLevel_statistics" "', argument " "1"" of type '" "Pythia8::ProcessLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessLevel * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessLevel_statistics" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->statistics(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessLevel_statistics__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessLevel *arg1 = (Pythia8::ProcessLevel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessLevel_statistics",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessLevel_statistics" "', argument " "1"" of type '" "Pythia8::ProcessLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessLevel * >(argp1);
  (arg1)->statistics();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessLevel_statistics(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ProcessLevel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ProcessLevel_statistics__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ProcessLevel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ProcessLevel_statistics__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ProcessLevel_statistics'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ProcessLevel::statistics(bool)\n"
    "    Pythia8::ProcessLevel::statistics()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ProcessLevel_resetStatistics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessLevel *arg1 = (Pythia8::ProcessLevel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ProcessLevel_resetStatistics",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessLevel_resetStatistics" "', argument " "1"" of type '" "Pythia8::ProcessLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessLevel * >(argp1);
  (arg1)->resetStatistics();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessLevel_findJunctions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessLevel *arg1 = (Pythia8::ProcessLevel *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProcessLevel_findJunctions",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessLevel_findJunctions" "', argument " "1"" of type '" "Pythia8::ProcessLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessLevel * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProcessLevel_findJunctions" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProcessLevel_findJunctions" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  (arg1)->findJunctions(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessLevel_initDecays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessLevel *arg1 = (Pythia8::ProcessLevel *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  Pythia8::LHAup *arg6 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ProcessLevel_initDecays",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessLevel_initDecays" "', argument " "1"" of type '" "Pythia8::ProcessLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessLevel * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProcessLevel_initDecays" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ProcessLevel_initDecays" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProcessLevel_initDecays" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ProcessLevel_initDecays" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ProcessLevel_initDecays" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ProcessLevel_initDecays" "', argument " "6"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::LHAup * >(argp6);
  (arg1)->initDecays(arg2,*arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ProcessLevel_nextDecays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ProcessLevel *arg1 = (Pythia8::ProcessLevel *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ProcessLevel_nextDecays",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ProcessLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessLevel_nextDecays" "', argument " "1"" of type '" "Pythia8::ProcessLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ProcessLevel * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProcessLevel_nextDecays" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProcessLevel_nextDecays" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->nextDecays(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ProcessLevel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ProcessLevel, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_BeamRemnants(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamRemnants *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_BeamRemnants")) SWIG_fail;
  result = (Pythia8::BeamRemnants *)new Pythia8::BeamRemnants();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__BeamRemnants, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamRemnants_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamRemnants *arg1 = (Pythia8::BeamRemnants *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::Rndm *arg4 = (Pythia8::Rndm *) 0 ;
  Pythia8::BeamParticle *arg5 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg6 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::PartonSystems *arg7 = (Pythia8::PartonSystems *) 0 ;
  Pythia8::PartonVertex *arg8 = (Pythia8::PartonVertex *) 0 ;
  Pythia8::ParticleData *arg9 = (Pythia8::ParticleData *) 0 ;
  Pythia8::ColourReconnection *arg10 = (Pythia8::ColourReconnection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:BeamRemnants_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamRemnants, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamRemnants_init" "', argument " "1"" of type '" "Pythia8::BeamRemnants *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamRemnants * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BeamRemnants_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BeamRemnants_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BeamRemnants_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BeamRemnants_init" "', argument " "4"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Rndm * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BeamRemnants_init" "', argument " "5"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::BeamParticle * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BeamRemnants_init" "', argument " "6"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::BeamParticle * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BeamRemnants_init" "', argument " "7"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::PartonSystems * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__PartonVertex, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "BeamRemnants_init" "', argument " "8"" of type '" "Pythia8::PartonVertex *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::PartonVertex * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "BeamRemnants_init" "', argument " "9"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::ParticleData * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_Pythia8__ColourReconnection, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "BeamRemnants_init" "', argument " "10"" of type '" "Pythia8::ColourReconnection *""'"); 
  }
  arg10 = reinterpret_cast< Pythia8::ColourReconnection * >(argp10);
  result = (bool)(arg1)->init(arg2,*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamRemnants_reassignBeamPtrs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamRemnants *arg1 = (Pythia8::BeamRemnants *) 0 ;
  Pythia8::BeamParticle *arg2 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg3 = (Pythia8::BeamParticle *) 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:BeamRemnants_reassignBeamPtrs",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamRemnants, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamRemnants_reassignBeamPtrs" "', argument " "1"" of type '" "Pythia8::BeamRemnants *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamRemnants * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BeamRemnants_reassignBeamPtrs" "', argument " "2"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::BeamParticle * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BeamRemnants_reassignBeamPtrs" "', argument " "3"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::BeamParticle * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BeamRemnants_reassignBeamPtrs" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->reassignBeamPtrs(arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamRemnants_add__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamRemnants *arg1 = (Pythia8::BeamRemnants *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:BeamRemnants_add",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamRemnants, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamRemnants_add" "', argument " "1"" of type '" "Pythia8::BeamRemnants *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamRemnants * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BeamRemnants_add" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BeamRemnants_add" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamRemnants_add" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BeamRemnants_add" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (bool)(arg1)->add(*arg2,arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamRemnants_add__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamRemnants *arg1 = (Pythia8::BeamRemnants *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:BeamRemnants_add",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamRemnants, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamRemnants_add" "', argument " "1"" of type '" "Pythia8::BeamRemnants *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamRemnants * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BeamRemnants_add" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BeamRemnants_add" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BeamRemnants_add" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (bool)(arg1)->add(*arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamRemnants_add__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamRemnants *arg1 = (Pythia8::BeamRemnants *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:BeamRemnants_add",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamRemnants, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeamRemnants_add" "', argument " "1"" of type '" "Pythia8::BeamRemnants *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamRemnants * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BeamRemnants_add" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BeamRemnants_add" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->add(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_BeamRemnants_add(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamRemnants, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BeamRemnants_add__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamRemnants, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BeamRemnants_add__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__BeamRemnants, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_BeamRemnants_add__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BeamRemnants_add'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::BeamRemnants::add(Pythia8::Event &,int,bool)\n"
    "    Pythia8::BeamRemnants::add(Pythia8::Event &,int)\n"
    "    Pythia8::BeamRemnants::add(Pythia8::Event &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_BeamRemnants(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::BeamRemnants *arg1 = (Pythia8::BeamRemnants *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_BeamRemnants",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__BeamRemnants, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BeamRemnants" "', argument " "1"" of type '" "Pythia8::BeamRemnants *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::BeamRemnants * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *BeamRemnants_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__BeamRemnants, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_HadronLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronLevel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HadronLevel")) SWIG_fail;
  result = (Pythia8::HadronLevel *)new Pythia8::HadronLevel();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HadronLevel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HadronLevel_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronLevel *arg1 = (Pythia8::HadronLevel *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  Pythia8::Couplings *arg6 = (Pythia8::Couplings *) 0 ;
  Pythia8::TimeShower *arg7 = (Pythia8::TimeShower *) 0 ;
  Pythia8::RHadrons *arg8 = (Pythia8::RHadrons *) 0 ;
  Pythia8::DecayHandler *arg9 = (Pythia8::DecayHandler *) 0 ;
  std::vector< int,std::allocator< int > > arg10 ;
  Pythia8::UserHooks *arg11 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:HadronLevel_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HadronLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HadronLevel_init" "', argument " "1"" of type '" "Pythia8::HadronLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HadronLevel * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HadronLevel_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HadronLevel_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HadronLevel_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "HadronLevel_init" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "HadronLevel_init" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "HadronLevel_init" "', argument " "6"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::Couplings * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "HadronLevel_init" "', argument " "7"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::TimeShower * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__RHadrons, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "HadronLevel_init" "', argument " "8"" of type '" "Pythia8::RHadrons *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::RHadrons * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__DecayHandler, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "HadronLevel_init" "', argument " "9"" of type '" "Pythia8::DecayHandler *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::DecayHandler * >(argp9);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj9, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HadronLevel_init" "', argument " "10"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg10 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "HadronLevel_init" "', argument " "11"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg11 = reinterpret_cast< Pythia8::UserHooks * >(argp11);
  result = (bool)(arg1)->init(arg2,*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HadronLevel_getStringFlavPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronLevel *arg1 = (Pythia8::HadronLevel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::StringFlav *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HadronLevel_getStringFlavPtr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HadronLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HadronLevel_getStringFlavPtr" "', argument " "1"" of type '" "Pythia8::HadronLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HadronLevel * >(argp1);
  result = (Pythia8::StringFlav *)(arg1)->getStringFlavPtr();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__StringFlav, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HadronLevel_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronLevel *arg1 = (Pythia8::HadronLevel *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HadronLevel_next",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HadronLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HadronLevel_next" "', argument " "1"" of type '" "Pythia8::HadronLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HadronLevel * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HadronLevel_next" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HadronLevel_next" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->next(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HadronLevel_moreDecays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronLevel *arg1 = (Pythia8::HadronLevel *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HadronLevel_moreDecays",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HadronLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HadronLevel_moreDecays" "', argument " "1"" of type '" "Pythia8::HadronLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HadronLevel * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HadronLevel_moreDecays" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HadronLevel_moreDecays" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->moreDecays(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HadronLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HadronLevel *arg1 = (Pythia8::HadronLevel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HadronLevel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HadronLevel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HadronLevel" "', argument " "1"" of type '" "Pythia8::HadronLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HadronLevel * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HadronLevel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HadronLevel, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_HardDiffraction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardDiffraction *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HardDiffraction")) SWIG_fail;
  result = (Pythia8::HardDiffraction *)new Pythia8::HardDiffraction();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HardDiffraction, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HardDiffraction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardDiffraction *arg1 = (Pythia8::HardDiffraction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HardDiffraction",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardDiffraction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HardDiffraction" "', argument " "1"" of type '" "Pythia8::HardDiffraction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardDiffraction * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardDiffraction_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardDiffraction *arg1 = (Pythia8::HardDiffraction *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::Rndm *arg4 = (Pythia8::Rndm *) 0 ;
  Pythia8::BeamParticle *arg5 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg6 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg7 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg8 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::SigmaTotal *arg9 = (Pythia8::SigmaTotal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:HardDiffraction_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardDiffraction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardDiffraction_init" "', argument " "1"" of type '" "Pythia8::HardDiffraction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardDiffraction * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HardDiffraction_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HardDiffraction_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HardDiffraction_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "HardDiffraction_init" "', argument " "4"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Rndm * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "HardDiffraction_init" "', argument " "5"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::BeamParticle * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "HardDiffraction_init" "', argument " "6"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::BeamParticle * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "HardDiffraction_init" "', argument " "7"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::BeamParticle * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "HardDiffraction_init" "', argument " "8"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::BeamParticle * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "HardDiffraction_init" "', argument " "9"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::SigmaTotal * >(argp9);
  (arg1)->init(arg2,*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardDiffraction_isDiffractive__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardDiffraction *arg1 = (Pythia8::HardDiffraction *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:HardDiffraction_isDiffractive",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardDiffraction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardDiffraction_isDiffractive" "', argument " "1"" of type '" "Pythia8::HardDiffraction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardDiffraction * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HardDiffraction_isDiffractive" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HardDiffraction_isDiffractive" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HardDiffraction_isDiffractive" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "HardDiffraction_isDiffractive" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "HardDiffraction_isDiffractive" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = (bool)(arg1)->isDiffractive(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardDiffraction_isDiffractive__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardDiffraction *arg1 = (Pythia8::HardDiffraction *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:HardDiffraction_isDiffractive",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardDiffraction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardDiffraction_isDiffractive" "', argument " "1"" of type '" "Pythia8::HardDiffraction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardDiffraction * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HardDiffraction_isDiffractive" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HardDiffraction_isDiffractive" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HardDiffraction_isDiffractive" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "HardDiffraction_isDiffractive" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (bool)(arg1)->isDiffractive(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardDiffraction_isDiffractive__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardDiffraction *arg1 = (Pythia8::HardDiffraction *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:HardDiffraction_isDiffractive",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardDiffraction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardDiffraction_isDiffractive" "', argument " "1"" of type '" "Pythia8::HardDiffraction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardDiffraction * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HardDiffraction_isDiffractive" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HardDiffraction_isDiffractive" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HardDiffraction_isDiffractive" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->isDiffractive(arg2,arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardDiffraction_isDiffractive__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardDiffraction *arg1 = (Pythia8::HardDiffraction *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:HardDiffraction_isDiffractive",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardDiffraction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardDiffraction_isDiffractive" "', argument " "1"" of type '" "Pythia8::HardDiffraction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardDiffraction * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HardDiffraction_isDiffractive" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HardDiffraction_isDiffractive" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (bool)(arg1)->isDiffractive(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardDiffraction_isDiffractive__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardDiffraction *arg1 = (Pythia8::HardDiffraction *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HardDiffraction_isDiffractive",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardDiffraction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardDiffraction_isDiffractive" "', argument " "1"" of type '" "Pythia8::HardDiffraction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardDiffraction * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HardDiffraction_isDiffractive" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->isDiffractive(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardDiffraction_isDiffractive__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardDiffraction *arg1 = (Pythia8::HardDiffraction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardDiffraction_isDiffractive",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardDiffraction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardDiffraction_isDiffractive" "', argument " "1"" of type '" "Pythia8::HardDiffraction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardDiffraction * >(argp1);
  result = (bool)(arg1)->isDiffractive();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardDiffraction_isDiffractive(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HardDiffraction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_HardDiffraction_isDiffractive__SWIG_5(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HardDiffraction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_HardDiffraction_isDiffractive__SWIG_4(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HardDiffraction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_HardDiffraction_isDiffractive__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HardDiffraction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_HardDiffraction_isDiffractive__SWIG_2(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HardDiffraction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_HardDiffraction_isDiffractive__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HardDiffraction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_HardDiffraction_isDiffractive__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'HardDiffraction_isDiffractive'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::HardDiffraction::isDiffractive(int,int,double,double,double)\n"
    "    Pythia8::HardDiffraction::isDiffractive(int,int,double,double)\n"
    "    Pythia8::HardDiffraction::isDiffractive(int,int,double)\n"
    "    Pythia8::HardDiffraction::isDiffractive(int,int)\n"
    "    Pythia8::HardDiffraction::isDiffractive(int)\n"
    "    Pythia8::HardDiffraction::isDiffractive()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HardDiffraction_getXPomeronA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardDiffraction *arg1 = (Pythia8::HardDiffraction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardDiffraction_getXPomeronA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardDiffraction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardDiffraction_getXPomeronA" "', argument " "1"" of type '" "Pythia8::HardDiffraction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardDiffraction * >(argp1);
  result = (double)(arg1)->getXPomeronA();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardDiffraction_getXPomeronB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardDiffraction *arg1 = (Pythia8::HardDiffraction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardDiffraction_getXPomeronB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardDiffraction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardDiffraction_getXPomeronB" "', argument " "1"" of type '" "Pythia8::HardDiffraction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardDiffraction * >(argp1);
  result = (double)(arg1)->getXPomeronB();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardDiffraction_getTPomeronA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardDiffraction *arg1 = (Pythia8::HardDiffraction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardDiffraction_getTPomeronA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardDiffraction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardDiffraction_getTPomeronA" "', argument " "1"" of type '" "Pythia8::HardDiffraction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardDiffraction * >(argp1);
  result = (double)(arg1)->getTPomeronA();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardDiffraction_getTPomeronB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardDiffraction *arg1 = (Pythia8::HardDiffraction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardDiffraction_getTPomeronB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardDiffraction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardDiffraction_getTPomeronB" "', argument " "1"" of type '" "Pythia8::HardDiffraction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardDiffraction * >(argp1);
  result = (double)(arg1)->getTPomeronB();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardDiffraction_getThetaPomeronA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardDiffraction *arg1 = (Pythia8::HardDiffraction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardDiffraction_getThetaPomeronA",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardDiffraction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardDiffraction_getThetaPomeronA" "', argument " "1"" of type '" "Pythia8::HardDiffraction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardDiffraction * >(argp1);
  result = (double)(arg1)->getThetaPomeronA();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HardDiffraction_getThetaPomeronB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HardDiffraction *arg1 = (Pythia8::HardDiffraction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HardDiffraction_getThetaPomeronB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HardDiffraction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HardDiffraction_getThetaPomeronB" "', argument " "1"" of type '" "Pythia8::HardDiffraction *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HardDiffraction * >(argp1);
  result = (double)(arg1)->getThetaPomeronB();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HardDiffraction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HardDiffraction, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PartonLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonLevel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PartonLevel")) SWIG_fail;
  result = (Pythia8::PartonLevel *)new Pythia8::PartonLevel();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PartonLevel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonLevel_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonLevel *arg1 = (Pythia8::PartonLevel *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  Pythia8::BeamParticle *arg6 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg7 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg8 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg9 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg10 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg11 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg12 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg13 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::Couplings *arg14 = (Pythia8::Couplings *) 0 ;
  Pythia8::PartonSystems *arg15 = (Pythia8::PartonSystems *) 0 ;
  Pythia8::SigmaTotal *arg16 = (Pythia8::SigmaTotal *) 0 ;
  Pythia8::TimeShower *arg17 = (Pythia8::TimeShower *) 0 ;
  Pythia8::TimeShower *arg18 = (Pythia8::TimeShower *) 0 ;
  Pythia8::SpaceShower *arg19 = (Pythia8::SpaceShower *) 0 ;
  Pythia8::RHadrons *arg20 = (Pythia8::RHadrons *) 0 ;
  Pythia8::UserHooks *arg21 = (Pythia8::UserHooks *) 0 ;
  Pythia8::MergingHooks *arg22 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::PartonVertex *arg23 = (Pythia8::PartonVertex *) 0 ;
  bool arg24 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  void *argp19 = 0 ;
  int res19 = 0 ;
  void *argp20 = 0 ;
  int res20 = 0 ;
  void *argp21 = 0 ;
  int res21 = 0 ;
  void *argp22 = 0 ;
  int res22 = 0 ;
  void *argp23 = 0 ;
  int res23 = 0 ;
  bool val24 ;
  int ecode24 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOOOOOOOOO:PartonLevel_init",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16,&obj17,&obj18,&obj19,&obj20,&obj21,&obj22,&obj23)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonLevel_init" "', argument " "1"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonLevel * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PartonLevel_init" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PartonLevel_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PartonLevel_init" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PartonLevel_init" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "PartonLevel_init" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "PartonLevel_init" "', argument " "6"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::BeamParticle * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "PartonLevel_init" "', argument " "7"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::BeamParticle * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "PartonLevel_init" "', argument " "8"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::BeamParticle * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "PartonLevel_init" "', argument " "9"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::BeamParticle * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "PartonLevel_init" "', argument " "10"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg10 = reinterpret_cast< Pythia8::BeamParticle * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "PartonLevel_init" "', argument " "11"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg11 = reinterpret_cast< Pythia8::BeamParticle * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "PartonLevel_init" "', argument " "12"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg12 = reinterpret_cast< Pythia8::BeamParticle * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "PartonLevel_init" "', argument " "13"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg13 = reinterpret_cast< Pythia8::BeamParticle * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14,SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "PartonLevel_init" "', argument " "14"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg14 = reinterpret_cast< Pythia8::Couplings * >(argp14);
  res15 = SWIG_ConvertPtr(obj14, &argp15,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "PartonLevel_init" "', argument " "15"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg15 = reinterpret_cast< Pythia8::PartonSystems * >(argp15);
  res16 = SWIG_ConvertPtr(obj15, &argp16,SWIGTYPE_p_Pythia8__SigmaTotal, 0 |  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "PartonLevel_init" "', argument " "16"" of type '" "Pythia8::SigmaTotal *""'"); 
  }
  arg16 = reinterpret_cast< Pythia8::SigmaTotal * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "PartonLevel_init" "', argument " "17"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg17 = reinterpret_cast< Pythia8::TimeShower * >(argp17);
  res18 = SWIG_ConvertPtr(obj17, &argp18,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "PartonLevel_init" "', argument " "18"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg18 = reinterpret_cast< Pythia8::TimeShower * >(argp18);
  res19 = SWIG_ConvertPtr(obj18, &argp19,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res19)) {
    SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "PartonLevel_init" "', argument " "19"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg19 = reinterpret_cast< Pythia8::SpaceShower * >(argp19);
  res20 = SWIG_ConvertPtr(obj19, &argp20,SWIGTYPE_p_Pythia8__RHadrons, 0 |  0 );
  if (!SWIG_IsOK(res20)) {
    SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "PartonLevel_init" "', argument " "20"" of type '" "Pythia8::RHadrons *""'"); 
  }
  arg20 = reinterpret_cast< Pythia8::RHadrons * >(argp20);
  res21 = SWIG_ConvertPtr(obj20, &argp21,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res21)) {
    SWIG_exception_fail(SWIG_ArgError(res21), "in method '" "PartonLevel_init" "', argument " "21"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg21 = reinterpret_cast< Pythia8::UserHooks * >(argp21);
  res22 = SWIG_ConvertPtr(obj21, &argp22,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res22)) {
    SWIG_exception_fail(SWIG_ArgError(res22), "in method '" "PartonLevel_init" "', argument " "22"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg22 = reinterpret_cast< Pythia8::MergingHooks * >(argp22);
  res23 = SWIG_ConvertPtr(obj22, &argp23,SWIGTYPE_p_Pythia8__PartonVertex, 0 |  0 );
  if (!SWIG_IsOK(res23)) {
    SWIG_exception_fail(SWIG_ArgError(res23), "in method '" "PartonLevel_init" "', argument " "23"" of type '" "Pythia8::PartonVertex *""'"); 
  }
  arg23 = reinterpret_cast< Pythia8::PartonVertex * >(argp23);
  ecode24 = SWIG_AsVal_bool(obj23, &val24);
  if (!SWIG_IsOK(ecode24)) {
    SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "PartonLevel_init" "', argument " "24"" of type '" "bool""'");
  } 
  arg24 = static_cast< bool >(val24);
  result = (bool)(arg1)->init(arg2,*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonLevel_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonLevel *arg1 = (Pythia8::PartonLevel *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PartonLevel_next",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonLevel_next" "', argument " "1"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonLevel * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PartonLevel_next" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PartonLevel_next" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PartonLevel_next" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PartonLevel_next" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  result = (bool)(arg1)->next(*arg2,*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonLevel_setupShowerSys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonLevel *arg1 = (Pythia8::PartonLevel *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PartonLevel_setupShowerSys",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonLevel_setupShowerSys" "', argument " "1"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonLevel * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PartonLevel_setupShowerSys" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PartonLevel_setupShowerSys" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PartonLevel_setupShowerSys" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PartonLevel_setupShowerSys" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  (arg1)->setupShowerSys(*arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonLevel_resonanceShowers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonLevel *arg1 = (Pythia8::PartonLevel *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  Pythia8::Event *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:PartonLevel_resonanceShowers",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonLevel_resonanceShowers" "', argument " "1"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonLevel * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PartonLevel_resonanceShowers" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PartonLevel_resonanceShowers" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PartonLevel_resonanceShowers" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PartonLevel_resonanceShowers" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PartonLevel_resonanceShowers" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (bool)(arg1)->resonanceShowers(*arg2,*arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonLevel_wzDecayShowers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonLevel *arg1 = (Pythia8::PartonLevel *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PartonLevel_wzDecayShowers",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonLevel_wzDecayShowers" "', argument " "1"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonLevel * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PartonLevel_wzDecayShowers" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PartonLevel_wzDecayShowers" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->wzDecayShowers(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonLevel_hasVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonLevel *arg1 = (Pythia8::PartonLevel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PartonLevel_hasVetoed",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonLevel_hasVetoed" "', argument " "1"" of type '" "Pythia8::PartonLevel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonLevel * >(argp1);
  result = (bool)((Pythia8::PartonLevel const *)arg1)->hasVetoed();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonLevel_hasVetoedDiff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonLevel *arg1 = (Pythia8::PartonLevel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PartonLevel_hasVetoedDiff",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonLevel_hasVetoedDiff" "', argument " "1"" of type '" "Pythia8::PartonLevel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonLevel * >(argp1);
  result = (bool)((Pythia8::PartonLevel const *)arg1)->hasVetoedDiff();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonLevel_accumulate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonLevel *arg1 = (Pythia8::PartonLevel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PartonLevel_accumulate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonLevel_accumulate" "', argument " "1"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonLevel * >(argp1);
  (arg1)->accumulate();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonLevel_statistics__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonLevel *arg1 = (Pythia8::PartonLevel *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PartonLevel_statistics",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonLevel_statistics" "', argument " "1"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonLevel * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PartonLevel_statistics" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->statistics(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonLevel_statistics__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonLevel *arg1 = (Pythia8::PartonLevel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PartonLevel_statistics",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonLevel_statistics" "', argument " "1"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonLevel * >(argp1);
  (arg1)->statistics();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonLevel_statistics(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PartonLevel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_PartonLevel_statistics__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__PartonLevel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PartonLevel_statistics__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'PartonLevel_statistics'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PartonLevel::statistics(bool)\n"
    "    Pythia8::PartonLevel::statistics()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PartonLevel_resetStatistics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonLevel *arg1 = (Pythia8::PartonLevel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PartonLevel_resetStatistics",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonLevel_resetStatistics" "', argument " "1"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonLevel * >(argp1);
  (arg1)->resetStatistics();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonLevel_resetTrial(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonLevel *arg1 = (Pythia8::PartonLevel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PartonLevel_resetTrial",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonLevel_resetTrial" "', argument " "1"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonLevel * >(argp1);
  (arg1)->resetTrial();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonLevel_pTLastInShower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonLevel *arg1 = (Pythia8::PartonLevel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PartonLevel_pTLastInShower",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonLevel_pTLastInShower" "', argument " "1"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonLevel * >(argp1);
  result = (double)(arg1)->pTLastInShower();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonLevel_typeLastInShower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonLevel *arg1 = (Pythia8::PartonLevel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PartonLevel_typeLastInShower",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonLevel_typeLastInShower" "', argument " "1"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonLevel * >(argp1);
  result = (int)(arg1)->typeLastInShower();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonLevel_timesDecPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonLevel *arg1 = (Pythia8::PartonLevel *) 0 ;
  Pythia8::TimeShower *arg2 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PartonLevel_timesDecPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonLevel_timesDecPtr_set" "', argument " "1"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonLevel * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__TimeShower, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PartonLevel_timesDecPtr_set" "', argument " "2"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::TimeShower * >(argp2);
  if (arg1) (arg1)->timesDecPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonLevel_timesDecPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonLevel *arg1 = (Pythia8::PartonLevel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::TimeShower *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PartonLevel_timesDecPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonLevel_timesDecPtr_get" "', argument " "1"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonLevel * >(argp1);
  result = (Pythia8::TimeShower *) ((arg1)->timesDecPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonLevel_timesPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonLevel *arg1 = (Pythia8::PartonLevel *) 0 ;
  Pythia8::TimeShower *arg2 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PartonLevel_timesPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonLevel_timesPtr_set" "', argument " "1"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonLevel * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__TimeShower, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PartonLevel_timesPtr_set" "', argument " "2"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::TimeShower * >(argp2);
  if (arg1) (arg1)->timesPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonLevel_timesPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonLevel *arg1 = (Pythia8::PartonLevel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::TimeShower *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PartonLevel_timesPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonLevel_timesPtr_get" "', argument " "1"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonLevel * >(argp1);
  result = (Pythia8::TimeShower *) ((arg1)->timesPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonLevel_spacePtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonLevel *arg1 = (Pythia8::PartonLevel *) 0 ;
  Pythia8::SpaceShower *arg2 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PartonLevel_spacePtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonLevel_spacePtr_set" "', argument " "1"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonLevel * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__SpaceShower, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PartonLevel_spacePtr_set" "', argument " "2"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::SpaceShower * >(argp2);
  if (arg1) (arg1)->spacePtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonLevel_spacePtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonLevel *arg1 = (Pythia8::PartonLevel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::SpaceShower *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PartonLevel_spacePtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonLevel_spacePtr_get" "', argument " "1"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonLevel * >(argp1);
  result = (Pythia8::SpaceShower *) ((arg1)->spacePtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonLevel_userHooksPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonLevel *arg1 = (Pythia8::PartonLevel *) 0 ;
  Pythia8::UserHooks *arg2 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PartonLevel_userHooksPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonLevel_userHooksPtr_set" "', argument " "1"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonLevel * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__UserHooks, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PartonLevel_userHooksPtr_set" "', argument " "2"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::UserHooks * >(argp2);
  if (arg1) (arg1)->userHooksPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PartonLevel_userHooksPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonLevel *arg1 = (Pythia8::PartonLevel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::UserHooks *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PartonLevel_userHooksPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PartonLevel_userHooksPtr_get" "', argument " "1"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonLevel * >(argp1);
  result = (Pythia8::UserHooks *) ((arg1)->userHooksPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PartonLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PartonLevel *arg1 = (Pythia8::PartonLevel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PartonLevel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PartonLevel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PartonLevel" "', argument " "1"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PartonLevel * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PartonLevel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__PartonLevel, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_Clustering_emitted_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Clustering_emitted_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering_emitted_set" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clustering_emitted_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->emitted = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Clustering_emitted_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Clustering_emitted_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering_emitted_get" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  result = (int) ((arg1)->emitted);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Clustering_emittor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Clustering_emittor_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering_emittor_set" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clustering_emittor_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->emittor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Clustering_emittor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Clustering_emittor_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering_emittor_get" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  result = (int) ((arg1)->emittor);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Clustering_recoiler_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Clustering_recoiler_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering_recoiler_set" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clustering_recoiler_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->recoiler = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Clustering_recoiler_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Clustering_recoiler_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering_recoiler_get" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  result = (int) ((arg1)->recoiler);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Clustering_partner_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Clustering_partner_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering_partner_set" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clustering_partner_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->partner = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Clustering_partner_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Clustering_partner_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering_partner_get" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  result = (int) ((arg1)->partner);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Clustering_pTscale_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Clustering_pTscale_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering_pTscale_set" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clustering_pTscale_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->pTscale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Clustering_pTscale_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Clustering_pTscale_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering_pTscale_get" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  result = (double) ((arg1)->pTscale);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Clustering_flavRadBef_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Clustering_flavRadBef_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering_flavRadBef_set" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clustering_flavRadBef_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->flavRadBef = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Clustering_flavRadBef_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Clustering_flavRadBef_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering_flavRadBef_get" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  result = (int) ((arg1)->flavRadBef);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Clustering_spinRad_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Clustering_spinRad_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering_spinRad_set" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clustering_spinRad_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->spinRad = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Clustering_spinRad_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Clustering_spinRad_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering_spinRad_get" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  result = (int) ((arg1)->spinRad);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Clustering_spinEmt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Clustering_spinEmt_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering_spinEmt_set" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clustering_spinEmt_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->spinEmt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Clustering_spinEmt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Clustering_spinEmt_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering_spinEmt_get" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  result = (int) ((arg1)->spinEmt);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Clustering_spinRec_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Clustering_spinRec_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering_spinRec_set" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clustering_spinRec_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->spinRec = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Clustering_spinRec_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Clustering_spinRec_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering_spinRec_get" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  result = (int) ((arg1)->spinRec);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Clustering_spinRadBef_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Clustering_spinRadBef_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering_spinRadBef_set" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clustering_spinRadBef_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->spinRadBef = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Clustering_spinRadBef_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Clustering_spinRadBef_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering_spinRadBef_get" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  result = (int) ((arg1)->spinRadBef);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Clustering_radBef_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Clustering_radBef_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering_radBef_set" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clustering_radBef_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->radBef = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Clustering_radBef_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Clustering_radBef_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering_radBef_get" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  result = (int) ((arg1)->radBef);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Clustering_recBef_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Clustering_recBef_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering_recBef_set" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clustering_recBef_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->recBef = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Clustering_recBef_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Clustering_recBef_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering_recBef_get" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  result = (int) ((arg1)->recBef);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Clustering__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Clustering")) SWIG_fail;
  result = (Pythia8::Clustering *)new Pythia8::Clustering();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Clustering, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Clustering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Clustering",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clustering" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Clustering__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Clustering *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Clustering",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Clustering,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Clustering" "', argument " "1"" of type '" "Pythia8::Clustering const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Clustering" "', argument " "1"" of type '" "Pythia8::Clustering const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  result = (Pythia8::Clustering *)new Pythia8::Clustering((Pythia8::Clustering const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Clustering, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Clustering__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int arg10 ;
  int arg11 ;
  int arg12 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  Pythia8::Clustering *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:new_Clustering",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Clustering" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Clustering" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Clustering" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Clustering" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Clustering" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Clustering" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Clustering" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Clustering" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Clustering" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_Clustering" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_Clustering" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_Clustering" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  result = (Pythia8::Clustering *)new Pythia8::Clustering(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Clustering, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Clustering__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int arg10 ;
  int arg11 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  Pythia8::Clustering *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:new_Clustering",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Clustering" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Clustering" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Clustering" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Clustering" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Clustering" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Clustering" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Clustering" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Clustering" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Clustering" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_Clustering" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_int(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_Clustering" "', argument " "11"" of type '" "int""'");
  } 
  arg11 = static_cast< int >(val11);
  result = (Pythia8::Clustering *)new Pythia8::Clustering(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Clustering, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Clustering__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int arg10 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  Pythia8::Clustering *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:new_Clustering",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Clustering" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Clustering" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Clustering" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Clustering" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Clustering" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Clustering" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Clustering" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Clustering" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Clustering" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_Clustering" "', argument " "10"" of type '" "int""'");
  } 
  arg10 = static_cast< int >(val10);
  result = (Pythia8::Clustering *)new Pythia8::Clustering(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Clustering, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Clustering__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int arg9 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  Pythia8::Clustering *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_Clustering",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Clustering" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Clustering" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Clustering" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Clustering" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Clustering" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Clustering" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Clustering" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Clustering" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Clustering" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  result = (Pythia8::Clustering *)new Pythia8::Clustering(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Clustering, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Clustering__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  Pythia8::Clustering *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:new_Clustering",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Clustering" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Clustering" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Clustering" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Clustering" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Clustering" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Clustering" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Clustering" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Clustering" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  result = (Pythia8::Clustering *)new Pythia8::Clustering(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Clustering, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Clustering__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  int arg6 ;
  int arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Pythia8::Clustering *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_Clustering",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Clustering" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Clustering" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Clustering" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Clustering" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Clustering" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Clustering" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Clustering" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  result = (Pythia8::Clustering *)new Pythia8::Clustering(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Clustering, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Clustering__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  int arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::Clustering *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_Clustering",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Clustering" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Clustering" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Clustering" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Clustering" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Clustering" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Clustering" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (Pythia8::Clustering *)new Pythia8::Clustering(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Clustering, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Clustering__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  double arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::Clustering *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_Clustering",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Clustering" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Clustering" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Clustering" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Clustering" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Clustering" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (Pythia8::Clustering *)new Pythia8::Clustering(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Clustering, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Clustering(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[13] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 12) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Clustering__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_Pythia8__Clustering, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Clustering__SWIG_1(self, args);
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Clustering__SWIG_9(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_Clustering__SWIG_8(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_Clustering__SWIG_7(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_Clustering__SWIG_6(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_Clustering__SWIG_5(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_Clustering__SWIG_4(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_Clustering__SWIG_3(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_new_Clustering__SWIG_2(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Clustering'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Clustering::Clustering()\n"
    "    Pythia8::Clustering::Clustering(Pythia8::Clustering const &)\n"
    "    Pythia8::Clustering::Clustering(int,int,int,int,double,int,int,int,int,int,int,int)\n"
    "    Pythia8::Clustering::Clustering(int,int,int,int,double,int,int,int,int,int,int)\n"
    "    Pythia8::Clustering::Clustering(int,int,int,int,double,int,int,int,int,int)\n"
    "    Pythia8::Clustering::Clustering(int,int,int,int,double,int,int,int,int)\n"
    "    Pythia8::Clustering::Clustering(int,int,int,int,double,int,int,int)\n"
    "    Pythia8::Clustering::Clustering(int,int,int,int,double,int,int)\n"
    "    Pythia8::Clustering::Clustering(int,int,int,int,double,int)\n"
    "    Pythia8::Clustering::Clustering(int,int,int,int,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Clustering_pT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Clustering_pT",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering_pT" "', argument " "1"" of type '" "Pythia8::Clustering const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  result = (double)((Pythia8::Clustering const *)arg1)->pT();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Clustering___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Clustering *arg1 = (Pythia8::Clustering *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Clustering___str__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clustering___str__" "', argument " "1"" of type '" "Pythia8::Clustering *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Clustering * >(argp1);
  result = Pythia8_Clustering___str__(arg1);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Clustering_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Clustering, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_History(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  Pythia8::Event arg3 ;
  Pythia8::Clustering arg4 ;
  Pythia8::MergingHooks *arg5 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::BeamParticle arg6 ;
  Pythia8::BeamParticle arg7 ;
  Pythia8::ParticleData *arg8 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Info *arg9 = (Pythia8::Info *) 0 ;
  Pythia8::PartonLevel *arg10 = (Pythia8::PartonLevel *) 0 ;
  Pythia8::CoupSM *arg11 = (Pythia8::CoupSM *) 0 ;
  bool arg12 ;
  bool arg13 ;
  bool arg14 ;
  bool arg15 ;
  double arg16 ;
  Pythia8::History *arg17 = (Pythia8::History *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  bool val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  Pythia8::History *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:new_History",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_History" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_History" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_History" "', argument " "3"" of type '" "Pythia8::Event""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_History" "', argument " "3"" of type '" "Pythia8::Event""'");
    } else {
      Pythia8::Event * temp = reinterpret_cast< Pythia8::Event * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Clustering,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_History" "', argument " "4"" of type '" "Pythia8::Clustering""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_History" "', argument " "4"" of type '" "Pythia8::Clustering""'");
    } else {
      Pythia8::Clustering * temp = reinterpret_cast< Pythia8::Clustering * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_History" "', argument " "5"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::MergingHooks * >(argp5);
  {
    res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Pythia8__BeamParticle,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_History" "', argument " "6"" of type '" "Pythia8::BeamParticle""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_History" "', argument " "6"" of type '" "Pythia8::BeamParticle""'");
    } else {
      Pythia8::BeamParticle * temp = reinterpret_cast< Pythia8::BeamParticle * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_Pythia8__BeamParticle,  0  | 0);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_History" "', argument " "7"" of type '" "Pythia8::BeamParticle""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_History" "', argument " "7"" of type '" "Pythia8::BeamParticle""'");
    } else {
      Pythia8::BeamParticle * temp = reinterpret_cast< Pythia8::BeamParticle * >(argp7);
      arg7 = *temp;
      if (SWIG_IsNewObj(res7)) delete temp;
    }
  }
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_History" "', argument " "8"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::ParticleData * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_History" "', argument " "9"" of type '" "Pythia8::Info *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::Info * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_History" "', argument " "10"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg10 = reinterpret_cast< Pythia8::PartonLevel * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "new_History" "', argument " "11"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg11 = reinterpret_cast< Pythia8::CoupSM * >(argp11);
  ecode12 = SWIG_AsVal_bool(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_History" "', argument " "12"" of type '" "bool""'");
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_bool(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_History" "', argument " "13"" of type '" "bool""'");
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_History" "', argument " "14"" of type '" "bool""'");
  } 
  arg14 = static_cast< bool >(val14);
  ecode15 = SWIG_AsVal_bool(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_History" "', argument " "15"" of type '" "bool""'");
  } 
  arg15 = static_cast< bool >(val15);
  ecode16 = SWIG_AsVal_double(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_History" "', argument " "16"" of type '" "double""'");
  } 
  arg16 = static_cast< double >(val16);
  res17 = SWIG_ConvertPtr(obj16, &argp17,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "new_History" "', argument " "17"" of type '" "Pythia8::History *""'"); 
  }
  arg17 = reinterpret_cast< Pythia8::History * >(argp17);
  result = (Pythia8::History *)new Pythia8::History(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__History, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_History(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_History",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_History" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_projectOntoDesiredHistories(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:History_projectOntoDesiredHistories",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_projectOntoDesiredHistories" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  result = (bool)(arg1)->projectOntoDesiredHistories();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_weightTREE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  Pythia8::PartonLevel *arg2 = (Pythia8::PartonLevel *) 0 ;
  Pythia8::AlphaStrong *arg3 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaStrong *arg4 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaEM *arg5 = (Pythia8::AlphaEM *) 0 ;
  Pythia8::AlphaEM *arg6 = (Pythia8::AlphaEM *) 0 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:History_weightTREE",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_weightTREE" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "History_weightTREE" "', argument " "2"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PartonLevel * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "History_weightTREE" "', argument " "3"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::AlphaStrong * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "History_weightTREE" "', argument " "4"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::AlphaStrong * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "History_weightTREE" "', argument " "5"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::AlphaEM * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "History_weightTREE" "', argument " "6"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::AlphaEM * >(argp6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "History_weightTREE" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)(arg1)->weightTREE(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_weightLOOP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  Pythia8::PartonLevel *arg2 = (Pythia8::PartonLevel *) 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:History_weightLOOP",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_weightLOOP" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "History_weightLOOP" "', argument " "2"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PartonLevel * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "History_weightLOOP" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)(arg1)->weightLOOP(arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_weightFIRST(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  Pythia8::PartonLevel *arg2 = (Pythia8::PartonLevel *) 0 ;
  Pythia8::AlphaStrong *arg3 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaStrong *arg4 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaEM *arg5 = (Pythia8::AlphaEM *) 0 ;
  Pythia8::AlphaEM *arg6 = (Pythia8::AlphaEM *) 0 ;
  double arg7 ;
  Pythia8::Rndm *arg8 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:History_weightFIRST",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_weightFIRST" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "History_weightFIRST" "', argument " "2"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PartonLevel * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "History_weightFIRST" "', argument " "3"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::AlphaStrong * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "History_weightFIRST" "', argument " "4"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::AlphaStrong * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "History_weightFIRST" "', argument " "5"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::AlphaEM * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "History_weightFIRST" "', argument " "6"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::AlphaEM * >(argp6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "History_weightFIRST" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "History_weightFIRST" "', argument " "8"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::Rndm * >(argp8);
  result = (double)(arg1)->weightFIRST(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_weight_UMEPS_TREE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  Pythia8::PartonLevel *arg2 = (Pythia8::PartonLevel *) 0 ;
  Pythia8::AlphaStrong *arg3 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaStrong *arg4 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaEM *arg5 = (Pythia8::AlphaEM *) 0 ;
  Pythia8::AlphaEM *arg6 = (Pythia8::AlphaEM *) 0 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:History_weight_UMEPS_TREE",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_weight_UMEPS_TREE" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "History_weight_UMEPS_TREE" "', argument " "2"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PartonLevel * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "History_weight_UMEPS_TREE" "', argument " "3"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::AlphaStrong * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "History_weight_UMEPS_TREE" "', argument " "4"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::AlphaStrong * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "History_weight_UMEPS_TREE" "', argument " "5"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::AlphaEM * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "History_weight_UMEPS_TREE" "', argument " "6"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::AlphaEM * >(argp6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "History_weight_UMEPS_TREE" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)(arg1)->weight_UMEPS_TREE(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_weight_UMEPS_SUBT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  Pythia8::PartonLevel *arg2 = (Pythia8::PartonLevel *) 0 ;
  Pythia8::AlphaStrong *arg3 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaStrong *arg4 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaEM *arg5 = (Pythia8::AlphaEM *) 0 ;
  Pythia8::AlphaEM *arg6 = (Pythia8::AlphaEM *) 0 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:History_weight_UMEPS_SUBT",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_weight_UMEPS_SUBT" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "History_weight_UMEPS_SUBT" "', argument " "2"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PartonLevel * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "History_weight_UMEPS_SUBT" "', argument " "3"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::AlphaStrong * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "History_weight_UMEPS_SUBT" "', argument " "4"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::AlphaStrong * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "History_weight_UMEPS_SUBT" "', argument " "5"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::AlphaEM * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "History_weight_UMEPS_SUBT" "', argument " "6"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::AlphaEM * >(argp6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "History_weight_UMEPS_SUBT" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)(arg1)->weight_UMEPS_SUBT(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_weight_UNLOPS_TREE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  Pythia8::PartonLevel *arg2 = (Pythia8::PartonLevel *) 0 ;
  Pythia8::AlphaStrong *arg3 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaStrong *arg4 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaEM *arg5 = (Pythia8::AlphaEM *) 0 ;
  Pythia8::AlphaEM *arg6 = (Pythia8::AlphaEM *) 0 ;
  double arg7 ;
  int arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:History_weight_UNLOPS_TREE",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_weight_UNLOPS_TREE" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "History_weight_UNLOPS_TREE" "', argument " "2"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PartonLevel * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "History_weight_UNLOPS_TREE" "', argument " "3"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::AlphaStrong * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "History_weight_UNLOPS_TREE" "', argument " "4"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::AlphaStrong * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "History_weight_UNLOPS_TREE" "', argument " "5"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::AlphaEM * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "History_weight_UNLOPS_TREE" "', argument " "6"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::AlphaEM * >(argp6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "History_weight_UNLOPS_TREE" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "History_weight_UNLOPS_TREE" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  result = (double)(arg1)->weight_UNLOPS_TREE(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_weight_UNLOPS_TREE__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  Pythia8::PartonLevel *arg2 = (Pythia8::PartonLevel *) 0 ;
  Pythia8::AlphaStrong *arg3 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaStrong *arg4 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaEM *arg5 = (Pythia8::AlphaEM *) 0 ;
  Pythia8::AlphaEM *arg6 = (Pythia8::AlphaEM *) 0 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:History_weight_UNLOPS_TREE",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_weight_UNLOPS_TREE" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "History_weight_UNLOPS_TREE" "', argument " "2"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PartonLevel * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "History_weight_UNLOPS_TREE" "', argument " "3"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::AlphaStrong * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "History_weight_UNLOPS_TREE" "', argument " "4"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::AlphaStrong * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "History_weight_UNLOPS_TREE" "', argument " "5"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::AlphaEM * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "History_weight_UNLOPS_TREE" "', argument " "6"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::AlphaEM * >(argp6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "History_weight_UNLOPS_TREE" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)(arg1)->weight_UNLOPS_TREE(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_weight_UNLOPS_TREE(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 8) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__History, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PartonLevel, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__AlphaStrong, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__AlphaStrong, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__AlphaEM, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__AlphaEM, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_History_weight_UNLOPS_TREE__SWIG_1(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__History, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PartonLevel, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__AlphaStrong, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__AlphaStrong, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__AlphaEM, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__AlphaEM, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_History_weight_UNLOPS_TREE__SWIG_0(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'History_weight_UNLOPS_TREE'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::History::weight_UNLOPS_TREE(Pythia8::PartonLevel *,Pythia8::AlphaStrong *,Pythia8::AlphaStrong *,Pythia8::AlphaEM *,Pythia8::AlphaEM *,double,int)\n"
    "    Pythia8::History::weight_UNLOPS_TREE(Pythia8::PartonLevel *,Pythia8::AlphaStrong *,Pythia8::AlphaStrong *,Pythia8::AlphaEM *,Pythia8::AlphaEM *,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_History_weight_UNLOPS_SUBT__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  Pythia8::PartonLevel *arg2 = (Pythia8::PartonLevel *) 0 ;
  Pythia8::AlphaStrong *arg3 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaStrong *arg4 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaEM *arg5 = (Pythia8::AlphaEM *) 0 ;
  Pythia8::AlphaEM *arg6 = (Pythia8::AlphaEM *) 0 ;
  double arg7 ;
  int arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:History_weight_UNLOPS_SUBT",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_weight_UNLOPS_SUBT" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "History_weight_UNLOPS_SUBT" "', argument " "2"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PartonLevel * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "History_weight_UNLOPS_SUBT" "', argument " "3"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::AlphaStrong * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "History_weight_UNLOPS_SUBT" "', argument " "4"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::AlphaStrong * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "History_weight_UNLOPS_SUBT" "', argument " "5"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::AlphaEM * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "History_weight_UNLOPS_SUBT" "', argument " "6"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::AlphaEM * >(argp6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "History_weight_UNLOPS_SUBT" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "History_weight_UNLOPS_SUBT" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  result = (double)(arg1)->weight_UNLOPS_SUBT(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_weight_UNLOPS_SUBT__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  Pythia8::PartonLevel *arg2 = (Pythia8::PartonLevel *) 0 ;
  Pythia8::AlphaStrong *arg3 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaStrong *arg4 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaEM *arg5 = (Pythia8::AlphaEM *) 0 ;
  Pythia8::AlphaEM *arg6 = (Pythia8::AlphaEM *) 0 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:History_weight_UNLOPS_SUBT",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_weight_UNLOPS_SUBT" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "History_weight_UNLOPS_SUBT" "', argument " "2"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PartonLevel * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "History_weight_UNLOPS_SUBT" "', argument " "3"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::AlphaStrong * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "History_weight_UNLOPS_SUBT" "', argument " "4"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::AlphaStrong * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "History_weight_UNLOPS_SUBT" "', argument " "5"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::AlphaEM * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "History_weight_UNLOPS_SUBT" "', argument " "6"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::AlphaEM * >(argp6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "History_weight_UNLOPS_SUBT" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)(arg1)->weight_UNLOPS_SUBT(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_weight_UNLOPS_SUBT(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 8) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__History, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PartonLevel, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__AlphaStrong, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__AlphaStrong, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__AlphaEM, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__AlphaEM, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_History_weight_UNLOPS_SUBT__SWIG_1(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__History, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PartonLevel, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__AlphaStrong, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__AlphaStrong, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__AlphaEM, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__AlphaEM, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_History_weight_UNLOPS_SUBT__SWIG_0(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'History_weight_UNLOPS_SUBT'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::History::weight_UNLOPS_SUBT(Pythia8::PartonLevel *,Pythia8::AlphaStrong *,Pythia8::AlphaStrong *,Pythia8::AlphaEM *,Pythia8::AlphaEM *,double,int)\n"
    "    Pythia8::History::weight_UNLOPS_SUBT(Pythia8::PartonLevel *,Pythia8::AlphaStrong *,Pythia8::AlphaStrong *,Pythia8::AlphaEM *,Pythia8::AlphaEM *,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_History_weight_UNLOPS_LOOP__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  Pythia8::PartonLevel *arg2 = (Pythia8::PartonLevel *) 0 ;
  Pythia8::AlphaStrong *arg3 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaStrong *arg4 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaEM *arg5 = (Pythia8::AlphaEM *) 0 ;
  Pythia8::AlphaEM *arg6 = (Pythia8::AlphaEM *) 0 ;
  double arg7 ;
  int arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:History_weight_UNLOPS_LOOP",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_weight_UNLOPS_LOOP" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "History_weight_UNLOPS_LOOP" "', argument " "2"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PartonLevel * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "History_weight_UNLOPS_LOOP" "', argument " "3"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::AlphaStrong * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "History_weight_UNLOPS_LOOP" "', argument " "4"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::AlphaStrong * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "History_weight_UNLOPS_LOOP" "', argument " "5"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::AlphaEM * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "History_weight_UNLOPS_LOOP" "', argument " "6"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::AlphaEM * >(argp6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "History_weight_UNLOPS_LOOP" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "History_weight_UNLOPS_LOOP" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  result = (double)(arg1)->weight_UNLOPS_LOOP(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_weight_UNLOPS_LOOP__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  Pythia8::PartonLevel *arg2 = (Pythia8::PartonLevel *) 0 ;
  Pythia8::AlphaStrong *arg3 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaStrong *arg4 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaEM *arg5 = (Pythia8::AlphaEM *) 0 ;
  Pythia8::AlphaEM *arg6 = (Pythia8::AlphaEM *) 0 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:History_weight_UNLOPS_LOOP",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_weight_UNLOPS_LOOP" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "History_weight_UNLOPS_LOOP" "', argument " "2"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PartonLevel * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "History_weight_UNLOPS_LOOP" "', argument " "3"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::AlphaStrong * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "History_weight_UNLOPS_LOOP" "', argument " "4"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::AlphaStrong * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "History_weight_UNLOPS_LOOP" "', argument " "5"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::AlphaEM * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "History_weight_UNLOPS_LOOP" "', argument " "6"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::AlphaEM * >(argp6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "History_weight_UNLOPS_LOOP" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)(arg1)->weight_UNLOPS_LOOP(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_weight_UNLOPS_LOOP(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 8) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__History, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PartonLevel, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__AlphaStrong, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__AlphaStrong, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__AlphaEM, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__AlphaEM, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_History_weight_UNLOPS_LOOP__SWIG_1(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__History, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PartonLevel, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__AlphaStrong, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__AlphaStrong, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__AlphaEM, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__AlphaEM, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_History_weight_UNLOPS_LOOP__SWIG_0(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'History_weight_UNLOPS_LOOP'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::History::weight_UNLOPS_LOOP(Pythia8::PartonLevel *,Pythia8::AlphaStrong *,Pythia8::AlphaStrong *,Pythia8::AlphaEM *,Pythia8::AlphaEM *,double,int)\n"
    "    Pythia8::History::weight_UNLOPS_LOOP(Pythia8::PartonLevel *,Pythia8::AlphaStrong *,Pythia8::AlphaStrong *,Pythia8::AlphaEM *,Pythia8::AlphaEM *,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_History_weight_UNLOPS_SUBTNLO__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  Pythia8::PartonLevel *arg2 = (Pythia8::PartonLevel *) 0 ;
  Pythia8::AlphaStrong *arg3 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaStrong *arg4 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaEM *arg5 = (Pythia8::AlphaEM *) 0 ;
  Pythia8::AlphaEM *arg6 = (Pythia8::AlphaEM *) 0 ;
  double arg7 ;
  int arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:History_weight_UNLOPS_SUBTNLO",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_weight_UNLOPS_SUBTNLO" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "History_weight_UNLOPS_SUBTNLO" "', argument " "2"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PartonLevel * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "History_weight_UNLOPS_SUBTNLO" "', argument " "3"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::AlphaStrong * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "History_weight_UNLOPS_SUBTNLO" "', argument " "4"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::AlphaStrong * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "History_weight_UNLOPS_SUBTNLO" "', argument " "5"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::AlphaEM * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "History_weight_UNLOPS_SUBTNLO" "', argument " "6"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::AlphaEM * >(argp6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "History_weight_UNLOPS_SUBTNLO" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "History_weight_UNLOPS_SUBTNLO" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  result = (double)(arg1)->weight_UNLOPS_SUBTNLO(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_weight_UNLOPS_SUBTNLO__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  Pythia8::PartonLevel *arg2 = (Pythia8::PartonLevel *) 0 ;
  Pythia8::AlphaStrong *arg3 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaStrong *arg4 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaEM *arg5 = (Pythia8::AlphaEM *) 0 ;
  Pythia8::AlphaEM *arg6 = (Pythia8::AlphaEM *) 0 ;
  double arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:History_weight_UNLOPS_SUBTNLO",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_weight_UNLOPS_SUBTNLO" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "History_weight_UNLOPS_SUBTNLO" "', argument " "2"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PartonLevel * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "History_weight_UNLOPS_SUBTNLO" "', argument " "3"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::AlphaStrong * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "History_weight_UNLOPS_SUBTNLO" "', argument " "4"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::AlphaStrong * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "History_weight_UNLOPS_SUBTNLO" "', argument " "5"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::AlphaEM * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "History_weight_UNLOPS_SUBTNLO" "', argument " "6"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::AlphaEM * >(argp6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "History_weight_UNLOPS_SUBTNLO" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  result = (double)(arg1)->weight_UNLOPS_SUBTNLO(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_weight_UNLOPS_SUBTNLO(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 8) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__History, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PartonLevel, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__AlphaStrong, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__AlphaStrong, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__AlphaEM, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__AlphaEM, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_History_weight_UNLOPS_SUBTNLO__SWIG_1(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__History, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PartonLevel, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__AlphaStrong, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__AlphaStrong, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__AlphaEM, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__AlphaEM, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_History_weight_UNLOPS_SUBTNLO__SWIG_0(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'History_weight_UNLOPS_SUBTNLO'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::History::weight_UNLOPS_SUBTNLO(Pythia8::PartonLevel *,Pythia8::AlphaStrong *,Pythia8::AlphaStrong *,Pythia8::AlphaEM *,Pythia8::AlphaEM *,double,int)\n"
    "    Pythia8::History::weight_UNLOPS_SUBTNLO(Pythia8::PartonLevel *,Pythia8::AlphaStrong *,Pythia8::AlphaStrong *,Pythia8::AlphaEM *,Pythia8::AlphaEM *,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_History_weight_UNLOPS_CORRECTION(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  int arg2 ;
  Pythia8::PartonLevel *arg3 = (Pythia8::PartonLevel *) 0 ;
  Pythia8::AlphaStrong *arg4 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaStrong *arg5 = (Pythia8::AlphaStrong *) 0 ;
  Pythia8::AlphaEM *arg6 = (Pythia8::AlphaEM *) 0 ;
  Pythia8::AlphaEM *arg7 = (Pythia8::AlphaEM *) 0 ;
  double arg8 ;
  Pythia8::Rndm *arg9 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:History_weight_UNLOPS_CORRECTION",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_weight_UNLOPS_CORRECTION" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "History_weight_UNLOPS_CORRECTION" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "History_weight_UNLOPS_CORRECTION" "', argument " "3"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PartonLevel * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "History_weight_UNLOPS_CORRECTION" "', argument " "4"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::AlphaStrong * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__AlphaStrong, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "History_weight_UNLOPS_CORRECTION" "', argument " "5"" of type '" "Pythia8::AlphaStrong *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::AlphaStrong * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "History_weight_UNLOPS_CORRECTION" "', argument " "6"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::AlphaEM * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__AlphaEM, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "History_weight_UNLOPS_CORRECTION" "', argument " "7"" of type '" "Pythia8::AlphaEM *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::AlphaEM * >(argp7);
  ecode8 = SWIG_AsVal_double(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "History_weight_UNLOPS_CORRECTION" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "History_weight_UNLOPS_CORRECTION" "', argument " "9"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::Rndm * >(argp9);
  result = (double)(arg1)->weight_UNLOPS_CORRECTION(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_foundAllowedHistories(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:History_foundAllowedHistories",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_foundAllowedHistories" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  result = (bool)(arg1)->foundAllowedHistories();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_foundOrderedHistories(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:History_foundOrderedHistories",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_foundOrderedHistories" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  result = (bool)(arg1)->foundOrderedHistories();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_foundCompleteHistories(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:History_foundCompleteHistories",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_foundCompleteHistories" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  result = (bool)(arg1)->foundCompleteHistories();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_getStartingConditions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  double arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:History_getStartingConditions",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_getStartingConditions" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "History_getStartingConditions" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "History_getStartingConditions" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "History_getStartingConditions" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  (arg1)->getStartingConditions(arg2,*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_getClusteredEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  double arg2 ;
  int arg3 ;
  Pythia8::Event *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:History_getClusteredEvent",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_getClusteredEvent" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "History_getClusteredEvent" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "History_getClusteredEvent" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "History_getClusteredEvent" "', argument " "4"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "History_getClusteredEvent" "', argument " "4"" of type '" "Pythia8::Event &""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Event * >(argp4);
  result = (bool)(arg1)->getClusteredEvent(arg2,arg3,*arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_getFirstClusteredEventAboveTMS__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  double arg2 ;
  int arg3 ;
  Pythia8::Event *arg4 = 0 ;
  int *arg5 = 0 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:History_getFirstClusteredEventAboveTMS",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_getFirstClusteredEventAboveTMS" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "History_getFirstClusteredEventAboveTMS" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "History_getFirstClusteredEventAboveTMS" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "History_getFirstClusteredEventAboveTMS" "', argument " "4"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "History_getFirstClusteredEventAboveTMS" "', argument " "4"" of type '" "Pythia8::Event &""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Event * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "History_getFirstClusteredEventAboveTMS" "', argument " "5"" of type '" "int &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "History_getFirstClusteredEventAboveTMS" "', argument " "5"" of type '" "int &""'"); 
  }
  arg5 = reinterpret_cast< int * >(argp5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "History_getFirstClusteredEventAboveTMS" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  result = (bool)(arg1)->getFirstClusteredEventAboveTMS(arg2,arg3,*arg4,*arg5,arg6);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_getFirstClusteredEventAboveTMS__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  double arg2 ;
  int arg3 ;
  Pythia8::Event *arg4 = 0 ;
  int *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:History_getFirstClusteredEventAboveTMS",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_getFirstClusteredEventAboveTMS" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "History_getFirstClusteredEventAboveTMS" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "History_getFirstClusteredEventAboveTMS" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "History_getFirstClusteredEventAboveTMS" "', argument " "4"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "History_getFirstClusteredEventAboveTMS" "', argument " "4"" of type '" "Pythia8::Event &""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Event * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "History_getFirstClusteredEventAboveTMS" "', argument " "5"" of type '" "int &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "History_getFirstClusteredEventAboveTMS" "', argument " "5"" of type '" "int &""'"); 
  }
  arg5 = reinterpret_cast< int * >(argp5);
  result = (bool)(arg1)->getFirstClusteredEventAboveTMS(arg2,arg3,*arg4,*arg5);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_getFirstClusteredEventAboveTMS(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__History, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_History_getFirstClusteredEventAboveTMS__SWIG_1(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__History, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__Event, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_History_getFirstClusteredEventAboveTMS__SWIG_0(self, args);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'History_getFirstClusteredEventAboveTMS'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::History::getFirstClusteredEventAboveTMS(double const,int,Pythia8::Event &,int &,bool)\n"
    "    Pythia8::History::getFirstClusteredEventAboveTMS(double const,int,Pythia8::Event &,int &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_History_nClusterings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:History_nClusterings",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_nClusterings" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  result = (int)(arg1)->nClusterings();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_lowestMultProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Event result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:History_lowestMultProc",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_lowestMultProc" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "History_lowestMultProc" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (arg1)->lowestMultProc(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Event(static_cast< const Pythia8::Event& >(result))), SWIGTYPE_p_Pythia8__Event, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_getPDFratio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  int arg2 ;
  bool arg3 ;
  bool arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  int arg8 ;
  double arg9 ;
  double arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:History_getPDFratio",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_getPDFratio" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "History_getPDFratio" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "History_getPDFratio" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "History_getPDFratio" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "History_getPDFratio" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "History_getPDFratio" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "History_getPDFratio" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "History_getPDFratio" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_double(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "History_getPDFratio" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  ecode10 = SWIG_AsVal_double(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "History_getPDFratio" "', argument " "10"" of type '" "double""'");
  } 
  arg10 = static_cast< double >(val10);
  result = (double)(arg1)->getPDFratio(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_getWeakProb__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:History_getWeakProb",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_getWeakProb" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  result = (double)(arg1)->getWeakProb();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_getWeakProb__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ;
  std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > *arg3 = 0 ;
  std::vector< int,std::allocator< int > > arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:History_getWeakProb",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_getWeakProb" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "History_getWeakProb" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "History_getWeakProb" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "History_getWeakProb" "', argument " "3"" of type '" "std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "History_getWeakProb" "', argument " "3"" of type '" "std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > * >(argp3);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "History_getWeakProb" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->getWeakProb(*arg2,*arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_getWeakProb(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__History, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_History_getWeakProb__SWIG_0(self, args);
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__History, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< int,std::allocator< int > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_History_getWeakProb__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'History_getWeakProb'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::History::getWeakProb()\n"
    "    Pythia8::History::getWeakProb(std::vector< int,std::allocator< int > > &,std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > &,std::vector< int,std::allocator< int > >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_History_getSingleWeakProb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ;
  std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > *arg3 = 0 ;
  std::vector< int,std::allocator< int > > arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:History_getSingleWeakProb",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_getSingleWeakProb" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "History_getSingleWeakProb" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "History_getSingleWeakProb" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "History_getSingleWeakProb" "', argument " "3"" of type '" "std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "History_getSingleWeakProb" "', argument " "3"" of type '" "std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > * >(argp3);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "History_getSingleWeakProb" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->getSingleWeakProb(*arg2,*arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_findStateTransfer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:History_findStateTransfer",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_findStateTransfer" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "History_findStateTransfer" "', argument " "2"" of type '" "std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "History_findStateTransfer" "', argument " "2"" of type '" "std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > > * >(argp2);
  (arg1)->findStateTransfer(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_printHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:History_printHistory",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_printHistory" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "History_printHistory" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->printHistory(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_History_printStates(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::History *arg1 = (Pythia8::History *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:History_printStates",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__History, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "History_printStates" "', argument " "1"" of type '" "Pythia8::History *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::History * >(argp1);
  (arg1)->printStates();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *History_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__History, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_Merging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Merging *arg1 = (Pythia8::Merging *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Merging",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Merging, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Merging" "', argument " "1"" of type '" "Pythia8::Merging *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Merging * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Merging_initPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Merging *arg1 = (Pythia8::Merging *) 0 ;
  Pythia8::Settings *arg2 = (Pythia8::Settings *) 0 ;
  Pythia8::Info *arg3 = (Pythia8::Info *) 0 ;
  Pythia8::ParticleData *arg4 = (Pythia8::ParticleData *) 0 ;
  Pythia8::Rndm *arg5 = (Pythia8::Rndm *) 0 ;
  Pythia8::BeamParticle *arg6 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::BeamParticle *arg7 = (Pythia8::BeamParticle *) 0 ;
  Pythia8::MergingHooks *arg8 = (Pythia8::MergingHooks *) 0 ;
  Pythia8::PartonLevel *arg9 = (Pythia8::PartonLevel *) 0 ;
  Pythia8::CoupSM *arg10 = (Pythia8::CoupSM *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Merging_initPtr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Merging, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Merging_initPtr" "', argument " "1"" of type '" "Pythia8::Merging *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Merging * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Merging_initPtr" "', argument " "2"" of type '" "Pythia8::Settings *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Merging_initPtr" "', argument " "3"" of type '" "Pythia8::Info *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Info * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Merging_initPtr" "', argument " "4"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Merging_initPtr" "', argument " "5"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Merging_initPtr" "', argument " "6"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::BeamParticle * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Merging_initPtr" "', argument " "7"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::BeamParticle * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Merging_initPtr" "', argument " "8"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::MergingHooks * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__PartonLevel, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Merging_initPtr" "', argument " "9"" of type '" "Pythia8::PartonLevel *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::PartonLevel * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_Pythia8__CoupSM, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Merging_initPtr" "', argument " "10"" of type '" "Pythia8::CoupSM *""'"); 
  }
  arg10 = reinterpret_cast< Pythia8::CoupSM * >(argp10);
  (arg1)->initPtr(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Merging_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Merging *arg1 = (Pythia8::Merging *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Merging_init",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Merging, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Merging_init" "', argument " "1"" of type '" "Pythia8::Merging *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Merging * >(argp1);
  (arg1)->init();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Merging_statistics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Merging *arg1 = (Pythia8::Merging *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Merging_statistics",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Merging, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Merging_statistics" "', argument " "1"" of type '" "Pythia8::Merging *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Merging * >(argp1);
  (arg1)->statistics();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Merging_mergeProcess(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Merging *arg1 = (Pythia8::Merging *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Merging_mergeProcess",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Merging, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Merging_mergeProcess" "', argument " "1"" of type '" "Pythia8::Merging *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Merging * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Merging_mergeProcess" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Merging_mergeProcess" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (int)(arg1)->mergeProcess(*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Merging_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Merging, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PYTHIA_VERSION_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *module;
  PyObject *d;
  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
  d = PyModule_GetDict(module);
  if (!d) return NULL;
  SWIG_Python_SetConstant(d, "PYTHIA_VERSION",SWIG_From_double(static_cast< double >(8.235)));
  return SWIG_Py_Void();
}


SWIGINTERN PyObject *PYTHIA_VERSION_INTEGER_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *module;
  PyObject *d;
  if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
  d = PyModule_GetDict(module);
  if (!d) return NULL;
  SWIG_Python_SetConstant(d, "PYTHIA_VERSION_INTEGER",SWIG_From_int(static_cast< int >(8235)));
  return SWIG_Py_Void();
}


SWIGINTERN PyObject *_wrap_new_Pythia__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  bool arg2 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Pythia *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Pythia",&obj0,&obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Pythia" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Pythia" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (Pythia8::Pythia *)new Pythia8::Pythia(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Pythia, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Pythia__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  Pythia8::Pythia *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Pythia",&obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Pythia" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::Pythia *)new Pythia8::Pythia(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Pythia, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Pythia__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Pythia")) SWIG_fail;
  result = (Pythia8::Pythia *)new Pythia8::Pythia();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Pythia, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Pythia__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = 0 ;
  Pythia8::ParticleData *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Pythia *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Pythia",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Pythia" "', argument " "1"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Pythia" "', argument " "1"" of type '" "Pythia8::Settings &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__ParticleData,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Pythia" "', argument " "2"" of type '" "Pythia8::ParticleData &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Pythia" "', argument " "2"" of type '" "Pythia8::ParticleData &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ParticleData * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Pythia" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (Pythia8::Pythia *)new Pythia8::Pythia(*arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Pythia, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Pythia__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = 0 ;
  Pythia8::ParticleData *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Pythia *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Pythia",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Pythia" "', argument " "1"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Pythia" "', argument " "1"" of type '" "Pythia8::Settings &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__ParticleData,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Pythia" "', argument " "2"" of type '" "Pythia8::ParticleData &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Pythia" "', argument " "2"" of type '" "Pythia8::ParticleData &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ParticleData * >(argp2);
  result = (Pythia8::Pythia *)new Pythia8::Pythia(*arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Pythia, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Pythia__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::istream *arg1 = 0 ;
  std::istream *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Pythia *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Pythia",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Pythia" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Pythia" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  arg1 = reinterpret_cast< std::istream * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Pythia" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Pythia" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Pythia" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (Pythia8::Pythia *)new Pythia8::Pythia(*arg1,*arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Pythia, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Pythia__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::istream *arg1 = 0 ;
  std::istream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Pythia *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Pythia",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Pythia" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Pythia" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  arg1 = reinterpret_cast< std::istream * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Pythia" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Pythia" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  result = (Pythia8::Pythia *)new Pythia8::Pythia(*arg1,*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Pythia, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Pythia(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Pythia__SWIG_2(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Pythia__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Pythia__SWIG_4(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Pythia__SWIG_6(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Pythia__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Pythia__SWIG_5(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Settings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__ParticleData, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Pythia__SWIG_3(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Pythia'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Pythia::Pythia(std::string,bool)\n"
    "    Pythia8::Pythia::Pythia(std::string)\n"
    "    Pythia8::Pythia::Pythia()\n"
    "    Pythia8::Pythia::Pythia(Pythia8::Settings &,Pythia8::ParticleData &,bool)\n"
    "    Pythia8::Pythia::Pythia(Pythia8::Settings &,Pythia8::ParticleData &)\n"
    "    Pythia8::Pythia::Pythia(std::istream &,std::istream &,bool)\n"
    "    Pythia8::Pythia::Pythia(std::istream &,std::istream &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_Pythia(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Pythia",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Pythia" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_initPtrs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_initPtrs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_initPtrs" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  (arg1)->initPtrs();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_checkVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_checkVersion",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_checkVersion" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (bool)(arg1)->checkVersion();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_readString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pythia_readString",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_readString" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Pythia_readString" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pythia_readString" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->readString(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_readString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_readString",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_readString" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Pythia_readString" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->readString(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_readString(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pythia_readString__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pythia_readString__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pythia_readString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Pythia::readString(std::string,bool)\n"
    "    Pythia8::Pythia::readString(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pythia_readFile__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Pythia_readFile",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_readFile" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Pythia_readFile" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pythia_readFile" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Pythia_readFile" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (bool)(arg1)->readFile(arg2,arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_readFile__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pythia_readFile",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_readFile" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Pythia_readFile" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pythia_readFile" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->readFile(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_readFile__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_readFile",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_readFile" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Pythia_readFile" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->readFile(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_readFile__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  std::string arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pythia_readFile",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_readFile" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Pythia_readFile" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pythia_readFile" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (bool)(arg1)->readFile(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_readFile__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  std::istream *arg2 = 0 ;
  bool arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Pythia_readFile",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_readFile" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_readFile" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pythia_readFile" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pythia_readFile" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Pythia_readFile" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (bool)(arg1)->readFile(*arg2,arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_readFile__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  std::istream *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pythia_readFile",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_readFile" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_readFile" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pythia_readFile" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pythia_readFile" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->readFile(*arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_readFile__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  std::istream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_readFile",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_readFile" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_readFile" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pythia_readFile" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  result = (bool)(arg1)->readFile(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_readFile__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_readFile",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_readFile" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (bool)(arg1)->readFile();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_readFile__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  std::istream *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pythia_readFile",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_readFile" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_readFile" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pythia_readFile" "', argument " "2"" of type '" "std::istream &""'"); 
  }
  arg2 = reinterpret_cast< std::istream * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pythia_readFile" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (bool)(arg1)->readFile(*arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_readFile(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pythia_readFile__SWIG_7(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pythia_readFile__SWIG_6(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pythia_readFile__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pythia_readFile__SWIG_5(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pythia_readFile__SWIG_8(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pythia_readFile__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pythia_readFile__SWIG_3(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Pythia_readFile__SWIG_4(self, args);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Pythia_readFile__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pythia_readFile'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Pythia::readFile(std::string,bool,int)\n"
    "    Pythia8::Pythia::readFile(std::string,bool)\n"
    "    Pythia8::Pythia::readFile(std::string)\n"
    "    Pythia8::Pythia::readFile(std::string,int)\n"
    "    Pythia8::Pythia::readFile(std::istream &,bool,int)\n"
    "    Pythia8::Pythia::readFile(std::istream &,bool)\n"
    "    Pythia8::Pythia::readFile(std::istream &)\n"
    "    Pythia8::Pythia::readFile()\n"
    "    Pythia8::Pythia::readFile(std::istream &,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pythia_setPDFPtr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::PDF *arg2 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg3 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg4 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg5 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg6 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg7 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg8 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg9 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg10 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg11 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg12 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg13 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg14 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg15 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg16 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg17 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOOO:Pythia_setPDFPtr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15,&obj16)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setPDFPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setPDFPtr" "', argument " "2"" of type '" "Pythia8::PDF *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PDF * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pythia_setPDFPtr" "', argument " "3"" of type '" "Pythia8::PDF *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PDF * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Pythia_setPDFPtr" "', argument " "4"" of type '" "Pythia8::PDF *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::PDF * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Pythia_setPDFPtr" "', argument " "5"" of type '" "Pythia8::PDF *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::PDF * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Pythia_setPDFPtr" "', argument " "6"" of type '" "Pythia8::PDF *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::PDF * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Pythia_setPDFPtr" "', argument " "7"" of type '" "Pythia8::PDF *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::PDF * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Pythia_setPDFPtr" "', argument " "8"" of type '" "Pythia8::PDF *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::PDF * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Pythia_setPDFPtr" "', argument " "9"" of type '" "Pythia8::PDF *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::PDF * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Pythia_setPDFPtr" "', argument " "10"" of type '" "Pythia8::PDF *""'"); 
  }
  arg10 = reinterpret_cast< Pythia8::PDF * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Pythia_setPDFPtr" "', argument " "11"" of type '" "Pythia8::PDF *""'"); 
  }
  arg11 = reinterpret_cast< Pythia8::PDF * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Pythia_setPDFPtr" "', argument " "12"" of type '" "Pythia8::PDF *""'"); 
  }
  arg12 = reinterpret_cast< Pythia8::PDF * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Pythia_setPDFPtr" "', argument " "13"" of type '" "Pythia8::PDF *""'"); 
  }
  arg13 = reinterpret_cast< Pythia8::PDF * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Pythia_setPDFPtr" "', argument " "14"" of type '" "Pythia8::PDF *""'"); 
  }
  arg14 = reinterpret_cast< Pythia8::PDF * >(argp14);
  res15 = SWIG_ConvertPtr(obj14, &argp15,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "Pythia_setPDFPtr" "', argument " "15"" of type '" "Pythia8::PDF *""'"); 
  }
  arg15 = reinterpret_cast< Pythia8::PDF * >(argp15);
  res16 = SWIG_ConvertPtr(obj15, &argp16,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "Pythia_setPDFPtr" "', argument " "16"" of type '" "Pythia8::PDF *""'"); 
  }
  arg16 = reinterpret_cast< Pythia8::PDF * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "Pythia_setPDFPtr" "', argument " "17"" of type '" "Pythia8::PDF *""'"); 
  }
  arg17 = reinterpret_cast< Pythia8::PDF * >(argp17);
  result = (bool)(arg1)->setPDFPtr(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setPDFPtr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::PDF *arg2 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg3 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg4 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg5 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg6 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg7 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg8 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg9 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg10 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg11 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg12 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg13 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg14 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg15 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg16 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:Pythia_setPDFPtr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setPDFPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setPDFPtr" "', argument " "2"" of type '" "Pythia8::PDF *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PDF * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pythia_setPDFPtr" "', argument " "3"" of type '" "Pythia8::PDF *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PDF * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Pythia_setPDFPtr" "', argument " "4"" of type '" "Pythia8::PDF *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::PDF * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Pythia_setPDFPtr" "', argument " "5"" of type '" "Pythia8::PDF *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::PDF * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Pythia_setPDFPtr" "', argument " "6"" of type '" "Pythia8::PDF *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::PDF * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Pythia_setPDFPtr" "', argument " "7"" of type '" "Pythia8::PDF *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::PDF * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Pythia_setPDFPtr" "', argument " "8"" of type '" "Pythia8::PDF *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::PDF * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Pythia_setPDFPtr" "', argument " "9"" of type '" "Pythia8::PDF *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::PDF * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Pythia_setPDFPtr" "', argument " "10"" of type '" "Pythia8::PDF *""'"); 
  }
  arg10 = reinterpret_cast< Pythia8::PDF * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Pythia_setPDFPtr" "', argument " "11"" of type '" "Pythia8::PDF *""'"); 
  }
  arg11 = reinterpret_cast< Pythia8::PDF * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Pythia_setPDFPtr" "', argument " "12"" of type '" "Pythia8::PDF *""'"); 
  }
  arg12 = reinterpret_cast< Pythia8::PDF * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Pythia_setPDFPtr" "', argument " "13"" of type '" "Pythia8::PDF *""'"); 
  }
  arg13 = reinterpret_cast< Pythia8::PDF * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Pythia_setPDFPtr" "', argument " "14"" of type '" "Pythia8::PDF *""'"); 
  }
  arg14 = reinterpret_cast< Pythia8::PDF * >(argp14);
  res15 = SWIG_ConvertPtr(obj14, &argp15,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "Pythia_setPDFPtr" "', argument " "15"" of type '" "Pythia8::PDF *""'"); 
  }
  arg15 = reinterpret_cast< Pythia8::PDF * >(argp15);
  res16 = SWIG_ConvertPtr(obj15, &argp16,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "Pythia_setPDFPtr" "', argument " "16"" of type '" "Pythia8::PDF *""'"); 
  }
  arg16 = reinterpret_cast< Pythia8::PDF * >(argp16);
  result = (bool)(arg1)->setPDFPtr(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setPDFPtr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::PDF *arg2 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg3 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg4 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg5 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg6 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg7 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg8 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg9 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg10 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg11 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg12 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg13 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg14 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg15 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:Pythia_setPDFPtr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setPDFPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setPDFPtr" "', argument " "2"" of type '" "Pythia8::PDF *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PDF * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pythia_setPDFPtr" "', argument " "3"" of type '" "Pythia8::PDF *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PDF * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Pythia_setPDFPtr" "', argument " "4"" of type '" "Pythia8::PDF *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::PDF * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Pythia_setPDFPtr" "', argument " "5"" of type '" "Pythia8::PDF *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::PDF * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Pythia_setPDFPtr" "', argument " "6"" of type '" "Pythia8::PDF *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::PDF * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Pythia_setPDFPtr" "', argument " "7"" of type '" "Pythia8::PDF *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::PDF * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Pythia_setPDFPtr" "', argument " "8"" of type '" "Pythia8::PDF *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::PDF * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Pythia_setPDFPtr" "', argument " "9"" of type '" "Pythia8::PDF *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::PDF * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Pythia_setPDFPtr" "', argument " "10"" of type '" "Pythia8::PDF *""'"); 
  }
  arg10 = reinterpret_cast< Pythia8::PDF * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Pythia_setPDFPtr" "', argument " "11"" of type '" "Pythia8::PDF *""'"); 
  }
  arg11 = reinterpret_cast< Pythia8::PDF * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Pythia_setPDFPtr" "', argument " "12"" of type '" "Pythia8::PDF *""'"); 
  }
  arg12 = reinterpret_cast< Pythia8::PDF * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Pythia_setPDFPtr" "', argument " "13"" of type '" "Pythia8::PDF *""'"); 
  }
  arg13 = reinterpret_cast< Pythia8::PDF * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Pythia_setPDFPtr" "', argument " "14"" of type '" "Pythia8::PDF *""'"); 
  }
  arg14 = reinterpret_cast< Pythia8::PDF * >(argp14);
  res15 = SWIG_ConvertPtr(obj14, &argp15,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "Pythia_setPDFPtr" "', argument " "15"" of type '" "Pythia8::PDF *""'"); 
  }
  arg15 = reinterpret_cast< Pythia8::PDF * >(argp15);
  result = (bool)(arg1)->setPDFPtr(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setPDFPtr__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::PDF *arg2 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg3 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg4 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg5 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg6 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg7 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg8 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg9 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg10 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg11 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg12 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg13 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg14 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOO:Pythia_setPDFPtr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setPDFPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setPDFPtr" "', argument " "2"" of type '" "Pythia8::PDF *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PDF * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pythia_setPDFPtr" "', argument " "3"" of type '" "Pythia8::PDF *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PDF * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Pythia_setPDFPtr" "', argument " "4"" of type '" "Pythia8::PDF *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::PDF * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Pythia_setPDFPtr" "', argument " "5"" of type '" "Pythia8::PDF *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::PDF * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Pythia_setPDFPtr" "', argument " "6"" of type '" "Pythia8::PDF *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::PDF * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Pythia_setPDFPtr" "', argument " "7"" of type '" "Pythia8::PDF *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::PDF * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Pythia_setPDFPtr" "', argument " "8"" of type '" "Pythia8::PDF *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::PDF * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Pythia_setPDFPtr" "', argument " "9"" of type '" "Pythia8::PDF *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::PDF * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Pythia_setPDFPtr" "', argument " "10"" of type '" "Pythia8::PDF *""'"); 
  }
  arg10 = reinterpret_cast< Pythia8::PDF * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Pythia_setPDFPtr" "', argument " "11"" of type '" "Pythia8::PDF *""'"); 
  }
  arg11 = reinterpret_cast< Pythia8::PDF * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Pythia_setPDFPtr" "', argument " "12"" of type '" "Pythia8::PDF *""'"); 
  }
  arg12 = reinterpret_cast< Pythia8::PDF * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Pythia_setPDFPtr" "', argument " "13"" of type '" "Pythia8::PDF *""'"); 
  }
  arg13 = reinterpret_cast< Pythia8::PDF * >(argp13);
  res14 = SWIG_ConvertPtr(obj13, &argp14,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "Pythia_setPDFPtr" "', argument " "14"" of type '" "Pythia8::PDF *""'"); 
  }
  arg14 = reinterpret_cast< Pythia8::PDF * >(argp14);
  result = (bool)(arg1)->setPDFPtr(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setPDFPtr__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::PDF *arg2 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg3 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg4 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg5 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg6 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg7 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg8 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg9 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg10 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg11 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg12 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg13 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:Pythia_setPDFPtr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setPDFPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setPDFPtr" "', argument " "2"" of type '" "Pythia8::PDF *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PDF * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pythia_setPDFPtr" "', argument " "3"" of type '" "Pythia8::PDF *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PDF * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Pythia_setPDFPtr" "', argument " "4"" of type '" "Pythia8::PDF *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::PDF * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Pythia_setPDFPtr" "', argument " "5"" of type '" "Pythia8::PDF *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::PDF * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Pythia_setPDFPtr" "', argument " "6"" of type '" "Pythia8::PDF *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::PDF * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Pythia_setPDFPtr" "', argument " "7"" of type '" "Pythia8::PDF *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::PDF * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Pythia_setPDFPtr" "', argument " "8"" of type '" "Pythia8::PDF *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::PDF * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Pythia_setPDFPtr" "', argument " "9"" of type '" "Pythia8::PDF *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::PDF * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Pythia_setPDFPtr" "', argument " "10"" of type '" "Pythia8::PDF *""'"); 
  }
  arg10 = reinterpret_cast< Pythia8::PDF * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Pythia_setPDFPtr" "', argument " "11"" of type '" "Pythia8::PDF *""'"); 
  }
  arg11 = reinterpret_cast< Pythia8::PDF * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Pythia_setPDFPtr" "', argument " "12"" of type '" "Pythia8::PDF *""'"); 
  }
  arg12 = reinterpret_cast< Pythia8::PDF * >(argp12);
  res13 = SWIG_ConvertPtr(obj12, &argp13,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "Pythia_setPDFPtr" "', argument " "13"" of type '" "Pythia8::PDF *""'"); 
  }
  arg13 = reinterpret_cast< Pythia8::PDF * >(argp13);
  result = (bool)(arg1)->setPDFPtr(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setPDFPtr__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::PDF *arg2 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg3 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg4 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg5 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg6 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg7 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg8 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg9 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg10 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg11 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg12 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Pythia_setPDFPtr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setPDFPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setPDFPtr" "', argument " "2"" of type '" "Pythia8::PDF *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PDF * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pythia_setPDFPtr" "', argument " "3"" of type '" "Pythia8::PDF *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PDF * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Pythia_setPDFPtr" "', argument " "4"" of type '" "Pythia8::PDF *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::PDF * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Pythia_setPDFPtr" "', argument " "5"" of type '" "Pythia8::PDF *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::PDF * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Pythia_setPDFPtr" "', argument " "6"" of type '" "Pythia8::PDF *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::PDF * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Pythia_setPDFPtr" "', argument " "7"" of type '" "Pythia8::PDF *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::PDF * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Pythia_setPDFPtr" "', argument " "8"" of type '" "Pythia8::PDF *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::PDF * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Pythia_setPDFPtr" "', argument " "9"" of type '" "Pythia8::PDF *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::PDF * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Pythia_setPDFPtr" "', argument " "10"" of type '" "Pythia8::PDF *""'"); 
  }
  arg10 = reinterpret_cast< Pythia8::PDF * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Pythia_setPDFPtr" "', argument " "11"" of type '" "Pythia8::PDF *""'"); 
  }
  arg11 = reinterpret_cast< Pythia8::PDF * >(argp11);
  res12 = SWIG_ConvertPtr(obj11, &argp12,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "Pythia_setPDFPtr" "', argument " "12"" of type '" "Pythia8::PDF *""'"); 
  }
  arg12 = reinterpret_cast< Pythia8::PDF * >(argp12);
  result = (bool)(arg1)->setPDFPtr(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setPDFPtr__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::PDF *arg2 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg3 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg4 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg5 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg6 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg7 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg8 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg9 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg10 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg11 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Pythia_setPDFPtr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setPDFPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setPDFPtr" "', argument " "2"" of type '" "Pythia8::PDF *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PDF * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pythia_setPDFPtr" "', argument " "3"" of type '" "Pythia8::PDF *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PDF * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Pythia_setPDFPtr" "', argument " "4"" of type '" "Pythia8::PDF *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::PDF * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Pythia_setPDFPtr" "', argument " "5"" of type '" "Pythia8::PDF *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::PDF * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Pythia_setPDFPtr" "', argument " "6"" of type '" "Pythia8::PDF *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::PDF * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Pythia_setPDFPtr" "', argument " "7"" of type '" "Pythia8::PDF *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::PDF * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Pythia_setPDFPtr" "', argument " "8"" of type '" "Pythia8::PDF *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::PDF * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Pythia_setPDFPtr" "', argument " "9"" of type '" "Pythia8::PDF *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::PDF * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Pythia_setPDFPtr" "', argument " "10"" of type '" "Pythia8::PDF *""'"); 
  }
  arg10 = reinterpret_cast< Pythia8::PDF * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "Pythia_setPDFPtr" "', argument " "11"" of type '" "Pythia8::PDF *""'"); 
  }
  arg11 = reinterpret_cast< Pythia8::PDF * >(argp11);
  result = (bool)(arg1)->setPDFPtr(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setPDFPtr__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::PDF *arg2 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg3 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg4 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg5 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg6 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg7 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg8 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg9 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg10 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Pythia_setPDFPtr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setPDFPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setPDFPtr" "', argument " "2"" of type '" "Pythia8::PDF *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PDF * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pythia_setPDFPtr" "', argument " "3"" of type '" "Pythia8::PDF *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PDF * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Pythia_setPDFPtr" "', argument " "4"" of type '" "Pythia8::PDF *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::PDF * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Pythia_setPDFPtr" "', argument " "5"" of type '" "Pythia8::PDF *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::PDF * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Pythia_setPDFPtr" "', argument " "6"" of type '" "Pythia8::PDF *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::PDF * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Pythia_setPDFPtr" "', argument " "7"" of type '" "Pythia8::PDF *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::PDF * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Pythia_setPDFPtr" "', argument " "8"" of type '" "Pythia8::PDF *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::PDF * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Pythia_setPDFPtr" "', argument " "9"" of type '" "Pythia8::PDF *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::PDF * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "Pythia_setPDFPtr" "', argument " "10"" of type '" "Pythia8::PDF *""'"); 
  }
  arg10 = reinterpret_cast< Pythia8::PDF * >(argp10);
  result = (bool)(arg1)->setPDFPtr(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setPDFPtr__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::PDF *arg2 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg3 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg4 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg5 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg6 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg7 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg8 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg9 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Pythia_setPDFPtr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setPDFPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setPDFPtr" "', argument " "2"" of type '" "Pythia8::PDF *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PDF * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pythia_setPDFPtr" "', argument " "3"" of type '" "Pythia8::PDF *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PDF * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Pythia_setPDFPtr" "', argument " "4"" of type '" "Pythia8::PDF *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::PDF * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Pythia_setPDFPtr" "', argument " "5"" of type '" "Pythia8::PDF *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::PDF * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Pythia_setPDFPtr" "', argument " "6"" of type '" "Pythia8::PDF *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::PDF * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Pythia_setPDFPtr" "', argument " "7"" of type '" "Pythia8::PDF *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::PDF * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Pythia_setPDFPtr" "', argument " "8"" of type '" "Pythia8::PDF *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::PDF * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Pythia_setPDFPtr" "', argument " "9"" of type '" "Pythia8::PDF *""'"); 
  }
  arg9 = reinterpret_cast< Pythia8::PDF * >(argp9);
  result = (bool)(arg1)->setPDFPtr(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setPDFPtr__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::PDF *arg2 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg3 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg4 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg5 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg6 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg7 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg8 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Pythia_setPDFPtr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setPDFPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setPDFPtr" "', argument " "2"" of type '" "Pythia8::PDF *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PDF * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pythia_setPDFPtr" "', argument " "3"" of type '" "Pythia8::PDF *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PDF * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Pythia_setPDFPtr" "', argument " "4"" of type '" "Pythia8::PDF *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::PDF * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Pythia_setPDFPtr" "', argument " "5"" of type '" "Pythia8::PDF *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::PDF * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Pythia_setPDFPtr" "', argument " "6"" of type '" "Pythia8::PDF *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::PDF * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Pythia_setPDFPtr" "', argument " "7"" of type '" "Pythia8::PDF *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::PDF * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Pythia_setPDFPtr" "', argument " "8"" of type '" "Pythia8::PDF *""'"); 
  }
  arg8 = reinterpret_cast< Pythia8::PDF * >(argp8);
  result = (bool)(arg1)->setPDFPtr(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setPDFPtr__SWIG_10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::PDF *arg2 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg3 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg4 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg5 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg6 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg7 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Pythia_setPDFPtr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setPDFPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setPDFPtr" "', argument " "2"" of type '" "Pythia8::PDF *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PDF * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pythia_setPDFPtr" "', argument " "3"" of type '" "Pythia8::PDF *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PDF * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Pythia_setPDFPtr" "', argument " "4"" of type '" "Pythia8::PDF *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::PDF * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Pythia_setPDFPtr" "', argument " "5"" of type '" "Pythia8::PDF *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::PDF * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Pythia_setPDFPtr" "', argument " "6"" of type '" "Pythia8::PDF *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::PDF * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Pythia_setPDFPtr" "', argument " "7"" of type '" "Pythia8::PDF *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::PDF * >(argp7);
  result = (bool)(arg1)->setPDFPtr(arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setPDFPtr__SWIG_11(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::PDF *arg2 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg3 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg4 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg5 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg6 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Pythia_setPDFPtr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setPDFPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setPDFPtr" "', argument " "2"" of type '" "Pythia8::PDF *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PDF * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pythia_setPDFPtr" "', argument " "3"" of type '" "Pythia8::PDF *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PDF * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Pythia_setPDFPtr" "', argument " "4"" of type '" "Pythia8::PDF *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::PDF * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Pythia_setPDFPtr" "', argument " "5"" of type '" "Pythia8::PDF *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::PDF * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Pythia_setPDFPtr" "', argument " "6"" of type '" "Pythia8::PDF *""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::PDF * >(argp6);
  result = (bool)(arg1)->setPDFPtr(arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setPDFPtr__SWIG_12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::PDF *arg2 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg3 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg4 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg5 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Pythia_setPDFPtr",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setPDFPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setPDFPtr" "', argument " "2"" of type '" "Pythia8::PDF *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PDF * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pythia_setPDFPtr" "', argument " "3"" of type '" "Pythia8::PDF *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PDF * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Pythia_setPDFPtr" "', argument " "4"" of type '" "Pythia8::PDF *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::PDF * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Pythia_setPDFPtr" "', argument " "5"" of type '" "Pythia8::PDF *""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::PDF * >(argp5);
  result = (bool)(arg1)->setPDFPtr(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setPDFPtr__SWIG_13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::PDF *arg2 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg3 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg4 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Pythia_setPDFPtr",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setPDFPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setPDFPtr" "', argument " "2"" of type '" "Pythia8::PDF *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PDF * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pythia_setPDFPtr" "', argument " "3"" of type '" "Pythia8::PDF *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PDF * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Pythia_setPDFPtr" "', argument " "4"" of type '" "Pythia8::PDF *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::PDF * >(argp4);
  result = (bool)(arg1)->setPDFPtr(arg2,arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setPDFPtr__SWIG_14(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::PDF *arg2 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg3 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pythia_setPDFPtr",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setPDFPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setPDFPtr" "', argument " "2"" of type '" "Pythia8::PDF *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PDF * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pythia_setPDFPtr" "', argument " "3"" of type '" "Pythia8::PDF *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PDF * >(argp3);
  result = (bool)(arg1)->setPDFPtr(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setPDFPtr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[18] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 17) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Pythia_setPDFPtr__SWIG_14(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Pythia_setPDFPtr__SWIG_13(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Pythia_setPDFPtr__SWIG_12(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Pythia_setPDFPtr__SWIG_11(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_Pythia_setPDFPtr__SWIG_10(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_Pythia_setPDFPtr__SWIG_9(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap_Pythia_setPDFPtr__SWIG_8(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_Pythia_setPDFPtr__SWIG_7(self, args);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_Pythia_setPDFPtr__SWIG_6(self, args);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_Pythia_setPDFPtr__SWIG_5(self, args);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_Pythia_setPDFPtr__SWIG_4(self, args);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                return _wrap_Pythia_setPDFPtr__SWIG_3(self, args);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[14], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  return _wrap_Pythia_setPDFPtr__SWIG_2(self, args);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[14], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    return _wrap_Pythia_setPDFPtr__SWIG_1(self, args);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          void *vptr = 0;
                          int res = SWIG_ConvertPtr(argv[11], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[14], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  void *vptr = 0;
                                  int res = SWIG_ConvertPtr(argv[15], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                                  _v = SWIG_CheckState(res);
                                  if (_v) {
                                    void *vptr = 0;
                                    int res = SWIG_ConvertPtr(argv[16], &vptr, SWIGTYPE_p_Pythia8__PDF, 0);
                                    _v = SWIG_CheckState(res);
                                    if (_v) {
                                      return _wrap_Pythia_setPDFPtr__SWIG_0(self, args);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pythia_setPDFPtr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Pythia::setPDFPtr(Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *)\n"
    "    Pythia8::Pythia::setPDFPtr(Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *)\n"
    "    Pythia8::Pythia::setPDFPtr(Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *)\n"
    "    Pythia8::Pythia::setPDFPtr(Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *)\n"
    "    Pythia8::Pythia::setPDFPtr(Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *)\n"
    "    Pythia8::Pythia::setPDFPtr(Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *)\n"
    "    Pythia8::Pythia::setPDFPtr(Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *)\n"
    "    Pythia8::Pythia::setPDFPtr(Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *)\n"
    "    Pythia8::Pythia::setPDFPtr(Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *)\n"
    "    Pythia8::Pythia::setPDFPtr(Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *)\n"
    "    Pythia8::Pythia::setPDFPtr(Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *)\n"
    "    Pythia8::Pythia::setPDFPtr(Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *)\n"
    "    Pythia8::Pythia::setPDFPtr(Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *)\n"
    "    Pythia8::Pythia::setPDFPtr(Pythia8::PDF *,Pythia8::PDF *,Pythia8::PDF *)\n"
    "    Pythia8::Pythia::setPDFPtr(Pythia8::PDF *,Pythia8::PDF *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pythia_setPhotonFluxPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::PDF *arg2 = (Pythia8::PDF *) 0 ;
  Pythia8::PDF *arg3 = (Pythia8::PDF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pythia_setPhotonFluxPtr",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setPhotonFluxPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setPhotonFluxPtr" "', argument " "2"" of type '" "Pythia8::PDF *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PDF * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pythia_setPhotonFluxPtr" "', argument " "3"" of type '" "Pythia8::PDF *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PDF * >(argp3);
  result = (bool)(arg1)->setPhotonFluxPtr(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setLHAupPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::LHAup *arg2 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_setLHAupPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setLHAupPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setLHAupPtr" "', argument " "2"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHAup * >(argp2);
  result = (bool)(arg1)->setLHAupPtr(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setDecayPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::DecayHandler *arg2 = (Pythia8::DecayHandler *) 0 ;
  std::vector< int,std::allocator< int > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pythia_setDecayPtr",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setDecayPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__DecayHandler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setDecayPtr" "', argument " "2"" of type '" "Pythia8::DecayHandler *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::DecayHandler * >(argp2);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Pythia_setDecayPtr" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->setDecayPtr(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setRndmEnginePtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::RndmEngine *arg2 = (Pythia8::RndmEngine *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_setRndmEnginePtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setRndmEnginePtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__RndmEngine, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setRndmEnginePtr" "', argument " "2"" of type '" "Pythia8::RndmEngine *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::RndmEngine * >(argp2);
  result = (bool)(arg1)->setRndmEnginePtr(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setUserHooksPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::UserHooks *arg2 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_setUserHooksPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setUserHooksPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setUserHooksPtr" "', argument " "2"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::UserHooks * >(argp2);
  result = (bool)(arg1)->setUserHooksPtr(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_addUserHooksPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::UserHooks *arg2 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_addUserHooksPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_addUserHooksPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_addUserHooksPtr" "', argument " "2"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::UserHooks * >(argp2);
  result = (bool)(arg1)->addUserHooksPtr(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setMergingPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::Merging *arg2 = (Pythia8::Merging *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_setMergingPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setMergingPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Merging, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setMergingPtr" "', argument " "2"" of type '" "Pythia8::Merging *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Merging * >(argp2);
  result = (bool)(arg1)->setMergingPtr(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setMergingHooksPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::MergingHooks *arg2 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_setMergingHooksPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setMergingHooksPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setMergingHooksPtr" "', argument " "2"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::MergingHooks * >(argp2);
  result = (bool)(arg1)->setMergingHooksPtr(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setBeamShapePtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::BeamShape *arg2 = (Pythia8::BeamShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_setBeamShapePtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setBeamShapePtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__BeamShape, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setBeamShapePtr" "', argument " "2"" of type '" "Pythia8::BeamShape *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::BeamShape * >(argp2);
  result = (bool)(arg1)->setBeamShapePtr(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setSigmaPtr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::SigmaProcess *arg2 = (Pythia8::SigmaProcess *) 0 ;
  Pythia8::PhaseSpace *arg3 = (Pythia8::PhaseSpace *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pythia_setSigmaPtr",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setSigmaPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setSigmaPtr" "', argument " "2"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::SigmaProcess * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__PhaseSpace, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pythia_setSigmaPtr" "', argument " "3"" of type '" "Pythia8::PhaseSpace *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::PhaseSpace * >(argp3);
  result = (bool)(arg1)->setSigmaPtr(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setSigmaPtr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::SigmaProcess *arg2 = (Pythia8::SigmaProcess *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_setSigmaPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setSigmaPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setSigmaPtr" "', argument " "2"" of type '" "Pythia8::SigmaProcess *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::SigmaProcess * >(argp2);
  result = (bool)(arg1)->setSigmaPtr(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setSigmaPtr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pythia_setSigmaPtr__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__PhaseSpace, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Pythia_setSigmaPtr__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pythia_setSigmaPtr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Pythia::setSigmaPtr(Pythia8::SigmaProcess *,Pythia8::PhaseSpace *)\n"
    "    Pythia8::Pythia::setSigmaPtr(Pythia8::SigmaProcess *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pythia_setResonancePtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::ResonanceWidths *arg2 = (Pythia8::ResonanceWidths *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_setResonancePtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setResonancePtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setResonancePtr" "', argument " "2"" of type '" "Pythia8::ResonanceWidths *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ResonanceWidths * >(argp2);
  result = (bool)(arg1)->setResonancePtr(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setShowerPtr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::TimeShower *arg2 = (Pythia8::TimeShower *) 0 ;
  Pythia8::TimeShower *arg3 = (Pythia8::TimeShower *) 0 ;
  Pythia8::SpaceShower *arg4 = (Pythia8::SpaceShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Pythia_setShowerPtr",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setShowerPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setShowerPtr" "', argument " "2"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::TimeShower * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pythia_setShowerPtr" "', argument " "3"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::TimeShower * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__SpaceShower, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Pythia_setShowerPtr" "', argument " "4"" of type '" "Pythia8::SpaceShower *""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::SpaceShower * >(argp4);
  result = (bool)(arg1)->setShowerPtr(arg2,arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setShowerPtr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::TimeShower *arg2 = (Pythia8::TimeShower *) 0 ;
  Pythia8::TimeShower *arg3 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pythia_setShowerPtr",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setShowerPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setShowerPtr" "', argument " "2"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::TimeShower * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pythia_setShowerPtr" "', argument " "3"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::TimeShower * >(argp3);
  result = (bool)(arg1)->setShowerPtr(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setShowerPtr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::TimeShower *arg2 = (Pythia8::TimeShower *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_setShowerPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setShowerPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__TimeShower, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setShowerPtr" "', argument " "2"" of type '" "Pythia8::TimeShower *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::TimeShower * >(argp2);
  result = (bool)(arg1)->setShowerPtr(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setShowerPtr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__TimeShower, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pythia_setShowerPtr__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__TimeShower, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__TimeShower, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Pythia_setShowerPtr__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__TimeShower, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__TimeShower, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__SpaceShower, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Pythia_setShowerPtr__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pythia_setShowerPtr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Pythia::setShowerPtr(Pythia8::TimeShower *,Pythia8::TimeShower *,Pythia8::SpaceShower *)\n"
    "    Pythia8::Pythia::setShowerPtr(Pythia8::TimeShower *,Pythia8::TimeShower *)\n"
    "    Pythia8::Pythia::setShowerPtr(Pythia8::TimeShower *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pythia_setHeavyIonsPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::HeavyIons *arg2 = (Pythia8::HeavyIons *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_setHeavyIonsPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setHeavyIonsPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__HeavyIons, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setHeavyIonsPtr" "', argument " "2"" of type '" "Pythia8::HeavyIons *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::HeavyIons * >(argp2);
  result = (bool)(arg1)->setHeavyIonsPtr(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setHIHooks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::HIUserHooks *arg2 = (Pythia8::HIUserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_setHIHooks",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setHIHooks" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__HIUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setHIHooks" "', argument " "2"" of type '" "Pythia8::HIUserHooks *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::HIUserHooks * >(argp2);
  result = (bool)(arg1)->setHIHooks(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_getHeavyIonsPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::HeavyIons *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_getHeavyIonsPtr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_getHeavyIonsPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (Pythia8::HeavyIons *)(arg1)->getHeavyIonsPtr();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HeavyIons, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_setPartonVertexPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::PartonVertex *arg2 = (Pythia8::PartonVertex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_setPartonVertexPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_setPartonVertexPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PartonVertex, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_setPartonVertexPtr" "', argument " "2"" of type '" "Pythia8::PartonVertex *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PartonVertex * >(argp2);
  result = (bool)(arg1)->setPartonVertexPtr(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_init",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_init" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (bool)(arg1)->init();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_next",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_next" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (bool)(arg1)->next();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_forceTimeShower__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Pythia_forceTimeShower",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_forceTimeShower" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pythia_forceTimeShower" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pythia_forceTimeShower" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Pythia_forceTimeShower" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Pythia_forceTimeShower" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (int)(arg1)->forceTimeShower(arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_forceTimeShower__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Pythia_forceTimeShower",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_forceTimeShower" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pythia_forceTimeShower" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pythia_forceTimeShower" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Pythia_forceTimeShower" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (int)(arg1)->forceTimeShower(arg2,arg3,arg4);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_forceTimeShower(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Pythia_forceTimeShower__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Pythia_forceTimeShower__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pythia_forceTimeShower'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Pythia::forceTimeShower(int,int,double,int)\n"
    "    Pythia8::Pythia::forceTimeShower(int,int,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pythia_forceHadronLevel__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_forceHadronLevel",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_forceHadronLevel" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pythia_forceHadronLevel" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)(arg1)->forceHadronLevel(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_forceHadronLevel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_forceHadronLevel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_forceHadronLevel" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (bool)(arg1)->forceHadronLevel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_forceHadronLevel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pythia_forceHadronLevel__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Pythia_forceHadronLevel__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pythia_forceHadronLevel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Pythia::forceHadronLevel(bool)\n"
    "    Pythia8::Pythia::forceHadronLevel()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pythia_moreDecays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_moreDecays",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_moreDecays" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (bool)(arg1)->moreDecays();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_forceRHadronDecays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_forceRHadronDecays",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_forceRHadronDecays" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (bool)(arg1)->forceRHadronDecays();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_LHAeventList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_LHAeventList",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_LHAeventList" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  (arg1)->LHAeventList();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_LHAeventSkip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_LHAeventSkip",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_LHAeventSkip" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pythia_LHAeventSkip" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->LHAeventSkip(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_stat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_stat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_stat" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  (arg1)->stat();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_flag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_flag",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_flag" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Pythia_flag" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->flag(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_mode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_mode",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_mode" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Pythia_mode" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (int)(arg1)->mode(arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_parm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_parm",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_parm" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Pythia_parm" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (double)(arg1)->parm(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_word(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::string result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_word",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_word" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Pythia_word" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->word(arg2);
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_getPDFPtr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  int arg2 ;
  int arg3 ;
  std::string arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Swig::Director *director = 0;
  Pythia8::PDF *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:Pythia_getPDFPtr",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_getPDFPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pythia_getPDFPtr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pythia_getPDFPtr" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Pythia_getPDFPtr" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Pythia_getPDFPtr" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (Pythia8::PDF *)(arg1)->getPDFPtr(arg2,arg3,arg4,arg5);
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_getPDFPtr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  int arg2 ;
  int arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Swig::Director *director = 0;
  Pythia8::PDF *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:Pythia_getPDFPtr",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_getPDFPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pythia_getPDFPtr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pythia_getPDFPtr" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Pythia_getPDFPtr" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::PDF *)(arg1)->getPDFPtr(arg2,arg3,arg4);
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_getPDFPtr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Swig::Director *director = 0;
  Pythia8::PDF *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Pythia_getPDFPtr",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_getPDFPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pythia_getPDFPtr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pythia_getPDFPtr" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (Pythia8::PDF *)(arg1)->getPDFPtr(arg2,arg3);
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_getPDFPtr__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  Pythia8::PDF *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_getPDFPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_getPDFPtr" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pythia_getPDFPtr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::PDF *)(arg1)->getPDFPtr(arg2);
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PDF, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_getPDFPtr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Pythia_getPDFPtr__SWIG_3(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pythia_getPDFPtr__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Pythia_getPDFPtr__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Pythia_getPDFPtr__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Pythia_getPDFPtr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Pythia::getPDFPtr(int,int,std::string,bool)\n"
    "    Pythia8::Pythia::getPDFPtr(int,int,std::string)\n"
    "    Pythia8::Pythia::getPDFPtr(int,int)\n"
    "    Pythia8::Pythia::getPDFPtr(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Pythia_process_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::Event *arg2 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_process_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_process_set" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_process_set" "', argument " "2"" of type '" "Pythia8::Event *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  if (arg1) (arg1)->process = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_process_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Event *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_process_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_process_get" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (Pythia8::Event *)& ((arg1)->process);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_event_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::Event *arg2 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_event_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_event_set" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_event_set" "', argument " "2"" of type '" "Pythia8::Event *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  if (arg1) (arg1)->event = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_event_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Event *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_event_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_event_get" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (Pythia8::Event *)& ((arg1)->event);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_info_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_info_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_info_set" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_info_set" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  if (arg1) (arg1)->info = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_info_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Info *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_info_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_info_get" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (Pythia8::Info *)& ((arg1)->info);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_settings_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::Settings *arg2 = (Pythia8::Settings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_settings_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_settings_set" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_settings_set" "', argument " "2"" of type '" "Pythia8::Settings *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Settings * >(argp2);
  if (arg1) (arg1)->settings = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_settings_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Settings *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_settings_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_settings_get" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (Pythia8::Settings *)& ((arg1)->settings);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Settings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_particleData_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::ParticleData *arg2 = (Pythia8::ParticleData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_particleData_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_particleData_set" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_particleData_set" "', argument " "2"" of type '" "Pythia8::ParticleData *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::ParticleData * >(argp2);
  if (arg1) (arg1)->particleData = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_particleData_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ParticleData *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_particleData_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_particleData_get" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (Pythia8::ParticleData *)& ((arg1)->particleData);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ParticleData, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_rndm_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::Rndm *arg2 = (Pythia8::Rndm *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_rndm_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_rndm_set" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_rndm_set" "', argument " "2"" of type '" "Pythia8::Rndm *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Rndm * >(argp2);
  if (arg1) (arg1)->rndm = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_rndm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Rndm *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_rndm_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_rndm_get" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (Pythia8::Rndm *)& ((arg1)->rndm);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Rndm, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_couplings_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::Couplings *arg2 = (Pythia8::Couplings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_couplings_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_couplings_set" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_couplings_set" "', argument " "2"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Couplings * >(argp2);
  if (arg1) (arg1)->couplings = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_couplings_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Couplings *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_couplings_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_couplings_get" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (Pythia8::Couplings *)& ((arg1)->couplings);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_couplingsPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::Couplings *arg2 = (Pythia8::Couplings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_couplingsPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_couplingsPtr_set" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Couplings, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_couplingsPtr_set" "', argument " "2"" of type '" "Pythia8::Couplings *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Couplings * >(argp2);
  if (arg1) (arg1)->couplingsPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_couplingsPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Couplings *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_couplingsPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_couplingsPtr_get" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (Pythia8::Couplings *) ((arg1)->couplingsPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Couplings, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_slhaInterface_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::SLHAinterface *arg2 = (Pythia8::SLHAinterface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_slhaInterface_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_slhaInterface_set" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__SLHAinterface, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_slhaInterface_set" "', argument " "2"" of type '" "Pythia8::SLHAinterface *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::SLHAinterface * >(argp2);
  if (arg1) (arg1)->slhaInterface = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_slhaInterface_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::SLHAinterface *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_slhaInterface_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_slhaInterface_get" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (Pythia8::SLHAinterface *)& ((arg1)->slhaInterface);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SLHAinterface, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_partonSystems_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::PartonSystems *arg2 = (Pythia8::PartonSystems *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_partonSystems_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_partonSystems_set" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_partonSystems_set" "', argument " "2"" of type '" "Pythia8::PartonSystems *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::PartonSystems * >(argp2);
  if (arg1) (arg1)->partonSystems = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_partonSystems_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::PartonSystems *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_partonSystems_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_partonSystems_get" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (Pythia8::PartonSystems *)& ((arg1)->partonSystems);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PartonSystems, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_mergingPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::Merging *arg2 = (Pythia8::Merging *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_mergingPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_mergingPtr_set" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Merging, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_mergingPtr_set" "', argument " "2"" of type '" "Pythia8::Merging *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Merging * >(argp2);
  if (arg1) (arg1)->mergingPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_mergingPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Merging *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_mergingPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_mergingPtr_get" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (Pythia8::Merging *) ((arg1)->mergingPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Merging, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_mergingHooksPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::MergingHooks *arg2 = (Pythia8::MergingHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_mergingHooksPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_mergingHooksPtr_set" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__MergingHooks, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_mergingHooksPtr_set" "', argument " "2"" of type '" "Pythia8::MergingHooks *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::MergingHooks * >(argp2);
  if (arg1) (arg1)->mergingHooksPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_mergingHooksPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::MergingHooks *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_mergingHooksPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_mergingHooksPtr_get" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (Pythia8::MergingHooks *) ((arg1)->mergingHooksPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MergingHooks, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_heavyIonsPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::HeavyIons *arg2 = (Pythia8::HeavyIons *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_heavyIonsPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_heavyIonsPtr_set" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__HeavyIons, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_heavyIonsPtr_set" "', argument " "2"" of type '" "Pythia8::HeavyIons *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::HeavyIons * >(argp2);
  if (arg1) (arg1)->heavyIonsPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_heavyIonsPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::HeavyIons *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_heavyIonsPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_heavyIonsPtr_get" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (Pythia8::HeavyIons *) ((arg1)->heavyIonsPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HeavyIons, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_hiHooksPtr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::HIUserHooks *arg2 = (Pythia8::HIUserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_hiHooksPtr_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_hiHooksPtr_set" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__HIUserHooks, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_hiHooksPtr_set" "', argument " "2"" of type '" "Pythia8::HIUserHooks *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::HIUserHooks * >(argp2);
  if (arg1) (arg1)->hiHooksPtr = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_hiHooksPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::HIUserHooks *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_hiHooksPtr_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_hiHooksPtr_get" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (Pythia8::HIUserHooks *) ((arg1)->hiHooksPtr);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HIUserHooks, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_beamA_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::BeamParticle *arg2 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_beamA_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_beamA_set" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_beamA_set" "', argument " "2"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::BeamParticle * >(argp2);
  if (arg1) (arg1)->beamA = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_beamA_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::BeamParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_beamA_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_beamA_get" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (Pythia8::BeamParticle *)& ((arg1)->beamA);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_beamB_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  Pythia8::BeamParticle *arg2 = (Pythia8::BeamParticle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Pythia_beamB_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_beamB_set" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pythia_beamB_set" "', argument " "2"" of type '" "Pythia8::BeamParticle *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::BeamParticle * >(argp2);
  if (arg1) (arg1)->beamB = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Pythia_beamB_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::BeamParticle *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Pythia_beamB_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pythia_beamB_get" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (Pythia8::BeamParticle *)& ((arg1)->beamB);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__BeamParticle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Pythia_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Pythia, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN int Swig_var_femtometer_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable femtometer is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_femtometer_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(Pythia8::HIUnits::femtometer));
  return pyobj;
}


SWIGINTERN int Swig_var_millimeter_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable millimeter is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_millimeter_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(Pythia8::HIUnits::millimeter));
  return pyobj;
}


SWIGINTERN int Swig_var_femtometer2_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable femtometer2 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_femtometer2_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(Pythia8::HIUnits::femtometer2));
  return pyobj;
}


SWIGINTERN int Swig_var_millibarn_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable millibarn is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_millibarn_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(Pythia8::HIUnits::millibarn));
  return pyobj;
}


SWIGINTERN int Swig_var_nanobarn_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable nanobarn is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_nanobarn_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(Pythia8::HIUnits::nanobarn));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_new_Nucleon__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  Pythia8::Vec4 *arg3 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::Nucleon *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_Nucleon",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Nucleon" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Nucleon" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Nucleon" "', argument " "3"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Nucleon" "', argument " "3"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Vec4 * >(argp3);
  result = (Pythia8::Nucleon *)new Pythia8::Nucleon(arg1,arg2,(Pythia8::Vec4 const &)*arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Nucleon, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nucleon__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Nucleon *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_Nucleon",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Nucleon" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Nucleon" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::Nucleon *)new Pythia8::Nucleon(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Nucleon, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nucleon__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Nucleon *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Nucleon",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Nucleon" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::Nucleon *)new Pythia8::Nucleon(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Nucleon, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nucleon__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Nucleon *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_Nucleon")) SWIG_fail;
  result = (Pythia8::Nucleon *)new Pythia8::Nucleon();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Nucleon, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_Nucleon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_Nucleon__SWIG_3(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Nucleon__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Nucleon__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_Nucleon__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Nucleon'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Nucleon::Nucleon(int,int,Pythia8::Vec4 const &)\n"
    "    Pythia8::Nucleon::Nucleon(int,int)\n"
    "    Pythia8::Nucleon::Nucleon(int)\n"
    "    Pythia8::Nucleon::Nucleon()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Nucleon_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Nucleon *arg1 = (Pythia8::Nucleon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Nucleon_id",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Nucleon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nucleon_id" "', argument " "1"" of type '" "Pythia8::Nucleon const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Nucleon * >(argp1);
  result = (int)((Pythia8::Nucleon const *)arg1)->id();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Nucleon_index(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Nucleon *arg1 = (Pythia8::Nucleon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Nucleon_index",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Nucleon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nucleon_index" "', argument " "1"" of type '" "Pythia8::Nucleon const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Nucleon * >(argp1);
  result = (int)((Pythia8::Nucleon const *)arg1)->index();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Nucleon_nPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Nucleon *arg1 = (Pythia8::Nucleon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Nucleon_nPos",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Nucleon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nucleon_nPos" "', argument " "1"" of type '" "Pythia8::Nucleon const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Nucleon * >(argp1);
  result = (Pythia8::Vec4 *) &((Pythia8::Nucleon const *)arg1)->nPos();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Nucleon_bPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Nucleon *arg1 = (Pythia8::Nucleon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Nucleon_bPos",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Nucleon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nucleon_bPos" "', argument " "1"" of type '" "Pythia8::Nucleon const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Nucleon * >(argp1);
  result = (Pythia8::Vec4 *) &((Pythia8::Nucleon const *)arg1)->bPos();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Nucleon_bShift(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Nucleon *arg1 = (Pythia8::Nucleon *) 0 ;
  Pythia8::Vec4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Vec4 *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Nucleon_bShift",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Nucleon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nucleon_bShift" "', argument " "1"" of type '" "Pythia8::Nucleon *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Nucleon * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Nucleon_bShift" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Nucleon_bShift" "', argument " "2"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Vec4 * >(argp2);
  result = (Pythia8::Vec4 *) &(arg1)->bShift((Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Nucleon_status__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Nucleon *arg1 = (Pythia8::Nucleon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Nucleon::Status result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Nucleon_status",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Nucleon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nucleon_status" "', argument " "1"" of type '" "Pythia8::Nucleon const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Nucleon * >(argp1);
  result = (Pythia8::Nucleon::Status)((Pythia8::Nucleon const *)arg1)->status();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Nucleon_done(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Nucleon *arg1 = (Pythia8::Nucleon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Nucleon_done",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Nucleon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nucleon_done" "', argument " "1"" of type '" "Pythia8::Nucleon const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Nucleon * >(argp1);
  result = (bool)((Pythia8::Nucleon const *)arg1)->done();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Nucleon_event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Nucleon *arg1 = (Pythia8::Nucleon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::EventInfo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Nucleon_event",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Nucleon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nucleon_event" "', argument " "1"" of type '" "Pythia8::Nucleon const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Nucleon * >(argp1);
  result = (Pythia8::EventInfo *)((Pythia8::Nucleon const *)arg1)->event();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__EventInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Nucleon_state__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Nucleon *arg1 = (Pythia8::Nucleon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Nucleon::State *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Nucleon_state",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Nucleon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nucleon_state" "', argument " "1"" of type '" "Pythia8::Nucleon const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Nucleon * >(argp1);
  result = (Pythia8::Nucleon::State *) &((Pythia8::Nucleon const *)arg1)->state();
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Nucleon_altState__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Nucleon *arg1 = (Pythia8::Nucleon *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Nucleon::State *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Nucleon_altState",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Nucleon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nucleon_altState" "', argument " "1"" of type '" "Pythia8::Nucleon *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Nucleon * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nucleon_altState" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::Nucleon::State *) &(arg1)->altState(arg2);
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Nucleon_altState__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Nucleon *arg1 = (Pythia8::Nucleon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Nucleon::State *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Nucleon_altState",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Nucleon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nucleon_altState" "', argument " "1"" of type '" "Pythia8::Nucleon *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Nucleon * >(argp1);
  result = (Pythia8::Nucleon::State *) &(arg1)->altState();
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Nucleon_altState(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Nucleon, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Nucleon_altState__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Nucleon, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Nucleon_altState__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Nucleon_altState'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Nucleon::altState(int)\n"
    "    Pythia8::Nucleon::altState()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Nucleon_status__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Nucleon *arg1 = (Pythia8::Nucleon *) 0 ;
  Pythia8::Nucleon::Status arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Nucleon_status",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Nucleon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nucleon_status" "', argument " "1"" of type '" "Pythia8::Nucleon *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Nucleon * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Nucleon_status" "', argument " "2"" of type '" "Pythia8::Nucleon::Status""'");
  } 
  arg2 = static_cast< Pythia8::Nucleon::Status >(val2);
  (arg1)->status(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Nucleon_status(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Nucleon, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Nucleon_status__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Nucleon, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Nucleon_status__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Nucleon_status'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Nucleon::status() const\n"
    "    Pythia8::Nucleon::status(Pythia8::Nucleon::Status)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Nucleon_state__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Nucleon *arg1 = (Pythia8::Nucleon *) 0 ;
  Pythia8::Nucleon::State arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Nucleon_state",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Nucleon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nucleon_state" "', argument " "1"" of type '" "Pythia8::Nucleon *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Nucleon * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Nucleon_state" "', argument " "2"" of type '" "Pythia8::Nucleon::State""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->state(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Nucleon_state(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Nucleon, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Nucleon_state__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Nucleon, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Nucleon_state__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Nucleon_state'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Nucleon::state() const\n"
    "    Pythia8::Nucleon::state(Pythia8::Nucleon::State)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Nucleon_addAltState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Nucleon *arg1 = (Pythia8::Nucleon *) 0 ;
  Pythia8::Nucleon::State arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:Nucleon_addAltState",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Nucleon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nucleon_addAltState" "', argument " "1"" of type '" "Pythia8::Nucleon *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Nucleon * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Nucleon_addAltState" "', argument " "2"" of type '" "Pythia8::Nucleon::State""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->addAltState(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Nucleon_select__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Nucleon *arg1 = (Pythia8::Nucleon *) 0 ;
  Pythia8::EventInfo *arg2 = 0 ;
  Pythia8::Nucleon::Status arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Nucleon_select",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Nucleon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nucleon_select" "', argument " "1"" of type '" "Pythia8::Nucleon *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Nucleon * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__EventInfo,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Nucleon_select" "', argument " "2"" of type '" "Pythia8::EventInfo &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Nucleon_select" "', argument " "2"" of type '" "Pythia8::EventInfo &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::EventInfo * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Nucleon_select" "', argument " "3"" of type '" "Pythia8::Nucleon::Status""'");
  } 
  arg3 = static_cast< Pythia8::Nucleon::Status >(val3);
  (arg1)->select(*arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Nucleon_select__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Nucleon *arg1 = (Pythia8::Nucleon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Nucleon_select",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Nucleon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nucleon_select" "', argument " "1"" of type '" "Pythia8::Nucleon *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Nucleon * >(argp1);
  (arg1)->select();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Nucleon_select(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Nucleon, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Nucleon_select__SWIG_1(self, args);
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Nucleon, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__EventInfo, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Nucleon_select__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Nucleon_select'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::Nucleon::select(Pythia8::EventInfo &,Pythia8::Nucleon::Status)\n"
    "    Pythia8::Nucleon::select()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_Nucleon_debug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Nucleon *arg1 = (Pythia8::Nucleon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Nucleon_debug",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Nucleon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nucleon_debug" "', argument " "1"" of type '" "Pythia8::Nucleon *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Nucleon * >(argp1);
  (arg1)->debug();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Nucleon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Nucleon *arg1 = (Pythia8::Nucleon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Nucleon",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Nucleon, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Nucleon" "', argument " "1"" of type '" "Pythia8::Nucleon *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Nucleon * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Nucleon_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Nucleon, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_SubCollision__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Nucleon *arg1 = 0 ;
  Pythia8::Nucleon *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  Pythia8::SubCollision::Type arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::SubCollision *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_SubCollision",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Nucleon,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SubCollision" "', argument " "1"" of type '" "Pythia8::Nucleon &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SubCollision" "', argument " "1"" of type '" "Pythia8::Nucleon &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Nucleon * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Nucleon,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SubCollision" "', argument " "2"" of type '" "Pythia8::Nucleon &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SubCollision" "', argument " "2"" of type '" "Pythia8::Nucleon &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Nucleon * >(argp2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SubCollision" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SubCollision" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SubCollision" "', argument " "5"" of type '" "Pythia8::SubCollision::Type""'");
  } 
  arg5 = static_cast< Pythia8::SubCollision::Type >(val5);
  result = (Pythia8::SubCollision *)new Pythia8::SubCollision(*arg1,*arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SubCollision, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SubCollision__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollision *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_SubCollision")) SWIG_fail;
  result = (Pythia8::SubCollision *)new Pythia8::SubCollision();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SubCollision, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SubCollision(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_SubCollision__SWIG_1(self, args);
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Nucleon, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__Nucleon, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_SubCollision__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SubCollision'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::SubCollision::SubCollision(Pythia8::Nucleon &,Pythia8::Nucleon &,double,double,Pythia8::SubCollision::Type)\n"
    "    Pythia8::SubCollision::SubCollision()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SubCollision___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollision *arg1 = (Pythia8::SubCollision *) 0 ;
  Pythia8::SubCollision *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SubCollision___lt__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollision, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollision___lt__" "', argument " "1"" of type '" "Pythia8::SubCollision const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollision * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__SubCollision,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SubCollision___lt__" "', argument " "2"" of type '" "Pythia8::SubCollision const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SubCollision___lt__" "', argument " "2"" of type '" "Pythia8::SubCollision const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::SubCollision * >(argp2);
  result = (bool)((Pythia8::SubCollision const *)arg1)->operator <((Pythia8::SubCollision const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollision_nucleons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollision *arg1 = (Pythia8::SubCollision *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SubCollision_nucleons",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollision, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollision_nucleons" "', argument " "1"" of type '" "Pythia8::SubCollision const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollision * >(argp1);
  result = (int)((Pythia8::SubCollision const *)arg1)->nucleons();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollision_proj_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollision *arg1 = (Pythia8::SubCollision *) 0 ;
  Pythia8::Nucleon *arg2 = (Pythia8::Nucleon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SubCollision_proj_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollision, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollision_proj_set" "', argument " "1"" of type '" "Pythia8::SubCollision *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollision * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Nucleon, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SubCollision_proj_set" "', argument " "2"" of type '" "Pythia8::Nucleon *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Nucleon * >(argp2);
  if (arg1) (arg1)->proj = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollision_proj_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollision *arg1 = (Pythia8::SubCollision *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Nucleon *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SubCollision_proj_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollision, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollision_proj_get" "', argument " "1"" of type '" "Pythia8::SubCollision *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollision * >(argp1);
  result = (Pythia8::Nucleon *) ((arg1)->proj);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Nucleon, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollision_targ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollision *arg1 = (Pythia8::SubCollision *) 0 ;
  Pythia8::Nucleon *arg2 = (Pythia8::Nucleon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SubCollision_targ_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollision, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollision_targ_set" "', argument " "1"" of type '" "Pythia8::SubCollision *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollision * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Nucleon, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SubCollision_targ_set" "', argument " "2"" of type '" "Pythia8::Nucleon *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Nucleon * >(argp2);
  if (arg1) (arg1)->targ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollision_targ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollision *arg1 = (Pythia8::SubCollision *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Nucleon *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SubCollision_targ_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollision, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollision_targ_get" "', argument " "1"" of type '" "Pythia8::SubCollision *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollision * >(argp1);
  result = (Pythia8::Nucleon *) ((arg1)->targ);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Nucleon, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollision_b_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollision *arg1 = (Pythia8::SubCollision *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SubCollision_b_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollision, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollision_b_set" "', argument " "1"" of type '" "Pythia8::SubCollision *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollision * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SubCollision_b_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->b = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollision_b_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollision *arg1 = (Pythia8::SubCollision *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SubCollision_b_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollision, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollision_b_get" "', argument " "1"" of type '" "Pythia8::SubCollision *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollision * >(argp1);
  result = (double) ((arg1)->b);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollision_bp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollision *arg1 = (Pythia8::SubCollision *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SubCollision_bp_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollision, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollision_bp_set" "', argument " "1"" of type '" "Pythia8::SubCollision *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollision * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SubCollision_bp_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->bp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollision_bp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollision *arg1 = (Pythia8::SubCollision *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SubCollision_bp_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollision, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollision_bp_get" "', argument " "1"" of type '" "Pythia8::SubCollision *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollision * >(argp1);
  result = (double) ((arg1)->bp);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollision_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollision *arg1 = (Pythia8::SubCollision *) 0 ;
  Pythia8::SubCollision::Type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SubCollision_type_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollision, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollision_type_set" "', argument " "1"" of type '" "Pythia8::SubCollision *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollision * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SubCollision_type_set" "', argument " "2"" of type '" "Pythia8::SubCollision::Type""'");
  } 
  arg2 = static_cast< Pythia8::SubCollision::Type >(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollision_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollision *arg1 = (Pythia8::SubCollision *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::SubCollision::Type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SubCollision_type_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollision, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollision_type_get" "', argument " "1"" of type '" "Pythia8::SubCollision *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollision * >(argp1);
  result = (Pythia8::SubCollision::Type) ((arg1)->type);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SubCollision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollision *arg1 = (Pythia8::SubCollision *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SubCollision",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollision, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SubCollision" "', argument " "1"" of type '" "Pythia8::SubCollision *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollision * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SubCollision_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SubCollision, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_NucleusModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::NucleusModel *arg1 = (Pythia8::NucleusModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NucleusModel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__NucleusModel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NucleusModel" "', argument " "1"" of type '" "Pythia8::NucleusModel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::NucleusModel * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NucleusModel_initPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::NucleusModel *arg1 = (Pythia8::NucleusModel *) 0 ;
  int arg2 ;
  Pythia8::Settings *arg3 = 0 ;
  Pythia8::ParticleData *arg4 = 0 ;
  Pythia8::Rndm *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:NucleusModel_initPtr",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__NucleusModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NucleusModel_initPtr" "', argument " "1"" of type '" "Pythia8::NucleusModel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::NucleusModel * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NucleusModel_initPtr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NucleusModel_initPtr" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NucleusModel_initPtr" "', argument " "3"" of type '" "Pythia8::Settings &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Settings * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__ParticleData,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NucleusModel_initPtr" "', argument " "4"" of type '" "Pythia8::ParticleData &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NucleusModel_initPtr" "', argument " "4"" of type '" "Pythia8::ParticleData &""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::ParticleData * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Pythia8__Rndm,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NucleusModel_initPtr" "', argument " "5"" of type '" "Pythia8::Rndm &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NucleusModel_initPtr" "', argument " "5"" of type '" "Pythia8::Rndm &""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Rndm * >(argp5);
  (arg1)->initPtr(arg2,*arg3,*arg4,*arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NucleusModel_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::NucleusModel *arg1 = (Pythia8::NucleusModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:NucleusModel_init",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__NucleusModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NucleusModel_init" "', argument " "1"" of type '" "Pythia8::NucleusModel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::NucleusModel * >(argp1);
  result = (bool)(arg1)->init();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NucleusModel_produceIon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::NucleusModel *arg1 = (Pythia8::NucleusModel *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Particle result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:NucleusModel_produceIon",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__NucleusModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NucleusModel_produceIon" "', argument " "1"" of type '" "Pythia8::NucleusModel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::NucleusModel * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NucleusModel_produceIon" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (arg1)->produceIon(arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Particle(static_cast< const Pythia8::Particle& >(result))), SWIGTYPE_p_Pythia8__Particle, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NucleusModel_generate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::NucleusModel *arg1 = (Pythia8::NucleusModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:NucleusModel_generate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__NucleusModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NucleusModel_generate" "', argument " "1"" of type '" "Pythia8::NucleusModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::NucleusModel * >(argp1);
  result = ((Pythia8::NucleusModel const *)arg1)->generate();
  resultobj = SWIG_NewPointerObj((new std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > >(static_cast< const std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > >& >(result))), SWIGTYPE_p_std__vectorT_Pythia8__Nucleon_std__allocatorT_Pythia8__Nucleon_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NucleusModel_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::NucleusModel *arg1 = (Pythia8::NucleusModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:NucleusModel_id",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__NucleusModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NucleusModel_id" "', argument " "1"" of type '" "Pythia8::NucleusModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::NucleusModel * >(argp1);
  result = (int)((Pythia8::NucleusModel const *)arg1)->id();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NucleusModel_I(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::NucleusModel *arg1 = (Pythia8::NucleusModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:NucleusModel_I",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__NucleusModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NucleusModel_I" "', argument " "1"" of type '" "Pythia8::NucleusModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::NucleusModel * >(argp1);
  result = (int)((Pythia8::NucleusModel const *)arg1)->I();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NucleusModel_A(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::NucleusModel *arg1 = (Pythia8::NucleusModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:NucleusModel_A",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__NucleusModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NucleusModel_A" "', argument " "1"" of type '" "Pythia8::NucleusModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::NucleusModel * >(argp1);
  result = (int)((Pythia8::NucleusModel const *)arg1)->A();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NucleusModel_Z(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::NucleusModel *arg1 = (Pythia8::NucleusModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:NucleusModel_Z",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__NucleusModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NucleusModel_Z" "', argument " "1"" of type '" "Pythia8::NucleusModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::NucleusModel * >(argp1);
  result = (int)((Pythia8::NucleusModel const *)arg1)->Z();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NucleusModel_L(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::NucleusModel *arg1 = (Pythia8::NucleusModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:NucleusModel_L",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__NucleusModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NucleusModel_L" "', argument " "1"" of type '" "Pythia8::NucleusModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::NucleusModel * >(argp1);
  result = (int)((Pythia8::NucleusModel const *)arg1)->L();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NucleusModel_R(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::NucleusModel *arg1 = (Pythia8::NucleusModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:NucleusModel_R",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__NucleusModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NucleusModel_R" "', argument " "1"" of type '" "Pythia8::NucleusModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::NucleusModel * >(argp1);
  result = (double)((Pythia8::NucleusModel const *)arg1)->R();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NucleusModel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__NucleusModel, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_WoodsSaxonModel_a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::WoodsSaxonModel *arg1 = (Pythia8::WoodsSaxonModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:WoodsSaxonModel_a",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__WoodsSaxonModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WoodsSaxonModel_a" "', argument " "1"" of type '" "Pythia8::WoodsSaxonModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::WoodsSaxonModel * >(argp1);
  result = (double)((Pythia8::WoodsSaxonModel const *)arg1)->a();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *WoodsSaxonModel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__WoodsSaxonModel, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_GLISSANDOModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GLISSANDOModel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_GLISSANDOModel")) SWIG_fail;
  result = (Pythia8::GLISSANDOModel *)new Pythia8::GLISSANDOModel();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__GLISSANDOModel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_GLISSANDOModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GLISSANDOModel *arg1 = (Pythia8::GLISSANDOModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_GLISSANDOModel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GLISSANDOModel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GLISSANDOModel" "', argument " "1"" of type '" "Pythia8::GLISSANDOModel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GLISSANDOModel * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLISSANDOModel_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GLISSANDOModel *arg1 = (Pythia8::GLISSANDOModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GLISSANDOModel_init",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GLISSANDOModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLISSANDOModel_init" "', argument " "1"" of type '" "Pythia8::GLISSANDOModel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GLISSANDOModel * >(argp1);
  result = (bool)(arg1)->init();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLISSANDOModel_generate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GLISSANDOModel *arg1 = (Pythia8::GLISSANDOModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GLISSANDOModel_generate",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GLISSANDOModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLISSANDOModel_generate" "', argument " "1"" of type '" "Pythia8::GLISSANDOModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GLISSANDOModel * >(argp1);
  result = ((Pythia8::GLISSANDOModel const *)arg1)->generate();
  resultobj = SWIG_NewPointerObj((new std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > >(static_cast< const std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > >& >(result))), SWIGTYPE_p_std__vectorT_Pythia8__Nucleon_std__allocatorT_Pythia8__Nucleon_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLISSANDOModel_Rh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GLISSANDOModel *arg1 = (Pythia8::GLISSANDOModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GLISSANDOModel_Rh",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GLISSANDOModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLISSANDOModel_Rh" "', argument " "1"" of type '" "Pythia8::GLISSANDOModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GLISSANDOModel * >(argp1);
  result = (double)((Pythia8::GLISSANDOModel const *)arg1)->Rh();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_GLISSANDOModel_RhGauss(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::GLISSANDOModel *arg1 = (Pythia8::GLISSANDOModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:GLISSANDOModel_RhGauss",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__GLISSANDOModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GLISSANDOModel_RhGauss" "', argument " "1"" of type '" "Pythia8::GLISSANDOModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::GLISSANDOModel * >(argp1);
  result = (double)((Pythia8::GLISSANDOModel const *)arg1)->RhGauss();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *GLISSANDOModel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__GLISSANDOModel, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ImpactParameterGenerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ImpactParameterGenerator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_ImpactParameterGenerator")) SWIG_fail;
  result = (Pythia8::ImpactParameterGenerator *)new Pythia8::ImpactParameterGenerator();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ImpactParameterGenerator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ImpactParameterGenerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ImpactParameterGenerator *arg1 = (Pythia8::ImpactParameterGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_ImpactParameterGenerator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ImpactParameterGenerator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ImpactParameterGenerator" "', argument " "1"" of type '" "Pythia8::ImpactParameterGenerator *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ImpactParameterGenerator * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImpactParameterGenerator_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ImpactParameterGenerator *arg1 = (Pythia8::ImpactParameterGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ImpactParameterGenerator_init",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ImpactParameterGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImpactParameterGenerator_init" "', argument " "1"" of type '" "Pythia8::ImpactParameterGenerator *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ImpactParameterGenerator * >(argp1);
  result = (bool)(arg1)->init();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImpactParameterGenerator_initPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ImpactParameterGenerator *arg1 = (Pythia8::ImpactParameterGenerator *) 0 ;
  Pythia8::SubCollisionModel *arg2 = 0 ;
  Pythia8::NucleusModel *arg3 = 0 ;
  Pythia8::NucleusModel *arg4 = 0 ;
  Pythia8::Settings *arg5 = 0 ;
  Pythia8::Rndm *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ImpactParameterGenerator_initPtr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ImpactParameterGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImpactParameterGenerator_initPtr" "', argument " "1"" of type '" "Pythia8::ImpactParameterGenerator *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ImpactParameterGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__SubCollisionModel,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImpactParameterGenerator_initPtr" "', argument " "2"" of type '" "Pythia8::SubCollisionModel &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImpactParameterGenerator_initPtr" "', argument " "2"" of type '" "Pythia8::SubCollisionModel &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::SubCollisionModel * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__NucleusModel,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ImpactParameterGenerator_initPtr" "', argument " "3"" of type '" "Pythia8::NucleusModel &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImpactParameterGenerator_initPtr" "', argument " "3"" of type '" "Pythia8::NucleusModel &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::NucleusModel * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__NucleusModel,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ImpactParameterGenerator_initPtr" "', argument " "4"" of type '" "Pythia8::NucleusModel &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImpactParameterGenerator_initPtr" "', argument " "4"" of type '" "Pythia8::NucleusModel &""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::NucleusModel * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ImpactParameterGenerator_initPtr" "', argument " "5"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImpactParameterGenerator_initPtr" "', argument " "5"" of type '" "Pythia8::Settings &""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Settings * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Pythia8__Rndm,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ImpactParameterGenerator_initPtr" "', argument " "6"" of type '" "Pythia8::Rndm &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImpactParameterGenerator_initPtr" "', argument " "6"" of type '" "Pythia8::Rndm &""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::Rndm * >(argp6);
  (arg1)->initPtr(*arg2,*arg3,*arg4,*arg5,*arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImpactParameterGenerator_generate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ImpactParameterGenerator *arg1 = (Pythia8::ImpactParameterGenerator *) 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::Vec4 result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ImpactParameterGenerator_generate",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ImpactParameterGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImpactParameterGenerator_generate" "', argument " "1"" of type '" "Pythia8::ImpactParameterGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ImpactParameterGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImpactParameterGenerator_generate" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImpactParameterGenerator_generate" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  result = ((Pythia8::ImpactParameterGenerator const *)arg1)->generate(*arg2);
  resultobj = SWIG_NewPointerObj((new Pythia8::Vec4(static_cast< const Pythia8::Vec4& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImpactParameterGenerator_width__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ImpactParameterGenerator *arg1 = (Pythia8::ImpactParameterGenerator *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:ImpactParameterGenerator_width",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ImpactParameterGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImpactParameterGenerator_width" "', argument " "1"" of type '" "Pythia8::ImpactParameterGenerator *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ImpactParameterGenerator * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImpactParameterGenerator_width" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->width(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImpactParameterGenerator_width__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::ImpactParameterGenerator *arg1 = (Pythia8::ImpactParameterGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:ImpactParameterGenerator_width",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__ImpactParameterGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImpactParameterGenerator_width" "', argument " "1"" of type '" "Pythia8::ImpactParameterGenerator const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::ImpactParameterGenerator * >(argp1);
  result = (double)((Pythia8::ImpactParameterGenerator const *)arg1)->width();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ImpactParameterGenerator_width(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ImpactParameterGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ImpactParameterGenerator_width__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__ImpactParameterGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ImpactParameterGenerator_width__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ImpactParameterGenerator_width'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::ImpactParameterGenerator::width(double)\n"
    "    Pythia8::ImpactParameterGenerator::width() const\n");
  return 0;
}


SWIGINTERN PyObject *ImpactParameterGenerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__ImpactParameterGenerator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_SubCollisionModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollisionModel *arg1 = (Pythia8::SubCollisionModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_SubCollisionModel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollisionModel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SubCollisionModel" "', argument " "1"" of type '" "Pythia8::SubCollisionModel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollisionModel * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollisionModel_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollisionModel *arg1 = (Pythia8::SubCollisionModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SubCollisionModel_init",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollisionModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollisionModel_init" "', argument " "1"" of type '" "Pythia8::SubCollisionModel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollisionModel * >(argp1);
  result = (bool)(arg1)->init();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollisionModel_initPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollisionModel *arg1 = (Pythia8::SubCollisionModel *) 0 ;
  Pythia8::NucleusModel *arg2 = 0 ;
  Pythia8::NucleusModel *arg3 = 0 ;
  Pythia8::SigmaTotal *arg4 = 0 ;
  Pythia8::Settings *arg5 = 0 ;
  Pythia8::Info *arg6 = 0 ;
  Pythia8::Rndm *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:SubCollisionModel_initPtr",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollisionModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollisionModel_initPtr" "', argument " "1"" of type '" "Pythia8::SubCollisionModel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollisionModel * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__NucleusModel,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SubCollisionModel_initPtr" "', argument " "2"" of type '" "Pythia8::NucleusModel &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SubCollisionModel_initPtr" "', argument " "2"" of type '" "Pythia8::NucleusModel &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::NucleusModel * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__NucleusModel,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SubCollisionModel_initPtr" "', argument " "3"" of type '" "Pythia8::NucleusModel &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SubCollisionModel_initPtr" "', argument " "3"" of type '" "Pythia8::NucleusModel &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::NucleusModel * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__SigmaTotal,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SubCollisionModel_initPtr" "', argument " "4"" of type '" "Pythia8::SigmaTotal &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SubCollisionModel_initPtr" "', argument " "4"" of type '" "Pythia8::SigmaTotal &""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::SigmaTotal * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SubCollisionModel_initPtr" "', argument " "5"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SubCollisionModel_initPtr" "', argument " "5"" of type '" "Pythia8::Settings &""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Settings * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Pythia8__Info,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SubCollisionModel_initPtr" "', argument " "6"" of type '" "Pythia8::Info &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SubCollisionModel_initPtr" "', argument " "6"" of type '" "Pythia8::Info &""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::Info * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_Pythia8__Rndm,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "SubCollisionModel_initPtr" "', argument " "7"" of type '" "Pythia8::Rndm &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SubCollisionModel_initPtr" "', argument " "7"" of type '" "Pythia8::Rndm &""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::Rndm * >(argp7);
  (arg1)->initPtr(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollisionModel_getCollisions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollisionModel *arg1 = (Pythia8::SubCollisionModel *) 0 ;
  std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > *arg2 = 0 ;
  std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > *arg3 = 0 ;
  Pythia8::Vec4 *arg4 = 0 ;
  double *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  SwigValueWrapper< std::multiset< Pythia8::SubCollision > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:SubCollisionModel_getCollisions",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollisionModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollisionModel_getCollisions" "', argument " "1"" of type '" "Pythia8::SubCollisionModel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollisionModel * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__Nucleon_std__allocatorT_Pythia8__Nucleon_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SubCollisionModel_getCollisions" "', argument " "2"" of type '" "std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SubCollisionModel_getCollisions" "', argument " "2"" of type '" "std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_Pythia8__Nucleon_std__allocatorT_Pythia8__Nucleon_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SubCollisionModel_getCollisions" "', argument " "3"" of type '" "std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SubCollisionModel_getCollisions" "', argument " "3"" of type '" "std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SubCollisionModel_getCollisions" "', argument " "4"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SubCollisionModel_getCollisions" "', argument " "4"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Vec4 * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SubCollisionModel_getCollisions" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SubCollisionModel_getCollisions" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  result = (arg1)->getCollisions(*arg2,*arg3,(Pythia8::Vec4 const &)*arg4,*arg5);
  resultobj = SWIG_NewPointerObj((new std::multiset< Pythia8::SubCollision >(static_cast< const std::multiset< Pythia8::SubCollision >& >(result))), SWIGTYPE_p_std__multisetT_Pythia8__SubCollision_std__lessT_Pythia8__SubCollision_t_std__allocatorT_Pythia8__SubCollision_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollisionModel_sigTot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollisionModel *arg1 = (Pythia8::SubCollisionModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SubCollisionModel_sigTot",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollisionModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollisionModel_sigTot" "', argument " "1"" of type '" "Pythia8::SubCollisionModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollisionModel * >(argp1);
  result = (double)((Pythia8::SubCollisionModel const *)arg1)->sigTot();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollisionModel_sigEl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollisionModel *arg1 = (Pythia8::SubCollisionModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SubCollisionModel_sigEl",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollisionModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollisionModel_sigEl" "', argument " "1"" of type '" "Pythia8::SubCollisionModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollisionModel * >(argp1);
  result = (double)((Pythia8::SubCollisionModel const *)arg1)->sigEl();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollisionModel_sigCDE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollisionModel *arg1 = (Pythia8::SubCollisionModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SubCollisionModel_sigCDE",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollisionModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollisionModel_sigCDE" "', argument " "1"" of type '" "Pythia8::SubCollisionModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollisionModel * >(argp1);
  result = (double)((Pythia8::SubCollisionModel const *)arg1)->sigCDE();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollisionModel_sigSDE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollisionModel *arg1 = (Pythia8::SubCollisionModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SubCollisionModel_sigSDE",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollisionModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollisionModel_sigSDE" "', argument " "1"" of type '" "Pythia8::SubCollisionModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollisionModel * >(argp1);
  result = (double)((Pythia8::SubCollisionModel const *)arg1)->sigSDE();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollisionModel_sigSDEP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollisionModel *arg1 = (Pythia8::SubCollisionModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SubCollisionModel_sigSDEP",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollisionModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollisionModel_sigSDEP" "', argument " "1"" of type '" "Pythia8::SubCollisionModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollisionModel * >(argp1);
  result = (double)((Pythia8::SubCollisionModel const *)arg1)->sigSDEP();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollisionModel_sigSDET(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollisionModel *arg1 = (Pythia8::SubCollisionModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SubCollisionModel_sigSDET",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollisionModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollisionModel_sigSDET" "', argument " "1"" of type '" "Pythia8::SubCollisionModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollisionModel * >(argp1);
  result = (double)((Pythia8::SubCollisionModel const *)arg1)->sigSDET();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollisionModel_sigDDE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollisionModel *arg1 = (Pythia8::SubCollisionModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SubCollisionModel_sigDDE",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollisionModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollisionModel_sigDDE" "', argument " "1"" of type '" "Pythia8::SubCollisionModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollisionModel * >(argp1);
  result = (double)((Pythia8::SubCollisionModel const *)arg1)->sigDDE();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollisionModel_sigND(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollisionModel *arg1 = (Pythia8::SubCollisionModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SubCollisionModel_sigND",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollisionModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollisionModel_sigND" "', argument " "1"" of type '" "Pythia8::SubCollisionModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollisionModel * >(argp1);
  result = (double)((Pythia8::SubCollisionModel const *)arg1)->sigND();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollisionModel_bSlope(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollisionModel *arg1 = (Pythia8::SubCollisionModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SubCollisionModel_bSlope",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollisionModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollisionModel_bSlope" "', argument " "1"" of type '" "Pythia8::SubCollisionModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollisionModel * >(argp1);
  result = (double)((Pythia8::SubCollisionModel const *)arg1)->bSlope();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollisionModel_getSig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollisionModel *arg1 = (Pythia8::SubCollisionModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::SubCollisionModel::SigEst result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SubCollisionModel_getSig",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollisionModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollisionModel_getSig" "', argument " "1"" of type '" "Pythia8::SubCollisionModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollisionModel * >(argp1);
  result = ((Pythia8::SubCollisionModel const *)arg1)->getSig();
  resultobj = SWIG_NewPointerObj((new Pythia8::SubCollisionModel::SigEst(static_cast< const Pythia8::SubCollisionModel::SigEst& >(result))), SWIGTYPE_p_Pythia8__SubCollisionModel__SigEst, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollisionModel_avNDB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollisionModel *arg1 = (Pythia8::SubCollisionModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SubCollisionModel_avNDB",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollisionModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollisionModel_avNDB" "', argument " "1"" of type '" "Pythia8::SubCollisionModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollisionModel * >(argp1);
  result = (double)((Pythia8::SubCollisionModel const *)arg1)->avNDB();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollisionModel_Chi2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollisionModel *arg1 = (Pythia8::SubCollisionModel *) 0 ;
  Pythia8::SubCollisionModel::SigEst *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:SubCollisionModel_Chi2",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollisionModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollisionModel_Chi2" "', argument " "1"" of type '" "Pythia8::SubCollisionModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollisionModel * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__SubCollisionModel__SigEst,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SubCollisionModel_Chi2" "', argument " "2"" of type '" "Pythia8::SubCollisionModel::SigEst const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SubCollisionModel_Chi2" "', argument " "2"" of type '" "Pythia8::SubCollisionModel::SigEst const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::SubCollisionModel::SigEst * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SubCollisionModel_Chi2" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (double)((Pythia8::SubCollisionModel const *)arg1)->Chi2((Pythia8::SubCollisionModel::SigEst const &)*arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollisionModel_evolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollisionModel *arg1 = (Pythia8::SubCollisionModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SubCollisionModel_evolve",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollisionModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollisionModel_evolve" "', argument " "1"" of type '" "Pythia8::SubCollisionModel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollisionModel * >(argp1);
  result = (bool)(arg1)->evolve();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollisionModel_setParm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollisionModel *arg1 = (Pythia8::SubCollisionModel *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:SubCollisionModel_setParm",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollisionModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollisionModel_setParm" "', argument " "1"" of type '" "Pythia8::SubCollisionModel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollisionModel * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SubCollisionModel_setParm" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SubCollisionModel_setParm" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg2 = ptr;
  }
  (arg1)->setParm((std::vector< double,std::allocator< double > > const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollisionModel_getParm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollisionModel *arg1 = (Pythia8::SubCollisionModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double,std::allocator< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SubCollisionModel_getParm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollisionModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollisionModel_getParm" "', argument " "1"" of type '" "Pythia8::SubCollisionModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollisionModel * >(argp1);
  result = ((Pythia8::SubCollisionModel const *)arg1)->getParm();
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollisionModel_minParm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollisionModel *arg1 = (Pythia8::SubCollisionModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double,std::allocator< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SubCollisionModel_minParm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollisionModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollisionModel_minParm" "', argument " "1"" of type '" "Pythia8::SubCollisionModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollisionModel * >(argp1);
  result = ((Pythia8::SubCollisionModel const *)arg1)->minParm();
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SubCollisionModel_maxParm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::SubCollisionModel *arg1 = (Pythia8::SubCollisionModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double,std::allocator< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:SubCollisionModel_maxParm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__SubCollisionModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SubCollisionModel_maxParm" "', argument " "1"" of type '" "Pythia8::SubCollisionModel const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::SubCollisionModel * >(argp1);
  result = ((Pythia8::SubCollisionModel const *)arg1)->maxParm();
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SubCollisionModel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__SubCollisionModel, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_NaiveSubCollisionModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::NaiveSubCollisionModel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_NaiveSubCollisionModel")) SWIG_fail;
  result = (Pythia8::NaiveSubCollisionModel *)new Pythia8::NaiveSubCollisionModel();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__NaiveSubCollisionModel, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_NaiveSubCollisionModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::NaiveSubCollisionModel *arg1 = (Pythia8::NaiveSubCollisionModel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_NaiveSubCollisionModel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__NaiveSubCollisionModel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NaiveSubCollisionModel" "', argument " "1"" of type '" "Pythia8::NaiveSubCollisionModel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::NaiveSubCollisionModel * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_NaiveSubCollisionModel_getCollisions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::NaiveSubCollisionModel *arg1 = (Pythia8::NaiveSubCollisionModel *) 0 ;
  std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > *arg2 = 0 ;
  std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > *arg3 = 0 ;
  Pythia8::Vec4 *arg4 = 0 ;
  double *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  SwigValueWrapper< std::multiset< Pythia8::SubCollision > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:NaiveSubCollisionModel_getCollisions",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__NaiveSubCollisionModel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NaiveSubCollisionModel_getCollisions" "', argument " "1"" of type '" "Pythia8::NaiveSubCollisionModel *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::NaiveSubCollisionModel * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__Nucleon_std__allocatorT_Pythia8__Nucleon_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NaiveSubCollisionModel_getCollisions" "', argument " "2"" of type '" "std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NaiveSubCollisionModel_getCollisions" "', argument " "2"" of type '" "std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_Pythia8__Nucleon_std__allocatorT_Pythia8__Nucleon_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NaiveSubCollisionModel_getCollisions" "', argument " "3"" of type '" "std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NaiveSubCollisionModel_getCollisions" "', argument " "3"" of type '" "std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NaiveSubCollisionModel_getCollisions" "', argument " "4"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NaiveSubCollisionModel_getCollisions" "', argument " "4"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Vec4 * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NaiveSubCollisionModel_getCollisions" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NaiveSubCollisionModel_getCollisions" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  result = (arg1)->getCollisions(*arg2,*arg3,(Pythia8::Vec4 const &)*arg4,*arg5);
  resultobj = SWIG_NewPointerObj((new std::multiset< Pythia8::SubCollision >(static_cast< const std::multiset< Pythia8::SubCollision >& >(result))), SWIGTYPE_p_std__multisetT_Pythia8__SubCollision_std__lessT_Pythia8__SubCollision_t_std__allocatorT_Pythia8__SubCollision_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *NaiveSubCollisionModel_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__NaiveSubCollisionModel, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DoubleStrikman__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::DoubleStrikman *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_DoubleStrikman",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DoubleStrikman" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::DoubleStrikman *)new Pythia8::DoubleStrikman(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__DoubleStrikman, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoubleStrikman__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DoubleStrikman *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_DoubleStrikman")) SWIG_fail;
  result = (Pythia8::DoubleStrikman *)new Pythia8::DoubleStrikman();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__DoubleStrikman, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoubleStrikman(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_DoubleStrikman__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_DoubleStrikman__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DoubleStrikman'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::DoubleStrikman::DoubleStrikman(int)\n"
    "    Pythia8::DoubleStrikman::DoubleStrikman()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_DoubleStrikman(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DoubleStrikman *arg1 = (Pythia8::DoubleStrikman *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleStrikman",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DoubleStrikman, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleStrikman" "', argument " "1"" of type '" "Pythia8::DoubleStrikman *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DoubleStrikman * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleStrikman_getCollisions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DoubleStrikman *arg1 = (Pythia8::DoubleStrikman *) 0 ;
  std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > *arg2 = 0 ;
  std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > *arg3 = 0 ;
  Pythia8::Vec4 *arg4 = 0 ;
  double *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  SwigValueWrapper< std::multiset< Pythia8::SubCollision > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:DoubleStrikman_getCollisions",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DoubleStrikman, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleStrikman_getCollisions" "', argument " "1"" of type '" "Pythia8::DoubleStrikman *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DoubleStrikman * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__Nucleon_std__allocatorT_Pythia8__Nucleon_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleStrikman_getCollisions" "', argument " "2"" of type '" "std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleStrikman_getCollisions" "', argument " "2"" of type '" "std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_Pythia8__Nucleon_std__allocatorT_Pythia8__Nucleon_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoubleStrikman_getCollisions" "', argument " "3"" of type '" "std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleStrikman_getCollisions" "', argument " "3"" of type '" "std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DoubleStrikman_getCollisions" "', argument " "4"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleStrikman_getCollisions" "', argument " "4"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Vec4 * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DoubleStrikman_getCollisions" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleStrikman_getCollisions" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  result = (arg1)->getCollisions(*arg2,*arg3,(Pythia8::Vec4 const &)*arg4,*arg5);
  resultobj = SWIG_NewPointerObj((new std::multiset< Pythia8::SubCollision >(static_cast< const std::multiset< Pythia8::SubCollision >& >(result))), SWIGTYPE_p_std__multisetT_Pythia8__SubCollision_std__lessT_Pythia8__SubCollision_t_std__allocatorT_Pythia8__SubCollision_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleStrikman_gamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DoubleStrikman *arg1 = (Pythia8::DoubleStrikman *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DoubleStrikman_gamma",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DoubleStrikman, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleStrikman_gamma" "', argument " "1"" of type '" "Pythia8::DoubleStrikman const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DoubleStrikman * >(argp1);
  result = (double)((Pythia8::DoubleStrikman const *)arg1)->gamma();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleStrikman_opacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DoubleStrikman *arg1 = (Pythia8::DoubleStrikman *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:DoubleStrikman_opacity",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DoubleStrikman, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleStrikman_opacity" "', argument " "1"" of type '" "Pythia8::DoubleStrikman const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DoubleStrikman * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleStrikman_opacity" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (double)((Pythia8::DoubleStrikman const *)arg1)->opacity(arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleStrikman_Tpt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DoubleStrikman *arg1 = (Pythia8::DoubleStrikman *) 0 ;
  Pythia8::Nucleon::State *arg2 = 0 ;
  Pythia8::Nucleon::State *arg3 = 0 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:DoubleStrikman_Tpt",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DoubleStrikman, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleStrikman_Tpt" "', argument " "1"" of type '" "Pythia8::DoubleStrikman const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DoubleStrikman * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleStrikman_Tpt" "', argument " "2"" of type '" "Pythia8::Nucleon::State const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleStrikman_Tpt" "', argument " "2"" of type '" "Pythia8::Nucleon::State const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoubleStrikman_Tpt" "', argument " "3"" of type '" "Pythia8::Nucleon::State const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleStrikman_Tpt" "', argument " "3"" of type '" "Pythia8::Nucleon::State const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoubleStrikman_Tpt" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)((Pythia8::DoubleStrikman const *)arg1)->Tpt((Pythia8::Nucleon::State const &)*arg2,(Pythia8::Nucleon::State const &)*arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleStrikman_getSig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DoubleStrikman *arg1 = (Pythia8::DoubleStrikman *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::SubCollisionModel::SigEst result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DoubleStrikman_getSig",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DoubleStrikman, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleStrikman_getSig" "', argument " "1"" of type '" "Pythia8::DoubleStrikman const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DoubleStrikman * >(argp1);
  result = ((Pythia8::DoubleStrikman const *)arg1)->getSig();
  resultobj = SWIG_NewPointerObj((new Pythia8::SubCollisionModel::SigEst(static_cast< const Pythia8::SubCollisionModel::SigEst& >(result))), SWIGTYPE_p_Pythia8__SubCollisionModel__SigEst, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleStrikman_setParm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DoubleStrikman *arg1 = (Pythia8::DoubleStrikman *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:DoubleStrikman_setParm",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DoubleStrikman, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleStrikman_setParm" "', argument " "1"" of type '" "Pythia8::DoubleStrikman *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DoubleStrikman * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleStrikman_setParm" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleStrikman_setParm" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg2 = ptr;
  }
  (arg1)->setParm((std::vector< double,std::allocator< double > > const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleStrikman_getParm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DoubleStrikman *arg1 = (Pythia8::DoubleStrikman *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double,std::allocator< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DoubleStrikman_getParm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DoubleStrikman, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleStrikman_getParm" "', argument " "1"" of type '" "Pythia8::DoubleStrikman const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DoubleStrikman * >(argp1);
  result = ((Pythia8::DoubleStrikman const *)arg1)->getParm();
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleStrikman_minParm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DoubleStrikman *arg1 = (Pythia8::DoubleStrikman *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double,std::allocator< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DoubleStrikman_minParm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DoubleStrikman, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleStrikman_minParm" "', argument " "1"" of type '" "Pythia8::DoubleStrikman const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DoubleStrikman * >(argp1);
  result = ((Pythia8::DoubleStrikman const *)arg1)->minParm();
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleStrikman_maxParm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::DoubleStrikman *arg1 = (Pythia8::DoubleStrikman *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double,std::allocator< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:DoubleStrikman_maxParm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__DoubleStrikman, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleStrikman_maxParm" "', argument " "1"" of type '" "Pythia8::DoubleStrikman const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::DoubleStrikman * >(argp1);
  result = ((Pythia8::DoubleStrikman const *)arg1)->maxParm();
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleStrikman_shuffle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:DoubleStrikman_shuffle",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DoubleStrikman_shuffle" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleStrikman_shuffle" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoubleStrikman_shuffle" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleStrikman_shuffle" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DoubleStrikman_shuffle" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleStrikman_shuffle" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  Pythia8::DoubleStrikman::shuffle(arg1,arg2,*arg3,*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleStrikman_shuffel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:DoubleStrikman_shuffel",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleStrikman_shuffel" "', argument " "1"" of type '" "double &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleStrikman_shuffel" "', argument " "1"" of type '" "double &""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleStrikman_shuffel" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleStrikman_shuffel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoubleStrikman_shuffel" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DoubleStrikman_shuffel" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  Pythia8::DoubleStrikman::shuffel(*arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleStrikman_PNW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleStrikman_PNW",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DoubleStrikman_PNW" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleStrikman_PNW" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleStrikman_PNW" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (double)Pythia8::DoubleStrikman::PNW(arg1,arg2,arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DoubleStrikman_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__DoubleStrikman, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MultiRadial__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::MultiRadial *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MultiRadial",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MultiRadial" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::MultiRadial *)new Pythia8::MultiRadial(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MultiRadial, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MultiRadial__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultiRadial *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MultiRadial")) SWIG_fail;
  result = (Pythia8::MultiRadial *)new Pythia8::MultiRadial();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MultiRadial, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MultiRadial(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_MultiRadial__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_MultiRadial__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MultiRadial'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::MultiRadial::MultiRadial(int)\n"
    "    Pythia8::MultiRadial::MultiRadial()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MultiRadial(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultiRadial *arg1 = (Pythia8::MultiRadial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MultiRadial",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultiRadial, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MultiRadial" "', argument " "1"" of type '" "Pythia8::MultiRadial *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultiRadial * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiRadial_getCollisions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultiRadial *arg1 = (Pythia8::MultiRadial *) 0 ;
  std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > *arg2 = 0 ;
  std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > *arg3 = 0 ;
  Pythia8::Vec4 *arg4 = 0 ;
  double *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  SwigValueWrapper< std::multiset< Pythia8::SubCollision > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:MultiRadial_getCollisions",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultiRadial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiRadial_getCollisions" "', argument " "1"" of type '" "Pythia8::MultiRadial *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultiRadial * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__Nucleon_std__allocatorT_Pythia8__Nucleon_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultiRadial_getCollisions" "', argument " "2"" of type '" "std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultiRadial_getCollisions" "', argument " "2"" of type '" "std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_Pythia8__Nucleon_std__allocatorT_Pythia8__Nucleon_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MultiRadial_getCollisions" "', argument " "3"" of type '" "std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultiRadial_getCollisions" "', argument " "3"" of type '" "std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MultiRadial_getCollisions" "', argument " "4"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultiRadial_getCollisions" "', argument " "4"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg4 = reinterpret_cast< Pythia8::Vec4 * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MultiRadial_getCollisions" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultiRadial_getCollisions" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  result = (arg1)->getCollisions(*arg2,*arg3,(Pythia8::Vec4 const &)*arg4,*arg5);
  resultobj = SWIG_NewPointerObj((new std::multiset< Pythia8::SubCollision >(static_cast< const std::multiset< Pythia8::SubCollision >& >(result))), SWIGTYPE_p_std__multisetT_Pythia8__SubCollision_std__lessT_Pythia8__SubCollision_t_std__allocatorT_Pythia8__SubCollision_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiRadial_Tpt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultiRadial *arg1 = (Pythia8::MultiRadial *) 0 ;
  Pythia8::Nucleon::State *arg2 = 0 ;
  Pythia8::Nucleon::State *arg3 = 0 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:MultiRadial_Tpt",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultiRadial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiRadial_Tpt" "', argument " "1"" of type '" "Pythia8::MultiRadial const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultiRadial * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultiRadial_Tpt" "', argument " "2"" of type '" "Pythia8::Nucleon::State const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultiRadial_Tpt" "', argument " "2"" of type '" "Pythia8::Nucleon::State const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MultiRadial_Tpt" "', argument " "3"" of type '" "Pythia8::Nucleon::State const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultiRadial_Tpt" "', argument " "3"" of type '" "Pythia8::Nucleon::State const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MultiRadial_Tpt" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (double)((Pythia8::MultiRadial const *)arg1)->Tpt((Pythia8::Nucleon::State const &)*arg2,(Pythia8::Nucleon::State const &)*arg3,arg4);
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiRadial_getSig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultiRadial *arg1 = (Pythia8::MultiRadial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::SubCollisionModel::SigEst result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MultiRadial_getSig",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultiRadial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiRadial_getSig" "', argument " "1"" of type '" "Pythia8::MultiRadial const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultiRadial * >(argp1);
  result = ((Pythia8::MultiRadial const *)arg1)->getSig();
  resultobj = SWIG_NewPointerObj((new Pythia8::SubCollisionModel::SigEst(static_cast< const Pythia8::SubCollisionModel::SigEst& >(result))), SWIGTYPE_p_Pythia8__SubCollisionModel__SigEst, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiRadial_setParm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultiRadial *arg1 = (Pythia8::MultiRadial *) 0 ;
  std::vector< double,std::allocator< double > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MultiRadial_setParm",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultiRadial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiRadial_setParm" "', argument " "1"" of type '" "Pythia8::MultiRadial *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultiRadial * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultiRadial_setParm" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultiRadial_setParm" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg2 = ptr;
  }
  (arg1)->setParm((std::vector< double,std::allocator< double > > const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiRadial_getParm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultiRadial *arg1 = (Pythia8::MultiRadial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double,std::allocator< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MultiRadial_getParm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultiRadial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiRadial_getParm" "', argument " "1"" of type '" "Pythia8::MultiRadial const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultiRadial * >(argp1);
  result = ((Pythia8::MultiRadial const *)arg1)->getParm();
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiRadial_minParm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultiRadial *arg1 = (Pythia8::MultiRadial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double,std::allocator< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MultiRadial_minParm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultiRadial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiRadial_minParm" "', argument " "1"" of type '" "Pythia8::MultiRadial const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultiRadial * >(argp1);
  result = ((Pythia8::MultiRadial const *)arg1)->minParm();
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MultiRadial_maxParm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MultiRadial *arg1 = (Pythia8::MultiRadial *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double,std::allocator< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MultiRadial_maxParm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MultiRadial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiRadial_maxParm" "', argument " "1"" of type '" "Pythia8::MultiRadial const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MultiRadial * >(argp1);
  result = ((Pythia8::MultiRadial const *)arg1)->maxParm();
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MultiRadial_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__MultiRadial, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_EventInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EventInfo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_EventInfo")) SWIG_fail;
  result = (Pythia8::EventInfo *)new Pythia8::EventInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__EventInfo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventInfo_event_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EventInfo *arg1 = (Pythia8::EventInfo *) 0 ;
  Pythia8::Event *arg2 = (Pythia8::Event *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:EventInfo_event_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EventInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventInfo_event_set" "', argument " "1"" of type '" "Pythia8::EventInfo *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EventInfo * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EventInfo_event_set" "', argument " "2"" of type '" "Pythia8::Event *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  if (arg1) (arg1)->event = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventInfo_event_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EventInfo *arg1 = (Pythia8::EventInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Event *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:EventInfo_event_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EventInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventInfo_event_get" "', argument " "1"" of type '" "Pythia8::EventInfo *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EventInfo * >(argp1);
  result = (Pythia8::Event *)& ((arg1)->event);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Event, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventInfo_info_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EventInfo *arg1 = (Pythia8::EventInfo *) 0 ;
  Pythia8::Info *arg2 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:EventInfo_info_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EventInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventInfo_info_set" "', argument " "1"" of type '" "Pythia8::EventInfo *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EventInfo * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EventInfo_info_set" "', argument " "2"" of type '" "Pythia8::Info *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Info * >(argp2);
  if (arg1) (arg1)->info = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventInfo_info_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EventInfo *arg1 = (Pythia8::EventInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Info *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:EventInfo_info_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EventInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventInfo_info_get" "', argument " "1"" of type '" "Pythia8::EventInfo *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EventInfo * >(argp1);
  result = (Pythia8::Info *)& ((arg1)->info);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventInfo_ordering_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EventInfo *arg1 = (Pythia8::EventInfo *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:EventInfo_ordering_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EventInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventInfo_ordering_set" "', argument " "1"" of type '" "Pythia8::EventInfo *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EventInfo * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventInfo_ordering_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->ordering = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventInfo_ordering_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EventInfo *arg1 = (Pythia8::EventInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:EventInfo_ordering_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EventInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventInfo_ordering_get" "', argument " "1"" of type '" "Pythia8::EventInfo *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EventInfo * >(argp1);
  result = (double) ((arg1)->ordering);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventInfo___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EventInfo *arg1 = (Pythia8::EventInfo *) 0 ;
  Pythia8::EventInfo *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:EventInfo___lt__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EventInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventInfo___lt__" "', argument " "1"" of type '" "Pythia8::EventInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EventInfo * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__EventInfo,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EventInfo___lt__" "', argument " "2"" of type '" "Pythia8::EventInfo const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EventInfo___lt__" "', argument " "2"" of type '" "Pythia8::EventInfo const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::EventInfo * >(argp2);
  result = (bool)((Pythia8::EventInfo const *)arg1)->operator <((Pythia8::EventInfo const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventInfo_coll_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EventInfo *arg1 = (Pythia8::EventInfo *) 0 ;
  Pythia8::SubCollision *arg2 = (Pythia8::SubCollision *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:EventInfo_coll_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EventInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventInfo_coll_set" "', argument " "1"" of type '" "Pythia8::EventInfo *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EventInfo * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__SubCollision, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EventInfo_coll_set" "', argument " "2"" of type '" "Pythia8::SubCollision const *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::SubCollision * >(argp2);
  if (arg1) (arg1)->coll = (Pythia8::SubCollision const *)arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventInfo_coll_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EventInfo *arg1 = (Pythia8::EventInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::SubCollision *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:EventInfo_coll_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EventInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventInfo_coll_get" "', argument " "1"" of type '" "Pythia8::EventInfo *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EventInfo * >(argp1);
  result = (Pythia8::SubCollision *) ((arg1)->coll);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SubCollision, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventInfo_ok_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EventInfo *arg1 = (Pythia8::EventInfo *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:EventInfo_ok_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EventInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventInfo_ok_set" "', argument " "1"" of type '" "Pythia8::EventInfo *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EventInfo * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventInfo_ok_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->ok = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventInfo_ok_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EventInfo *arg1 = (Pythia8::EventInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:EventInfo_ok_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EventInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventInfo_ok_get" "', argument " "1"" of type '" "Pythia8::EventInfo *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EventInfo * >(argp1);
  result = (bool) ((arg1)->ok);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventInfo_projs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EventInfo *arg1 = (Pythia8::EventInfo *) 0 ;
  std::map< Pythia8::Nucleon *,std::pair< int,int >,std::less< Pythia8::Nucleon * >,std::allocator< std::pair< Pythia8::Nucleon *const,std::pair< int,int > > > > *arg2 = (std::map< Pythia8::Nucleon *,std::pair< int,int >,std::less< Pythia8::Nucleon * >,std::allocator< std::pair< Pythia8::Nucleon *const,std::pair< int,int > > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:EventInfo_projs_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EventInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventInfo_projs_set" "', argument " "1"" of type '" "Pythia8::EventInfo *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EventInfo * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_Pythia8__Nucleon_p_std__pairT_int_int_t_std__lessT_Pythia8__Nucleon_p_t_std__allocatorT_std__pairT_Pythia8__Nucleon_pconst_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EventInfo_projs_set" "', argument " "2"" of type '" "std::map< Pythia8::Nucleon *,std::pair< int,int >,std::less< Pythia8::Nucleon * >,std::allocator< std::pair< Pythia8::Nucleon *const,std::pair< int,int > > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< Pythia8::Nucleon *,std::pair< int,int >,std::less< Pythia8::Nucleon * >,std::allocator< std::pair< Pythia8::Nucleon *const,std::pair< int,int > > > > * >(argp2);
  if (arg1) (arg1)->projs = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventInfo_projs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EventInfo *arg1 = (Pythia8::EventInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< Pythia8::Nucleon *,std::pair< int,int >,std::less< Pythia8::Nucleon * >,std::allocator< std::pair< Pythia8::Nucleon *const,std::pair< int,int > > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:EventInfo_projs_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EventInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventInfo_projs_get" "', argument " "1"" of type '" "Pythia8::EventInfo *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EventInfo * >(argp1);
  result = (std::map< Pythia8::Nucleon *,std::pair< int,int >,std::less< Pythia8::Nucleon * >,std::allocator< std::pair< Pythia8::Nucleon *const,std::pair< int,int > > > > *)& ((arg1)->projs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_Pythia8__Nucleon_p_std__pairT_int_int_t_std__lessT_Pythia8__Nucleon_p_t_std__allocatorT_std__pairT_Pythia8__Nucleon_pconst_std__pairT_int_int_t_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventInfo_targs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EventInfo *arg1 = (Pythia8::EventInfo *) 0 ;
  std::map< Pythia8::Nucleon *,std::pair< int,int >,std::less< Pythia8::Nucleon * >,std::allocator< std::pair< Pythia8::Nucleon *const,std::pair< int,int > > > > *arg2 = (std::map< Pythia8::Nucleon *,std::pair< int,int >,std::less< Pythia8::Nucleon * >,std::allocator< std::pair< Pythia8::Nucleon *const,std::pair< int,int > > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:EventInfo_targs_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EventInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventInfo_targs_set" "', argument " "1"" of type '" "Pythia8::EventInfo *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EventInfo * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__mapT_Pythia8__Nucleon_p_std__pairT_int_int_t_std__lessT_Pythia8__Nucleon_p_t_std__allocatorT_std__pairT_Pythia8__Nucleon_pconst_std__pairT_int_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EventInfo_targs_set" "', argument " "2"" of type '" "std::map< Pythia8::Nucleon *,std::pair< int,int >,std::less< Pythia8::Nucleon * >,std::allocator< std::pair< Pythia8::Nucleon *const,std::pair< int,int > > > > *""'"); 
  }
  arg2 = reinterpret_cast< std::map< Pythia8::Nucleon *,std::pair< int,int >,std::less< Pythia8::Nucleon * >,std::allocator< std::pair< Pythia8::Nucleon *const,std::pair< int,int > > > > * >(argp2);
  if (arg1) (arg1)->targs = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_EventInfo_targs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EventInfo *arg1 = (Pythia8::EventInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< Pythia8::Nucleon *,std::pair< int,int >,std::less< Pythia8::Nucleon * >,std::allocator< std::pair< Pythia8::Nucleon *const,std::pair< int,int > > > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:EventInfo_targs_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EventInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventInfo_targs_get" "', argument " "1"" of type '" "Pythia8::EventInfo *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EventInfo * >(argp1);
  result = (std::map< Pythia8::Nucleon *,std::pair< int,int >,std::less< Pythia8::Nucleon * >,std::allocator< std::pair< Pythia8::Nucleon *const,std::pair< int,int > > > > *)& ((arg1)->targs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_Pythia8__Nucleon_p_std__pairT_int_int_t_std__lessT_Pythia8__Nucleon_p_t_std__allocatorT_std__pairT_Pythia8__Nucleon_pconst_std__pairT_int_int_t_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_EventInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::EventInfo *arg1 = (Pythia8::EventInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_EventInfo",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__EventInfo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventInfo" "', argument " "1"" of type '" "Pythia8::EventInfo *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::EventInfo * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *EventInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__EventInfo, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_HIInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HIInfo")) SWIG_fail;
  result = (Pythia8::HIInfo *)new Pythia8::HIInfo();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HIInfo, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_b(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_b",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_b" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (double)((Pythia8::HIInfo const *)arg1)->b();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_sigmaTot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_sigmaTot",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_sigmaTot" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (double)((Pythia8::HIInfo const *)arg1)->sigmaTot();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_sigmaTotErr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_sigmaTotErr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_sigmaTotErr" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (double)((Pythia8::HIInfo const *)arg1)->sigmaTotErr();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_sigmaND(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_sigmaND",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_sigmaND" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (double)((Pythia8::HIInfo const *)arg1)->sigmaND();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_sigmaNDErr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_sigmaNDErr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_sigmaNDErr" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (double)((Pythia8::HIInfo const *)arg1)->sigmaNDErr();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_nAttempts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  long result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_nAttempts",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_nAttempts" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (long)((Pythia8::HIInfo const *)arg1)->nAttempts();
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_nAccepted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  long result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_nAccepted",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_nAccepted" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (long)((Pythia8::HIInfo const *)arg1)->nAccepted();
  resultobj = SWIG_From_long(static_cast< long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_nCollTot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_nCollTot",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_nCollTot" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (int)((Pythia8::HIInfo const *)arg1)->nCollTot();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_nCollND(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_nCollND",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_nCollND" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (int)((Pythia8::HIInfo const *)arg1)->nCollND();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_nCollNDTot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_nCollNDTot",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_nCollNDTot" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (int)((Pythia8::HIInfo const *)arg1)->nCollNDTot();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_nCollSDP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_nCollSDP",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_nCollSDP" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (int)((Pythia8::HIInfo const *)arg1)->nCollSDP();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_nCollSDT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_nCollSDT",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_nCollSDT" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (int)((Pythia8::HIInfo const *)arg1)->nCollSDT();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_nCollDD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_nCollDD",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_nCollDD" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (int)((Pythia8::HIInfo const *)arg1)->nCollDD();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_nCollCD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_nCollCD",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_nCollCD" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (int)((Pythia8::HIInfo const *)arg1)->nCollCD();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_nCollEL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_nCollEL",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_nCollEL" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (int)((Pythia8::HIInfo const *)arg1)->nCollEL();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_nPartProj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_nPartProj",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_nPartProj" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (int)((Pythia8::HIInfo const *)arg1)->nPartProj();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_nAbsProj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_nAbsProj",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_nAbsProj" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (int)((Pythia8::HIInfo const *)arg1)->nAbsProj();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_nDiffProj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_nDiffProj",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_nDiffProj" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (int)((Pythia8::HIInfo const *)arg1)->nDiffProj();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_nElProj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_nElProj",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_nElProj" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (int)((Pythia8::HIInfo const *)arg1)->nElProj();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_nPartTarg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_nPartTarg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_nPartTarg" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (int)((Pythia8::HIInfo const *)arg1)->nPartTarg();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_nAbsTarg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_nAbsTarg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_nAbsTarg" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (int)((Pythia8::HIInfo const *)arg1)->nAbsTarg();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_nDiffTarg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_nDiffTarg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_nDiffTarg" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (int)((Pythia8::HIInfo const *)arg1)->nDiffTarg();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_nElTarg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_nElTarg",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_nElTarg" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (int)((Pythia8::HIInfo const *)arg1)->nElTarg();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_weight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_weight",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_weight" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (double)((Pythia8::HIInfo const *)arg1)->weight();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_weightSum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_weightSum",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_weightSum" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (double)((Pythia8::HIInfo const *)arg1)->weightSum();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_nFail(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_nFail",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_nFail" "', argument " "1"" of type '" "Pythia8::HIInfo const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (int)((Pythia8::HIInfo const *)arg1)->nFail();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_failedExcitation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_failedExcitation",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_failedExcitation" "', argument " "1"" of type '" "Pythia8::HIInfo *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  (arg1)->failedExcitation();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_subCollisionsPtr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::multiset< Pythia8::SubCollision > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIInfo_subCollisionsPtr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_subCollisionsPtr" "', argument " "1"" of type '" "Pythia8::HIInfo *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  result = (std::multiset< Pythia8::SubCollision > *)(arg1)->subCollisionsPtr();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__multisetT_Pythia8__SubCollision_std__lessT_Pythia8__SubCollision_t_std__allocatorT_Pythia8__SubCollision_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_subCollisionsPtr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  std::multiset< Pythia8::SubCollision > *arg2 = (std::multiset< Pythia8::SubCollision > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HIInfo_subCollisionsPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIInfo_subCollisionsPtr" "', argument " "1"" of type '" "Pythia8::HIInfo *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__multisetT_Pythia8__SubCollision_std__lessT_Pythia8__SubCollision_t_std__allocatorT_Pythia8__SubCollision_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HIInfo_subCollisionsPtr" "', argument " "2"" of type '" "std::multiset< Pythia8::SubCollision > *""'"); 
  }
  arg2 = reinterpret_cast< std::multiset< Pythia8::SubCollision > * >(argp2);
  (arg1)->subCollisionsPtr(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIInfo_subCollisionsPtr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HIInfo, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_HIInfo_subCollisionsPtr__SWIG_0(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__HIInfo, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__multisetT_Pythia8__SubCollision_std__lessT_Pythia8__SubCollision_t_std__allocatorT_Pythia8__SubCollision_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_HIInfo_subCollisionsPtr__SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'HIInfo_subCollisionsPtr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::HIInfo::subCollisionsPtr()\n"
    "    Pythia8::HIInfo::subCollisionsPtr(std::multiset< Pythia8::SubCollision > *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_HIInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIInfo *arg1 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HIInfo",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIInfo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HIInfo" "', argument " "1"" of type '" "Pythia8::HIInfo *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIInfo * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HIInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HIInfo, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_HIUserHooks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIUserHooks *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_HIUserHooks")) SWIG_fail;
  result = (Pythia8::HIUserHooks *)new Pythia8::HIUserHooks();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HIUserHooks, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HIUserHooks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIUserHooks *arg1 = (Pythia8::HIUserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HIUserHooks",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIUserHooks, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HIUserHooks" "', argument " "1"" of type '" "Pythia8::HIUserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIUserHooks * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIUserHooks_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIUserHooks *arg1 = (Pythia8::HIUserHooks *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:HIUserHooks_init",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIUserHooks_init" "', argument " "1"" of type '" "Pythia8::HIUserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIUserHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HIUserHooks_init" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HIUserHooks_init" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->init(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIUserHooks_hasImpactParameterGenerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIUserHooks *arg1 = (Pythia8::HIUserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIUserHooks_hasImpactParameterGenerator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIUserHooks_hasImpactParameterGenerator" "', argument " "1"" of type '" "Pythia8::HIUserHooks const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIUserHooks * >(argp1);
  result = (bool)((Pythia8::HIUserHooks const *)arg1)->hasImpactParameterGenerator();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIUserHooks_impactParameterGenerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIUserHooks *arg1 = (Pythia8::HIUserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::ImpactParameterGenerator *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIUserHooks_impactParameterGenerator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIUserHooks_impactParameterGenerator" "', argument " "1"" of type '" "Pythia8::HIUserHooks const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIUserHooks * >(argp1);
  result = (Pythia8::ImpactParameterGenerator *)((Pythia8::HIUserHooks const *)arg1)->impactParameterGenerator();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ImpactParameterGenerator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIUserHooks_hasProjectileModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIUserHooks *arg1 = (Pythia8::HIUserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIUserHooks_hasProjectileModel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIUserHooks_hasProjectileModel" "', argument " "1"" of type '" "Pythia8::HIUserHooks const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIUserHooks * >(argp1);
  result = (bool)((Pythia8::HIUserHooks const *)arg1)->hasProjectileModel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIUserHooks_projectileModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIUserHooks *arg1 = (Pythia8::HIUserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::NucleusModel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIUserHooks_projectileModel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIUserHooks_projectileModel" "', argument " "1"" of type '" "Pythia8::HIUserHooks const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIUserHooks * >(argp1);
  result = (Pythia8::NucleusModel *)((Pythia8::HIUserHooks const *)arg1)->projectileModel();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__NucleusModel, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIUserHooks_hasTargetModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIUserHooks *arg1 = (Pythia8::HIUserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIUserHooks_hasTargetModel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIUserHooks_hasTargetModel" "', argument " "1"" of type '" "Pythia8::HIUserHooks const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIUserHooks * >(argp1);
  result = (bool)((Pythia8::HIUserHooks const *)arg1)->hasTargetModel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIUserHooks_targetModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIUserHooks *arg1 = (Pythia8::HIUserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::NucleusModel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIUserHooks_targetModel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIUserHooks_targetModel" "', argument " "1"" of type '" "Pythia8::HIUserHooks const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIUserHooks * >(argp1);
  result = (Pythia8::NucleusModel *)((Pythia8::HIUserHooks const *)arg1)->targetModel();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__NucleusModel, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIUserHooks_hasSubCollisionModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIUserHooks *arg1 = (Pythia8::HIUserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIUserHooks_hasSubCollisionModel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIUserHooks_hasSubCollisionModel" "', argument " "1"" of type '" "Pythia8::HIUserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIUserHooks * >(argp1);
  result = (bool)(arg1)->hasSubCollisionModel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIUserHooks_subCollisionModel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIUserHooks *arg1 = (Pythia8::HIUserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::SubCollisionModel *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIUserHooks_subCollisionModel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIUserHooks_subCollisionModel" "', argument " "1"" of type '" "Pythia8::HIUserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIUserHooks * >(argp1);
  result = (Pythia8::SubCollisionModel *)(arg1)->subCollisionModel();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SubCollisionModel, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIUserHooks_hasEventOrdering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIUserHooks *arg1 = (Pythia8::HIUserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIUserHooks_hasEventOrdering",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIUserHooks_hasEventOrdering" "', argument " "1"" of type '" "Pythia8::HIUserHooks const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIUserHooks * >(argp1);
  result = (bool)((Pythia8::HIUserHooks const *)arg1)->hasEventOrdering();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIUserHooks_eventOrdering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIUserHooks *arg1 = (Pythia8::HIUserHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  Pythia8::Info *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:HIUserHooks_eventOrdering",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIUserHooks_eventOrdering" "', argument " "1"" of type '" "Pythia8::HIUserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIUserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HIUserHooks_eventOrdering" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HIUserHooks_eventOrdering" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Info,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HIUserHooks_eventOrdering" "', argument " "3"" of type '" "Pythia8::Info const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HIUserHooks_eventOrdering" "', argument " "3"" of type '" "Pythia8::Info const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Info * >(argp3);
  result = (double)(arg1)->eventOrdering((Pythia8::Event const &)*arg2,(Pythia8::Info const &)*arg3);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIUserHooks_canFixIsoSpin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIUserHooks *arg1 = (Pythia8::HIUserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIUserHooks_canFixIsoSpin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIUserHooks_canFixIsoSpin" "', argument " "1"" of type '" "Pythia8::HIUserHooks const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIUserHooks * >(argp1);
  result = (bool)((Pythia8::HIUserHooks const *)arg1)->canFixIsoSpin();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIUserHooks_fixIsoSpin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIUserHooks *arg1 = (Pythia8::HIUserHooks *) 0 ;
  Pythia8::EventInfo *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HIUserHooks_fixIsoSpin",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIUserHooks_fixIsoSpin" "', argument " "1"" of type '" "Pythia8::HIUserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIUserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__EventInfo,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HIUserHooks_fixIsoSpin" "', argument " "2"" of type '" "Pythia8::EventInfo &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HIUserHooks_fixIsoSpin" "', argument " "2"" of type '" "Pythia8::EventInfo &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::EventInfo * >(argp2);
  result = (bool)(arg1)->fixIsoSpin(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIUserHooks_canShiftEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIUserHooks *arg1 = (Pythia8::HIUserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIUserHooks_canShiftEvent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIUserHooks_canShiftEvent" "', argument " "1"" of type '" "Pythia8::HIUserHooks const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIUserHooks * >(argp1);
  result = (bool)((Pythia8::HIUserHooks const *)arg1)->canShiftEvent();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIUserHooks_shiftEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIUserHooks *arg1 = (Pythia8::HIUserHooks *) 0 ;
  Pythia8::EventInfo *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::EventInfo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HIUserHooks_shiftEvent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIUserHooks_shiftEvent" "', argument " "1"" of type '" "Pythia8::HIUserHooks const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIUserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__EventInfo,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HIUserHooks_shiftEvent" "', argument " "2"" of type '" "Pythia8::EventInfo &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HIUserHooks_shiftEvent" "', argument " "2"" of type '" "Pythia8::EventInfo &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::EventInfo * >(argp2);
  result = (Pythia8::EventInfo *) &((Pythia8::HIUserHooks const *)arg1)->shiftEvent(*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__EventInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIUserHooks_canAddNucleonExcitation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIUserHooks *arg1 = (Pythia8::HIUserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIUserHooks_canAddNucleonExcitation",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIUserHooks_canAddNucleonExcitation" "', argument " "1"" of type '" "Pythia8::HIUserHooks const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIUserHooks * >(argp1);
  result = (bool)((Pythia8::HIUserHooks const *)arg1)->canAddNucleonExcitation();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIUserHooks_addNucleonExcitation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIUserHooks *arg1 = (Pythia8::HIUserHooks *) 0 ;
  Pythia8::EventInfo *arg2 = 0 ;
  Pythia8::EventInfo *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:HIUserHooks_addNucleonExcitation",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIUserHooks_addNucleonExcitation" "', argument " "1"" of type '" "Pythia8::HIUserHooks const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIUserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__EventInfo,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HIUserHooks_addNucleonExcitation" "', argument " "2"" of type '" "Pythia8::EventInfo &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HIUserHooks_addNucleonExcitation" "', argument " "2"" of type '" "Pythia8::EventInfo &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::EventInfo * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__EventInfo,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HIUserHooks_addNucleonExcitation" "', argument " "3"" of type '" "Pythia8::EventInfo &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HIUserHooks_addNucleonExcitation" "', argument " "3"" of type '" "Pythia8::EventInfo &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::EventInfo * >(argp3);
  ecode4 = SWIG_AsVal_bool(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HIUserHooks_addNucleonExcitation" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  result = (bool)((Pythia8::HIUserHooks const *)arg1)->addNucleonExcitation(*arg2,*arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIUserHooks_canForceHadronLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIUserHooks *arg1 = (Pythia8::HIUserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIUserHooks_canForceHadronLevel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIUserHooks_canForceHadronLevel" "', argument " "1"" of type '" "Pythia8::HIUserHooks const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIUserHooks * >(argp1);
  result = (bool)((Pythia8::HIUserHooks const *)arg1)->canForceHadronLevel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIUserHooks_forceHadronLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIUserHooks *arg1 = (Pythia8::HIUserHooks *) 0 ;
  Pythia8::Pythia *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HIUserHooks_forceHadronLevel",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIUserHooks_forceHadronLevel" "', argument " "1"" of type '" "Pythia8::HIUserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIUserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Pythia,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HIUserHooks_forceHadronLevel" "', argument " "2"" of type '" "Pythia8::Pythia &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HIUserHooks_forceHadronLevel" "', argument " "2"" of type '" "Pythia8::Pythia &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Pythia * >(argp2);
  result = (bool)(arg1)->forceHadronLevel(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIUserHooks_canFindRecoilers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIUserHooks *arg1 = (Pythia8::HIUserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HIUserHooks_canFindRecoilers",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIUserHooks_canFindRecoilers" "', argument " "1"" of type '" "Pythia8::HIUserHooks const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIUserHooks * >(argp1);
  result = (bool)((Pythia8::HIUserHooks const *)arg1)->canFindRecoilers();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HIUserHooks_findRecoilers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HIUserHooks *arg1 = (Pythia8::HIUserHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  bool arg3 ;
  int arg4 ;
  int arg5 ;
  Pythia8::Vec4 *arg6 = 0 ;
  Pythia8::Vec4 *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  std::vector< int,std::allocator< int > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:HIUserHooks_findRecoilers",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HIUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HIUserHooks_findRecoilers" "', argument " "1"" of type '" "Pythia8::HIUserHooks const *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HIUserHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HIUserHooks_findRecoilers" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HIUserHooks_findRecoilers" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_bool(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HIUserHooks_findRecoilers" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HIUserHooks_findRecoilers" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "HIUserHooks_findRecoilers" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "HIUserHooks_findRecoilers" "', argument " "6"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HIUserHooks_findRecoilers" "', argument " "6"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg6 = reinterpret_cast< Pythia8::Vec4 * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "HIUserHooks_findRecoilers" "', argument " "7"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HIUserHooks_findRecoilers" "', argument " "7"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::Vec4 * >(argp7);
  result = ((Pythia8::HIUserHooks const *)arg1)->findRecoilers((Pythia8::Event const &)*arg2,arg3,arg4,arg5,(Pythia8::Vec4 const &)*arg6,(Pythia8::Vec4 const &)*arg7);
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HIUserHooks_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HIUserHooks, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_amcnlo_unitarised_interface__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::amcnlo_unitarised_interface *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_amcnlo_unitarised_interface")) SWIG_fail;
  result = (Pythia8::amcnlo_unitarised_interface *)new Pythia8::amcnlo_unitarised_interface();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__amcnlo_unitarised_interface, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_amcnlo_unitarised_interface__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::amcnlo_unitarised_interface *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_amcnlo_unitarised_interface",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_amcnlo_unitarised_interface" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::amcnlo_unitarised_interface *)new Pythia8::amcnlo_unitarised_interface(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__amcnlo_unitarised_interface, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_amcnlo_unitarised_interface(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_amcnlo_unitarised_interface__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_amcnlo_unitarised_interface__SWIG_1(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_amcnlo_unitarised_interface'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::amcnlo_unitarised_interface::amcnlo_unitarised_interface()\n"
    "    Pythia8::amcnlo_unitarised_interface::amcnlo_unitarised_interface(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_amcnlo_unitarised_interface(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::amcnlo_unitarised_interface *arg1 = (Pythia8::amcnlo_unitarised_interface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_amcnlo_unitarised_interface",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__amcnlo_unitarised_interface, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_amcnlo_unitarised_interface" "', argument " "1"" of type '" "Pythia8::amcnlo_unitarised_interface *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::amcnlo_unitarised_interface * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_amcnlo_unitarised_interface_getNormFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::amcnlo_unitarised_interface *arg1 = (Pythia8::amcnlo_unitarised_interface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:amcnlo_unitarised_interface_getNormFactor",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__amcnlo_unitarised_interface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "amcnlo_unitarised_interface_getNormFactor" "', argument " "1"" of type '" "Pythia8::amcnlo_unitarised_interface *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::amcnlo_unitarised_interface * >(argp1);
  result = (double)(arg1)->getNormFactor();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_amcnlo_unitarised_interface_canVetoProcessLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::amcnlo_unitarised_interface *arg1 = (Pythia8::amcnlo_unitarised_interface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:amcnlo_unitarised_interface_canVetoProcessLevel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__amcnlo_unitarised_interface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "amcnlo_unitarised_interface_canVetoProcessLevel" "', argument " "1"" of type '" "Pythia8::amcnlo_unitarised_interface *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::amcnlo_unitarised_interface * >(argp1);
  result = (bool)(arg1)->canVetoProcessLevel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_amcnlo_unitarised_interface_doVetoProcessLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::amcnlo_unitarised_interface *arg1 = (Pythia8::amcnlo_unitarised_interface *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:amcnlo_unitarised_interface_doVetoProcessLevel",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__amcnlo_unitarised_interface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "amcnlo_unitarised_interface_doVetoProcessLevel" "', argument " "1"" of type '" "Pythia8::amcnlo_unitarised_interface *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::amcnlo_unitarised_interface * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "amcnlo_unitarised_interface_doVetoProcessLevel" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "amcnlo_unitarised_interface_doVetoProcessLevel" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->doVetoProcessLevel(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *amcnlo_unitarised_interface_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__amcnlo_unitarised_interface, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MBReconUserHooks__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::MBReconUserHooks *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_MBReconUserHooks",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MBReconUserHooks" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MBReconUserHooks" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MBReconUserHooks" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MBReconUserHooks" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (Pythia8::MBReconUserHooks *)new Pythia8::MBReconUserHooks(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MBReconUserHooks, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MBReconUserHooks__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  double arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::MBReconUserHooks *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_MBReconUserHooks",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MBReconUserHooks" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MBReconUserHooks" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MBReconUserHooks" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (Pythia8::MBReconUserHooks *)new Pythia8::MBReconUserHooks(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MBReconUserHooks, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MBReconUserHooks__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::MBReconUserHooks *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_MBReconUserHooks",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MBReconUserHooks" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MBReconUserHooks" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (Pythia8::MBReconUserHooks *)new Pythia8::MBReconUserHooks(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MBReconUserHooks, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MBReconUserHooks__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::MBReconUserHooks *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MBReconUserHooks",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MBReconUserHooks" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::MBReconUserHooks *)new Pythia8::MBReconUserHooks(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MBReconUserHooks, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MBReconUserHooks__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MBReconUserHooks *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MBReconUserHooks")) SWIG_fail;
  result = (Pythia8::MBReconUserHooks *)new Pythia8::MBReconUserHooks();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MBReconUserHooks, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MBReconUserHooks(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_MBReconUserHooks__SWIG_4(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_MBReconUserHooks__SWIG_3(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_MBReconUserHooks__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_MBReconUserHooks__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_MBReconUserHooks__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MBReconUserHooks'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::MBReconUserHooks::MBReconUserHooks(int,int,double,double)\n"
    "    Pythia8::MBReconUserHooks::MBReconUserHooks(int,int,double)\n"
    "    Pythia8::MBReconUserHooks::MBReconUserHooks(int,int)\n"
    "    Pythia8::MBReconUserHooks::MBReconUserHooks(int)\n"
    "    Pythia8::MBReconUserHooks::MBReconUserHooks()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_MBReconUserHooks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MBReconUserHooks *arg1 = (Pythia8::MBReconUserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MBReconUserHooks",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MBReconUserHooks, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MBReconUserHooks" "', argument " "1"" of type '" "Pythia8::MBReconUserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MBReconUserHooks * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MBReconUserHooks_canReconnectResonanceSystems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MBReconUserHooks *arg1 = (Pythia8::MBReconUserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MBReconUserHooks_canReconnectResonanceSystems",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MBReconUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MBReconUserHooks_canReconnectResonanceSystems" "', argument " "1"" of type '" "Pythia8::MBReconUserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MBReconUserHooks * >(argp1);
  result = (bool)(arg1)->canReconnectResonanceSystems();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MBReconUserHooks_doReconnectResonanceSystems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MBReconUserHooks *arg1 = (Pythia8::MBReconUserHooks *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MBReconUserHooks_doReconnectResonanceSystems",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MBReconUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MBReconUserHooks_doReconnectResonanceSystems" "', argument " "1"" of type '" "Pythia8::MBReconUserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MBReconUserHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MBReconUserHooks_doReconnectResonanceSystems" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MBReconUserHooks_doReconnectResonanceSystems" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MBReconUserHooks_doReconnectResonanceSystems" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  result = (bool)(arg1)->doReconnectResonanceSystems(arg2,*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MBReconUserHooks_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__MBReconUserHooks, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_TopReconUserHooks__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::TopReconUserHooks *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_TopReconUserHooks",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TopReconUserHooks" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TopReconUserHooks" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (Pythia8::TopReconUserHooks *)new Pythia8::TopReconUserHooks(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TopReconUserHooks, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TopReconUserHooks__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::TopReconUserHooks *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_TopReconUserHooks",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TopReconUserHooks" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  result = (Pythia8::TopReconUserHooks *)new Pythia8::TopReconUserHooks(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TopReconUserHooks, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TopReconUserHooks__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TopReconUserHooks *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_TopReconUserHooks")) SWIG_fail;
  result = (Pythia8::TopReconUserHooks *)new Pythia8::TopReconUserHooks();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__TopReconUserHooks, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_TopReconUserHooks(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_TopReconUserHooks__SWIG_2(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_TopReconUserHooks__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TopReconUserHooks__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_TopReconUserHooks'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::TopReconUserHooks::TopReconUserHooks(int,double)\n"
    "    Pythia8::TopReconUserHooks::TopReconUserHooks(int)\n"
    "    Pythia8::TopReconUserHooks::TopReconUserHooks()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_TopReconUserHooks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TopReconUserHooks *arg1 = (Pythia8::TopReconUserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_TopReconUserHooks",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TopReconUserHooks, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TopReconUserHooks" "', argument " "1"" of type '" "Pythia8::TopReconUserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TopReconUserHooks * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TopReconUserHooks_canReconnectResonanceSystems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TopReconUserHooks *arg1 = (Pythia8::TopReconUserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:TopReconUserHooks_canReconnectResonanceSystems",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TopReconUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TopReconUserHooks_canReconnectResonanceSystems" "', argument " "1"" of type '" "Pythia8::TopReconUserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TopReconUserHooks * >(argp1);
  result = (bool)(arg1)->canReconnectResonanceSystems();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_TopReconUserHooks_doReconnectResonanceSystems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::TopReconUserHooks *arg1 = (Pythia8::TopReconUserHooks *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:TopReconUserHooks_doReconnectResonanceSystems",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__TopReconUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TopReconUserHooks_doReconnectResonanceSystems" "', argument " "1"" of type '" "Pythia8::TopReconUserHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::TopReconUserHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TopReconUserHooks_doReconnectResonanceSystems" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TopReconUserHooks_doReconnectResonanceSystems" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TopReconUserHooks_doReconnectResonanceSystems" "', argument " "3"" of type '" "Pythia8::Event &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  result = (bool)(arg1)->doReconnectResonanceSystems(arg2,*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *TopReconUserHooks_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__TopReconUserHooks, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AlpgenPar__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::AlpgenPar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AlpgenPar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AlpgenPar" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (Pythia8::AlpgenPar *)new Pythia8::AlpgenPar(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__AlpgenPar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AlpgenPar__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlpgenPar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_AlpgenPar")) SWIG_fail;
  result = (Pythia8::AlpgenPar *)new Pythia8::AlpgenPar();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__AlpgenPar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_AlpgenPar(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_AlpgenPar__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AlpgenPar__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_AlpgenPar'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::AlpgenPar::AlpgenPar(Pythia8::Info *)\n"
    "    Pythia8::AlpgenPar::AlpgenPar()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_AlpgenPar_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlpgenPar *arg1 = (Pythia8::AlpgenPar *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:AlpgenPar_parse",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlpgenPar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlpgenPar_parse" "', argument " "1"" of type '" "Pythia8::AlpgenPar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlpgenPar * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "AlpgenPar_parse" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->parse(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlpgenPar_extractRunParam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlpgenPar *arg1 = (Pythia8::AlpgenPar *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:AlpgenPar_extractRunParam",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlpgenPar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlpgenPar_extractRunParam" "', argument " "1"" of type '" "Pythia8::AlpgenPar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlpgenPar * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "AlpgenPar_extractRunParam" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->extractRunParam(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlpgenPar_haveParam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlpgenPar *arg1 = (Pythia8::AlpgenPar *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:AlpgenPar_haveParam",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlpgenPar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlpgenPar_haveParam" "', argument " "1"" of type '" "Pythia8::AlpgenPar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlpgenPar * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlpgenPar_haveParam" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlpgenPar_haveParam" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->haveParam((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlpgenPar_getParam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlpgenPar *arg1 = (Pythia8::AlpgenPar *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:AlpgenPar_getParam",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlpgenPar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlpgenPar_getParam" "', argument " "1"" of type '" "Pythia8::AlpgenPar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlpgenPar * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlpgenPar_getParam" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlpgenPar_getParam" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (double)(arg1)->getParam((std::string const &)*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlpgenPar_getParamAsInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlpgenPar *arg1 = (Pythia8::AlpgenPar *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:AlpgenPar_getParamAsInt",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlpgenPar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlpgenPar_getParamAsInt" "', argument " "1"" of type '" "Pythia8::AlpgenPar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlpgenPar * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlpgenPar_getParamAsInt" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlpgenPar_getParamAsInt" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->getParamAsInt((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlpgenPar_printParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlpgenPar *arg1 = (Pythia8::AlpgenPar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:AlpgenPar_printParams",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlpgenPar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlpgenPar_printParams" "', argument " "1"" of type '" "Pythia8::AlpgenPar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlpgenPar * >(argp1);
  (arg1)->printParams();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AlpgenPar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlpgenPar *arg1 = (Pythia8::AlpgenPar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AlpgenPar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlpgenPar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AlpgenPar" "', argument " "1"" of type '" "Pythia8::AlpgenPar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlpgenPar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AlpgenPar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__AlpgenPar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_LHAupAlpgen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupAlpgen *arg1 = (Pythia8::LHAupAlpgen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LHAupAlpgen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupAlpgen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LHAupAlpgen" "', argument " "1"" of type '" "Pythia8::LHAupAlpgen *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupAlpgen * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupAlpgen_fileFound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupAlpgen *arg1 = (Pythia8::LHAupAlpgen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAupAlpgen_fileFound",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupAlpgen, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupAlpgen_fileFound" "', argument " "1"" of type '" "Pythia8::LHAupAlpgen *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupAlpgen * >(argp1);
  result = (bool)(arg1)->fileFound();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupAlpgen_setInit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupAlpgen *arg1 = (Pythia8::LHAupAlpgen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAupAlpgen_setInit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupAlpgen, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupAlpgen_setInit" "', argument " "1"" of type '" "Pythia8::LHAupAlpgen *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupAlpgen * >(argp1);
  result = (bool)(arg1)->setInit();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupAlpgen_setEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupAlpgen *arg1 = (Pythia8::LHAupAlpgen *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAupAlpgen_setEvent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupAlpgen, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupAlpgen_setEvent" "', argument " "1"" of type '" "Pythia8::LHAupAlpgen *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupAlpgen * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAupAlpgen_setEvent" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->setEvent(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupAlpgen_printParticles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupAlpgen *arg1 = (Pythia8::LHAupAlpgen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAupAlpgen_printParticles",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupAlpgen, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupAlpgen_printParticles" "', argument " "1"" of type '" "Pythia8::LHAupAlpgen *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupAlpgen * >(argp1);
  (arg1)->printParticles();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *LHAupAlpgen_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__LHAupAlpgen, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_AlpgenHooks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::AlpgenHooks *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_AlpgenHooks",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Pythia,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AlpgenHooks" "', argument " "1"" of type '" "Pythia8::Pythia &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AlpgenHooks" "', argument " "1"" of type '" "Pythia8::Pythia &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (Pythia8::AlpgenHooks *)new Pythia8::AlpgenHooks(*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__AlpgenHooks, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_AlpgenHooks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlpgenHooks *arg1 = (Pythia8::AlpgenHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_AlpgenHooks",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlpgenHooks, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AlpgenHooks" "', argument " "1"" of type '" "Pythia8::AlpgenHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlpgenHooks * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_AlpgenHooks_initAfterBeams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::AlpgenHooks *arg1 = (Pythia8::AlpgenHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:AlpgenHooks_initAfterBeams",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__AlpgenHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlpgenHooks_initAfterBeams" "', argument " "1"" of type '" "Pythia8::AlpgenHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::AlpgenHooks * >(argp1);
  result = (bool)(arg1)->initAfterBeams();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *AlpgenHooks_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__AlpgenHooks, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MadgraphPar__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Info *arg1 = (Pythia8::Info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::MadgraphPar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MadgraphPar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MadgraphPar" "', argument " "1"" of type '" "Pythia8::Info *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Info * >(argp1);
  result = (Pythia8::MadgraphPar *)new Pythia8::MadgraphPar(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MadgraphPar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MadgraphPar__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MadgraphPar *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MadgraphPar")) SWIG_fail;
  result = (Pythia8::MadgraphPar *)new Pythia8::MadgraphPar();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MadgraphPar, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MadgraphPar(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_MadgraphPar__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Info, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MadgraphPar__SWIG_0(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MadgraphPar'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::MadgraphPar::MadgraphPar(Pythia8::Info *)\n"
    "    Pythia8::MadgraphPar::MadgraphPar()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MadgraphPar_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MadgraphPar *arg1 = (Pythia8::MadgraphPar *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MadgraphPar_parse",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MadgraphPar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MadgraphPar_parse" "', argument " "1"" of type '" "Pythia8::MadgraphPar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MadgraphPar * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MadgraphPar_parse" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->parse(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MadgraphPar_extractRunParam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MadgraphPar *arg1 = (Pythia8::MadgraphPar *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MadgraphPar_extractRunParam",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MadgraphPar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MadgraphPar_extractRunParam" "', argument " "1"" of type '" "Pythia8::MadgraphPar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MadgraphPar * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MadgraphPar_extractRunParam" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->extractRunParam(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MadgraphPar_haveParam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MadgraphPar *arg1 = (Pythia8::MadgraphPar *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MadgraphPar_haveParam",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MadgraphPar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MadgraphPar_haveParam" "', argument " "1"" of type '" "Pythia8::MadgraphPar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MadgraphPar * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MadgraphPar_haveParam" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MadgraphPar_haveParam" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->haveParam((std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MadgraphPar_getParam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MadgraphPar *arg1 = (Pythia8::MadgraphPar *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MadgraphPar_getParam",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MadgraphPar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MadgraphPar_getParam" "', argument " "1"" of type '" "Pythia8::MadgraphPar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MadgraphPar * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MadgraphPar_getParam" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MadgraphPar_getParam" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (double)(arg1)->getParam((std::string const &)*arg2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MadgraphPar_getParamAsInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MadgraphPar *arg1 = (Pythia8::MadgraphPar *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MadgraphPar_getParamAsInt",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MadgraphPar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MadgraphPar_getParamAsInt" "', argument " "1"" of type '" "Pythia8::MadgraphPar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MadgraphPar * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MadgraphPar_getParamAsInt" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MadgraphPar_getParamAsInt" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)(arg1)->getParamAsInt((std::string const &)*arg2);
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MadgraphPar_printParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MadgraphPar *arg1 = (Pythia8::MadgraphPar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MadgraphPar_printParams",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MadgraphPar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MadgraphPar_printParams" "', argument " "1"" of type '" "Pythia8::MadgraphPar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MadgraphPar * >(argp1);
  (arg1)->printParams();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MadgraphPar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::MadgraphPar *arg1 = (Pythia8::MadgraphPar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MadgraphPar",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__MadgraphPar, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MadgraphPar" "', argument " "1"" of type '" "Pythia8::MadgraphPar *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::MadgraphPar * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MadgraphPar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__MadgraphPar, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_HJSlowJet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  int arg6 ;
  Pythia8::SlowJetHook *arg7 = (Pythia8::SlowJetHook *) 0 ;
  bool arg8 ;
  bool arg9 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  Pythia8::HJSlowJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_HJSlowJet",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HJSlowJet" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HJSlowJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HJSlowJet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HJSlowJet" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HJSlowJet" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HJSlowJet" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__SlowJetHook, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_HJSlowJet" "', argument " "7"" of type '" "Pythia8::SlowJetHook *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::SlowJetHook * >(argp7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_HJSlowJet" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_bool(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_HJSlowJet" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  result = (Pythia8::HJSlowJet *)new Pythia8::HJSlowJet(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HJSlowJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HJSlowJet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  int arg6 ;
  Pythia8::SlowJetHook *arg7 = (Pythia8::SlowJetHook *) 0 ;
  bool arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  Pythia8::HJSlowJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:new_HJSlowJet",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HJSlowJet" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HJSlowJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HJSlowJet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HJSlowJet" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HJSlowJet" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HJSlowJet" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__SlowJetHook, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_HJSlowJet" "', argument " "7"" of type '" "Pythia8::SlowJetHook *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::SlowJetHook * >(argp7);
  ecode8 = SWIG_AsVal_bool(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_HJSlowJet" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  result = (Pythia8::HJSlowJet *)new Pythia8::HJSlowJet(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HJSlowJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HJSlowJet__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  int arg6 ;
  Pythia8::SlowJetHook *arg7 = (Pythia8::SlowJetHook *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  Pythia8::HJSlowJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_HJSlowJet",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HJSlowJet" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HJSlowJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HJSlowJet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HJSlowJet" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HJSlowJet" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HJSlowJet" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Pythia8__SlowJetHook, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_HJSlowJet" "', argument " "7"" of type '" "Pythia8::SlowJetHook *""'"); 
  }
  arg7 = reinterpret_cast< Pythia8::SlowJetHook * >(argp7);
  result = (Pythia8::HJSlowJet *)new Pythia8::HJSlowJet(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HJSlowJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HJSlowJet__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  int arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  Pythia8::HJSlowJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_HJSlowJet",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HJSlowJet" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HJSlowJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HJSlowJet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HJSlowJet" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HJSlowJet" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_HJSlowJet" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (Pythia8::HJSlowJet *)new Pythia8::HJSlowJet(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HJSlowJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HJSlowJet__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::HJSlowJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_HJSlowJet",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HJSlowJet" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HJSlowJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HJSlowJet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HJSlowJet" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HJSlowJet" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = (Pythia8::HJSlowJet *)new Pythia8::HJSlowJet(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HJSlowJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HJSlowJet__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::HJSlowJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_HJSlowJet",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HJSlowJet" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HJSlowJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HJSlowJet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HJSlowJet" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (Pythia8::HJSlowJet *)new Pythia8::HJSlowJet(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HJSlowJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HJSlowJet__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::HJSlowJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_HJSlowJet",&obj0,&obj1,&obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HJSlowJet" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HJSlowJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_HJSlowJet" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (Pythia8::HJSlowJet *)new Pythia8::HJSlowJet(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HJSlowJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HJSlowJet__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::HJSlowJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_HJSlowJet",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HJSlowJet" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HJSlowJet" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = (Pythia8::HJSlowJet *)new Pythia8::HJSlowJet(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HJSlowJet, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HJSlowJet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[10] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 9) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_HJSlowJet__SWIG_7(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_HJSlowJet__SWIG_6(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_HJSlowJet__SWIG_5(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_HJSlowJet__SWIG_4(self, args);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_HJSlowJet__SWIG_3(self, args);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__SlowJetHook, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_new_HJSlowJet__SWIG_2(self, args);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__SlowJetHook, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_HJSlowJet__SWIG_1(self, args);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Pythia8__SlowJetHook, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_HJSlowJet__SWIG_0(self, args);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_HJSlowJet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::HJSlowJet::HJSlowJet(int,double,double,double,int,int,Pythia8::SlowJetHook *,bool,bool)\n"
    "    Pythia8::HJSlowJet::HJSlowJet(int,double,double,double,int,int,Pythia8::SlowJetHook *,bool)\n"
    "    Pythia8::HJSlowJet::HJSlowJet(int,double,double,double,int,int,Pythia8::SlowJetHook *)\n"
    "    Pythia8::HJSlowJet::HJSlowJet(int,double,double,double,int,int)\n"
    "    Pythia8::HJSlowJet::HJSlowJet(int,double,double,double,int)\n"
    "    Pythia8::HJSlowJet::HJSlowJet(int,double,double,double)\n"
    "    Pythia8::HJSlowJet::HJSlowJet(int,double,double)\n"
    "    Pythia8::HJSlowJet::HJSlowJet(int,double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_HJSlowJet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HJSlowJet *arg1 = (Pythia8::HJSlowJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HJSlowJet",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HJSlowJet, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HJSlowJet" "', argument " "1"" of type '" "Pythia8::HJSlowJet *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HJSlowJet * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HJSlowJet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HJSlowJet, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_JetMatching(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatching *arg1 = (Pythia8::JetMatching *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_JetMatching",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatching, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_JetMatching" "', argument " "1"" of type '" "Pythia8::JetMatching *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatching * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatching_initAfterBeams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatching *arg1 = (Pythia8::JetMatching *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:JetMatching_initAfterBeams",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatching, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatching_initAfterBeams" "', argument " "1"" of type '" "Pythia8::JetMatching *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatching * >(argp1);
  result = (bool)(arg1)->initAfterBeams();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatching_canVetoProcessLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatching *arg1 = (Pythia8::JetMatching *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:JetMatching_canVetoProcessLevel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatching, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatching_canVetoProcessLevel" "', argument " "1"" of type '" "Pythia8::JetMatching *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatching * >(argp1);
  result = (bool)(arg1)->canVetoProcessLevel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatching_doVetoProcessLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatching *arg1 = (Pythia8::JetMatching *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:JetMatching_doVetoProcessLevel",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatching, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatching_doVetoProcessLevel" "', argument " "1"" of type '" "Pythia8::JetMatching *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatching * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JetMatching_doVetoProcessLevel" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JetMatching_doVetoProcessLevel" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->doVetoProcessLevel(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatching_canVetoPartonLevelEarly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatching *arg1 = (Pythia8::JetMatching *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:JetMatching_canVetoPartonLevelEarly",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatching, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatching_canVetoPartonLevelEarly" "', argument " "1"" of type '" "Pythia8::JetMatching *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatching * >(argp1);
  result = (bool)(arg1)->canVetoPartonLevelEarly();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatching_doVetoPartonLevelEarly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatching *arg1 = (Pythia8::JetMatching *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:JetMatching_doVetoPartonLevelEarly",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatching, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatching_doVetoPartonLevelEarly" "', argument " "1"" of type '" "Pythia8::JetMatching *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatching * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JetMatching_doVetoPartonLevelEarly" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JetMatching_doVetoPartonLevelEarly" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->doVetoPartonLevelEarly((Pythia8::Event const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatching_numberVetoStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatching *arg1 = (Pythia8::JetMatching *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:JetMatching_numberVetoStep",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatching, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatching_numberVetoStep" "', argument " "1"" of type '" "Pythia8::JetMatching *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatching * >(argp1);
  result = (int)(arg1)->numberVetoStep();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatching_canVetoStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatching *arg1 = (Pythia8::JetMatching *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:JetMatching_canVetoStep",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatching, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatching_canVetoStep" "', argument " "1"" of type '" "Pythia8::JetMatching *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatching * >(argp1);
  result = (bool)(arg1)->canVetoStep();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatching_doVetoStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatching *arg1 = (Pythia8::JetMatching *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  Pythia8::Event *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:JetMatching_doVetoStep",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatching, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatching_doVetoStep" "', argument " "1"" of type '" "Pythia8::JetMatching *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatching * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JetMatching_doVetoStep" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "JetMatching_doVetoStep" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "JetMatching_doVetoStep" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "JetMatching_doVetoStep" "', argument " "5"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JetMatching_doVetoStep" "', argument " "5"" of type '" "Pythia8::Event const &""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Event * >(argp5);
  result = (bool)(arg1)->doVetoStep(arg2,arg3,arg4,(Pythia8::Event const &)*arg5);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *JetMatching_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__JetMatching, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_JetMatchingAlpgen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingAlpgen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_JetMatchingAlpgen")) SWIG_fail;
  result = (Pythia8::JetMatchingAlpgen *)new Pythia8::JetMatchingAlpgen();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__JetMatchingAlpgen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_JetMatchingAlpgen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingAlpgen *arg1 = (Pythia8::JetMatchingAlpgen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_JetMatchingAlpgen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingAlpgen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_JetMatchingAlpgen" "', argument " "1"" of type '" "Pythia8::JetMatchingAlpgen *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingAlpgen * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatchingAlpgen_initAfterBeams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingAlpgen *arg1 = (Pythia8::JetMatchingAlpgen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:JetMatchingAlpgen_initAfterBeams",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingAlpgen, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatchingAlpgen_initAfterBeams" "', argument " "1"" of type '" "Pythia8::JetMatchingAlpgen *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingAlpgen * >(argp1);
  result = (bool)(arg1)->initAfterBeams();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *JetMatchingAlpgen_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__JetMatchingAlpgen, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_JetMatchingMadgraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingMadgraph *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_JetMatchingMadgraph")) SWIG_fail;
  result = (Pythia8::JetMatchingMadgraph *)new Pythia8::JetMatchingMadgraph();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__JetMatchingMadgraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_JetMatchingMadgraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingMadgraph *arg1 = (Pythia8::JetMatchingMadgraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_JetMatchingMadgraph",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingMadgraph, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_JetMatchingMadgraph" "', argument " "1"" of type '" "Pythia8::JetMatchingMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingMadgraph * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatchingMadgraph_initAfterBeams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingMadgraph *arg1 = (Pythia8::JetMatchingMadgraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:JetMatchingMadgraph_initAfterBeams",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingMadgraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatchingMadgraph_initAfterBeams" "', argument " "1"" of type '" "Pythia8::JetMatchingMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingMadgraph * >(argp1);
  result = (bool)(arg1)->initAfterBeams();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatchingMadgraph_canVetoProcessLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingMadgraph *arg1 = (Pythia8::JetMatchingMadgraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:JetMatchingMadgraph_canVetoProcessLevel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingMadgraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatchingMadgraph_canVetoProcessLevel" "', argument " "1"" of type '" "Pythia8::JetMatchingMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingMadgraph * >(argp1);
  result = (bool)(arg1)->canVetoProcessLevel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatchingMadgraph_doVetoProcessLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingMadgraph *arg1 = (Pythia8::JetMatchingMadgraph *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:JetMatchingMadgraph_doVetoProcessLevel",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingMadgraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatchingMadgraph_doVetoProcessLevel" "', argument " "1"" of type '" "Pythia8::JetMatchingMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingMadgraph * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JetMatchingMadgraph_doVetoProcessLevel" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JetMatchingMadgraph_doVetoProcessLevel" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->doVetoProcessLevel(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatchingMadgraph_numberVetoStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingMadgraph *arg1 = (Pythia8::JetMatchingMadgraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:JetMatchingMadgraph_numberVetoStep",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingMadgraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatchingMadgraph_numberVetoStep" "', argument " "1"" of type '" "Pythia8::JetMatchingMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingMadgraph * >(argp1);
  result = (int)(arg1)->numberVetoStep();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatchingMadgraph_canVetoStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingMadgraph *arg1 = (Pythia8::JetMatchingMadgraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:JetMatchingMadgraph_canVetoStep",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingMadgraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatchingMadgraph_canVetoStep" "', argument " "1"" of type '" "Pythia8::JetMatchingMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingMadgraph * >(argp1);
  result = (bool)(arg1)->canVetoStep();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatchingMadgraph_doVetoStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingMadgraph *arg1 = (Pythia8::JetMatchingMadgraph *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  Pythia8::Event *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:JetMatchingMadgraph_doVetoStep",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingMadgraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatchingMadgraph_doVetoStep" "', argument " "1"" of type '" "Pythia8::JetMatchingMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingMadgraph * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JetMatchingMadgraph_doVetoStep" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "JetMatchingMadgraph_doVetoStep" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "JetMatchingMadgraph_doVetoStep" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "JetMatchingMadgraph_doVetoStep" "', argument " "5"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JetMatchingMadgraph_doVetoStep" "', argument " "5"" of type '" "Pythia8::Event const &""'"); 
  }
  arg5 = reinterpret_cast< Pythia8::Event * >(argp5);
  result = (bool)(arg1)->doVetoStep(arg2,arg3,arg4,(Pythia8::Event const &)*arg5);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatchingMadgraph_slowJetDJR_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingMadgraph *arg1 = (Pythia8::JetMatchingMadgraph *) 0 ;
  Pythia8::SlowJet *arg2 = (Pythia8::SlowJet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:JetMatchingMadgraph_slowJetDJR_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingMadgraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatchingMadgraph_slowJetDJR_set" "', argument " "1"" of type '" "Pythia8::JetMatchingMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingMadgraph * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__SlowJet, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JetMatchingMadgraph_slowJetDJR_set" "', argument " "2"" of type '" "Pythia8::SlowJet *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::SlowJet * >(argp2);
  if (arg1) (arg1)->slowJetDJR = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatchingMadgraph_slowJetDJR_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingMadgraph *arg1 = (Pythia8::JetMatchingMadgraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::SlowJet *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:JetMatchingMadgraph_slowJetDJR_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingMadgraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatchingMadgraph_slowJetDJR_get" "', argument " "1"" of type '" "Pythia8::JetMatchingMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingMadgraph * >(argp1);
  result = (Pythia8::SlowJet *) ((arg1)->slowJetDJR);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SlowJet, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatchingMadgraph_getDJR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingMadgraph *arg1 = (Pythia8::JetMatchingMadgraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< double,std::allocator< double > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:JetMatchingMadgraph_getDJR",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingMadgraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatchingMadgraph_getDJR" "', argument " "1"" of type '" "Pythia8::JetMatchingMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingMadgraph * >(argp1);
  result = (arg1)->getDJR();
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatchingMadgraph_nMEpartons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingMadgraph *arg1 = (Pythia8::JetMatchingMadgraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::pair< int,int > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:JetMatchingMadgraph_nMEpartons",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingMadgraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatchingMadgraph_nMEpartons" "', argument " "1"" of type '" "Pythia8::JetMatchingMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingMadgraph * >(argp1);
  result = (arg1)->nMEpartons();
  resultobj = swig::from(static_cast< std::pair< int,int > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatchingMadgraph_getWorkEventJet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingMadgraph *arg1 = (Pythia8::JetMatchingMadgraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Event result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:JetMatchingMadgraph_getWorkEventJet",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingMadgraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatchingMadgraph_getWorkEventJet" "', argument " "1"" of type '" "Pythia8::JetMatchingMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingMadgraph * >(argp1);
  result = (arg1)->getWorkEventJet();
  resultobj = SWIG_NewPointerObj((new Pythia8::Event(static_cast< const Pythia8::Event& >(result))), SWIGTYPE_p_Pythia8__Event, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatchingMadgraph_getProcessSubset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingMadgraph *arg1 = (Pythia8::JetMatchingMadgraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Event result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:JetMatchingMadgraph_getProcessSubset",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingMadgraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatchingMadgraph_getProcessSubset" "', argument " "1"" of type '" "Pythia8::JetMatchingMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingMadgraph * >(argp1);
  result = (arg1)->getProcessSubset();
  resultobj = SWIG_NewPointerObj((new Pythia8::Event(static_cast< const Pythia8::Event& >(result))), SWIGTYPE_p_Pythia8__Event, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatchingMadgraph_getExclusive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingMadgraph *arg1 = (Pythia8::JetMatchingMadgraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:JetMatchingMadgraph_getExclusive",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingMadgraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatchingMadgraph_getExclusive" "', argument " "1"" of type '" "Pythia8::JetMatchingMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingMadgraph * >(argp1);
  result = (bool)(arg1)->getExclusive();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatchingMadgraph_getPTfirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingMadgraph *arg1 = (Pythia8::JetMatchingMadgraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:JetMatchingMadgraph_getPTfirst",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingMadgraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatchingMadgraph_getPTfirst" "', argument " "1"" of type '" "Pythia8::JetMatchingMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingMadgraph * >(argp1);
  result = (double)(arg1)->getPTfirst();
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *JetMatchingMadgraph_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__JetMatchingMadgraph, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LHAupHelaconia__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::LHAupHelaconia *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_LHAupHelaconia",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAupHelaconia" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_LHAupHelaconia" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_LHAupHelaconia" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::LHAupHelaconia *)new Pythia8::LHAupHelaconia(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAupHelaconia, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAupHelaconia__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::LHAupHelaconia *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_LHAupHelaconia",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAupHelaconia" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_LHAupHelaconia" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::LHAupHelaconia *)new Pythia8::LHAupHelaconia(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAupHelaconia, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAupHelaconia__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHAupHelaconia *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LHAupHelaconia",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAupHelaconia" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (Pythia8::LHAupHelaconia *)new Pythia8::LHAupHelaconia(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAupHelaconia, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAupHelaconia(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LHAupHelaconia__SWIG_2(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_LHAupHelaconia__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_LHAupHelaconia__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LHAupHelaconia'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAupHelaconia::LHAupHelaconia(Pythia8::Pythia *,std::string,std::string)\n"
    "    Pythia8::LHAupHelaconia::LHAupHelaconia(Pythia8::Pythia *,std::string)\n"
    "    Pythia8::LHAupHelaconia::LHAupHelaconia(Pythia8::Pythia *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LHAupHelaconia(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupHelaconia *arg1 = (Pythia8::LHAupHelaconia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LHAupHelaconia",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupHelaconia, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LHAupHelaconia" "', argument " "1"" of type '" "Pythia8::LHAupHelaconia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupHelaconia * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupHelaconia_readString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupHelaconia *arg1 = (Pythia8::LHAupHelaconia *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAupHelaconia_readString",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupHelaconia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupHelaconia_readString" "', argument " "1"" of type '" "Pythia8::LHAupHelaconia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupHelaconia * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LHAupHelaconia_readString" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->readString(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupHelaconia_setEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupHelaconia *arg1 = (Pythia8::LHAupHelaconia *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAupHelaconia_setEvents",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupHelaconia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupHelaconia_setEvents" "', argument " "1"" of type '" "Pythia8::LHAupHelaconia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupHelaconia * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAupHelaconia_setEvents" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setEvents(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupHelaconia_setSeed__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupHelaconia *arg1 = (Pythia8::LHAupHelaconia *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:LHAupHelaconia_setSeed",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupHelaconia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupHelaconia_setSeed" "', argument " "1"" of type '" "Pythia8::LHAupHelaconia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupHelaconia * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAupHelaconia_setSeed" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAupHelaconia_setSeed" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (bool)(arg1)->setSeed(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupHelaconia_setSeed__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupHelaconia *arg1 = (Pythia8::LHAupHelaconia *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAupHelaconia_setSeed",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupHelaconia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupHelaconia_setSeed" "', argument " "1"" of type '" "Pythia8::LHAupHelaconia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupHelaconia * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAupHelaconia_setSeed" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->setSeed(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupHelaconia_setSeed(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAupHelaconia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LHAupHelaconia_setSeed__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAupHelaconia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LHAupHelaconia_setSeed__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LHAupHelaconia_setSeed'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAupHelaconia::setSeed(int,int)\n"
    "    Pythia8::LHAupHelaconia::setSeed(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAupHelaconia_setInit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupHelaconia *arg1 = (Pythia8::LHAupHelaconia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAupHelaconia_setInit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupHelaconia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupHelaconia_setInit" "', argument " "1"" of type '" "Pythia8::LHAupHelaconia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupHelaconia * >(argp1);
  result = (bool)(arg1)->setInit();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupHelaconia_setEvent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupHelaconia *arg1 = (Pythia8::LHAupHelaconia *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAupHelaconia_setEvent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupHelaconia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupHelaconia_setEvent" "', argument " "1"" of type '" "Pythia8::LHAupHelaconia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupHelaconia * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAupHelaconia_setEvent" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->setEvent(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupHelaconia_setEvent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupHelaconia *arg1 = (Pythia8::LHAupHelaconia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAupHelaconia_setEvent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupHelaconia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupHelaconia_setEvent" "', argument " "1"" of type '" "Pythia8::LHAupHelaconia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupHelaconia * >(argp1);
  result = (bool)(arg1)->setEvent();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupHelaconia_setEvent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAupHelaconia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LHAupHelaconia_setEvent__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAupHelaconia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LHAupHelaconia_setEvent__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LHAupHelaconia_setEvent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAupHelaconia::setEvent(int)\n"
    "    Pythia8::LHAupHelaconia::setEvent()\n");
  return 0;
}


SWIGINTERN PyObject *LHAupHelaconia_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__LHAupHelaconia, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_LHAupMadgraph__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  bool arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::LHAupMadgraph *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_LHAupMadgraph",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAupMadgraph" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LHAupMadgraph" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_LHAupMadgraph" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_LHAupMadgraph" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::LHAupMadgraph *)new Pythia8::LHAupMadgraph(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAupMadgraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAupMadgraph__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  bool arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::LHAupMadgraph *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_LHAupMadgraph",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAupMadgraph" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LHAupMadgraph" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_LHAupMadgraph" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::LHAupMadgraph *)new Pythia8::LHAupMadgraph(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAupMadgraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAupMadgraph__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::LHAupMadgraph *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_LHAupMadgraph",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAupMadgraph" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  ecode2 = SWIG_AsVal_bool(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LHAupMadgraph" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (Pythia8::LHAupMadgraph *)new Pythia8::LHAupMadgraph(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAupMadgraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAupMadgraph__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHAupMadgraph *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_LHAupMadgraph",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LHAupMadgraph" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (Pythia8::LHAupMadgraph *)new Pythia8::LHAupMadgraph(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAupMadgraph, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_LHAupMadgraph(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LHAupMadgraph__SWIG_3(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_LHAupMadgraph__SWIG_2(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_LHAupMadgraph__SWIG_1(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_LHAupMadgraph__SWIG_0(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LHAupMadgraph'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAupMadgraph::LHAupMadgraph(Pythia8::Pythia *,bool,std::string,std::string)\n"
    "    Pythia8::LHAupMadgraph::LHAupMadgraph(Pythia8::Pythia *,bool,std::string)\n"
    "    Pythia8::LHAupMadgraph::LHAupMadgraph(Pythia8::Pythia *,bool)\n"
    "    Pythia8::LHAupMadgraph::LHAupMadgraph(Pythia8::Pythia *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_LHAupMadgraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupMadgraph *arg1 = (Pythia8::LHAupMadgraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_LHAupMadgraph",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupMadgraph, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LHAupMadgraph" "', argument " "1"" of type '" "Pythia8::LHAupMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupMadgraph * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupMadgraph_readString__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupMadgraph *arg1 = (Pythia8::LHAupMadgraph *) 0 ;
  std::string arg2 ;
  Pythia8::LHAupMadgraph::Stage arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:LHAupMadgraph_readString",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupMadgraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupMadgraph_readString" "', argument " "1"" of type '" "Pythia8::LHAupMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupMadgraph * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LHAupMadgraph_readString" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAupMadgraph_readString" "', argument " "3"" of type '" "Pythia8::LHAupMadgraph::Stage""'");
  } 
  arg3 = static_cast< Pythia8::LHAupMadgraph::Stage >(val3);
  result = (bool)(arg1)->readString(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupMadgraph_readString__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupMadgraph *arg1 = (Pythia8::LHAupMadgraph *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAupMadgraph_readString",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupMadgraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupMadgraph_readString" "', argument " "1"" of type '" "Pythia8::LHAupMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupMadgraph * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LHAupMadgraph_readString" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->readString(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupMadgraph_readString(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAupMadgraph, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_LHAupMadgraph_readString__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAupMadgraph, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LHAupMadgraph_readString__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LHAupMadgraph_readString'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAupMadgraph::readString(std::string,Pythia8::LHAupMadgraph::Stage)\n"
    "    Pythia8::LHAupMadgraph::readString(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAupMadgraph_addCard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupMadgraph *arg1 = (Pythia8::LHAupMadgraph *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:LHAupMadgraph_addCard",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupMadgraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupMadgraph_addCard" "', argument " "1"" of type '" "Pythia8::LHAupMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupMadgraph * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LHAupMadgraph_addCard" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LHAupMadgraph_addCard" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->addCard(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupMadgraph_setEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupMadgraph *arg1 = (Pythia8::LHAupMadgraph *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAupMadgraph_setEvents",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupMadgraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupMadgraph_setEvents" "', argument " "1"" of type '" "Pythia8::LHAupMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupMadgraph * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAupMadgraph_setEvents" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setEvents(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupMadgraph_setSeed__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupMadgraph *arg1 = (Pythia8::LHAupMadgraph *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:LHAupMadgraph_setSeed",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupMadgraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupMadgraph_setSeed" "', argument " "1"" of type '" "Pythia8::LHAupMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupMadgraph * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAupMadgraph_setSeed" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LHAupMadgraph_setSeed" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (bool)(arg1)->setSeed(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupMadgraph_setSeed__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupMadgraph *arg1 = (Pythia8::LHAupMadgraph *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAupMadgraph_setSeed",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupMadgraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupMadgraph_setSeed" "', argument " "1"" of type '" "Pythia8::LHAupMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupMadgraph * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAupMadgraph_setSeed" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->setSeed(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupMadgraph_setSeed(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAupMadgraph, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LHAupMadgraph_setSeed__SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAupMadgraph, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LHAupMadgraph_setSeed__SWIG_0(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LHAupMadgraph_setSeed'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAupMadgraph::setSeed(int,int)\n"
    "    Pythia8::LHAupMadgraph::setSeed(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_LHAupMadgraph_setJets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupMadgraph *arg1 = (Pythia8::LHAupMadgraph *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAupMadgraph_setJets",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupMadgraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupMadgraph_setJets" "', argument " "1"" of type '" "Pythia8::LHAupMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupMadgraph * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAupMadgraph_setJets" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setJets(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupMadgraph_setInit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupMadgraph *arg1 = (Pythia8::LHAupMadgraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAupMadgraph_setInit",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupMadgraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupMadgraph_setInit" "', argument " "1"" of type '" "Pythia8::LHAupMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupMadgraph * >(argp1);
  result = (bool)(arg1)->setInit();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupMadgraph_setEvent__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupMadgraph *arg1 = (Pythia8::LHAupMadgraph *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:LHAupMadgraph_setEvent",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupMadgraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupMadgraph_setEvent" "', argument " "1"" of type '" "Pythia8::LHAupMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupMadgraph * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LHAupMadgraph_setEvent" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->setEvent(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupMadgraph_setEvent__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::LHAupMadgraph *arg1 = (Pythia8::LHAupMadgraph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:LHAupMadgraph_setEvent",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__LHAupMadgraph, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LHAupMadgraph_setEvent" "', argument " "1"" of type '" "Pythia8::LHAupMadgraph *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::LHAupMadgraph * >(argp1);
  result = (bool)(arg1)->setEvent();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_LHAupMadgraph_setEvent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAupMadgraph, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LHAupMadgraph_setEvent__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__LHAupMadgraph, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LHAupMadgraph_setEvent__SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LHAupMadgraph_setEvent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::LHAupMadgraph::setEvent(int)\n"
    "    Pythia8::LHAupMadgraph::setEvent()\n");
  return 0;
}


SWIGINTERN PyObject *LHAupMadgraph_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__LHAupMadgraph, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PowhegHooks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PowhegHooks *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_PowhegHooks")) SWIG_fail;
  result = (Pythia8::PowhegHooks *)new Pythia8::PowhegHooks();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PowhegHooks, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PowhegHooks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PowhegHooks *arg1 = (Pythia8::PowhegHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PowhegHooks",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PowhegHooks, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PowhegHooks" "', argument " "1"" of type '" "Pythia8::PowhegHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PowhegHooks * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PowhegHooks_initAfterBeams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PowhegHooks *arg1 = (Pythia8::PowhegHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PowhegHooks_initAfterBeams",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PowhegHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowhegHooks_initAfterBeams" "', argument " "1"" of type '" "Pythia8::PowhegHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PowhegHooks * >(argp1);
  result = (bool)(arg1)->initAfterBeams();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PowhegHooks_pTpythia(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PowhegHooks *arg1 = (Pythia8::PowhegHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:PowhegHooks_pTpythia",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PowhegHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowhegHooks_pTpythia" "', argument " "1"" of type '" "Pythia8::PowhegHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PowhegHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PowhegHooks_pTpythia" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PowhegHooks_pTpythia" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PowhegHooks_pTpythia" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PowhegHooks_pTpythia" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PowhegHooks_pTpythia" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PowhegHooks_pTpythia" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  result = (double)(arg1)->pTpythia((Pythia8::Event const &)*arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PowhegHooks_pTpowheg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PowhegHooks *arg1 = (Pythia8::PowhegHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:PowhegHooks_pTpowheg",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PowhegHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowhegHooks_pTpowheg" "', argument " "1"" of type '" "Pythia8::PowhegHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PowhegHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PowhegHooks_pTpowheg" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PowhegHooks_pTpowheg" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PowhegHooks_pTpowheg" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PowhegHooks_pTpowheg" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PowhegHooks_pTpowheg" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (double)(arg1)->pTpowheg((Pythia8::Event const &)*arg2,arg3,arg4,arg5);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PowhegHooks_pTcalc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PowhegHooks *arg1 = (Pythia8::PowhegHooks *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:PowhegHooks_pTcalc",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PowhegHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowhegHooks_pTcalc" "', argument " "1"" of type '" "Pythia8::PowhegHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PowhegHooks * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PowhegHooks_pTcalc" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PowhegHooks_pTcalc" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PowhegHooks_pTcalc" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PowhegHooks_pTcalc" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PowhegHooks_pTcalc" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PowhegHooks_pTcalc" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "PowhegHooks_pTcalc" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  result = (double)(arg1)->pTcalc((Pythia8::Event const &)*arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PowhegHooks_canVetoMPIStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PowhegHooks *arg1 = (Pythia8::PowhegHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PowhegHooks_canVetoMPIStep",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PowhegHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowhegHooks_canVetoMPIStep" "', argument " "1"" of type '" "Pythia8::PowhegHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PowhegHooks * >(argp1);
  result = (bool)(arg1)->canVetoMPIStep();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PowhegHooks_numberVetoMPIStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PowhegHooks *arg1 = (Pythia8::PowhegHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PowhegHooks_numberVetoMPIStep",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PowhegHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowhegHooks_numberVetoMPIStep" "', argument " "1"" of type '" "Pythia8::PowhegHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PowhegHooks * >(argp1);
  result = (int)(arg1)->numberVetoMPIStep();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PowhegHooks_doVetoMPIStep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PowhegHooks *arg1 = (Pythia8::PowhegHooks *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PowhegHooks_doVetoMPIStep",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PowhegHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowhegHooks_doVetoMPIStep" "', argument " "1"" of type '" "Pythia8::PowhegHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PowhegHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PowhegHooks_doVetoMPIStep" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PowhegHooks_doVetoMPIStep" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PowhegHooks_doVetoMPIStep" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  result = (bool)(arg1)->doVetoMPIStep(arg2,(Pythia8::Event const &)*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PowhegHooks_canVetoISREmission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PowhegHooks *arg1 = (Pythia8::PowhegHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PowhegHooks_canVetoISREmission",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PowhegHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowhegHooks_canVetoISREmission" "', argument " "1"" of type '" "Pythia8::PowhegHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PowhegHooks * >(argp1);
  result = (bool)(arg1)->canVetoISREmission();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PowhegHooks_doVetoISREmission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PowhegHooks *arg1 = (Pythia8::PowhegHooks *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:PowhegHooks_doVetoISREmission",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PowhegHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowhegHooks_doVetoISREmission" "', argument " "1"" of type '" "Pythia8::PowhegHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PowhegHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PowhegHooks_doVetoISREmission" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PowhegHooks_doVetoISREmission" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PowhegHooks_doVetoISREmission" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PowhegHooks_doVetoISREmission" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (bool)(arg1)->doVetoISREmission(arg2,(Pythia8::Event const &)*arg3,arg4);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PowhegHooks_canVetoFSREmission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PowhegHooks *arg1 = (Pythia8::PowhegHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PowhegHooks_canVetoFSREmission",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PowhegHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowhegHooks_canVetoFSREmission" "', argument " "1"" of type '" "Pythia8::PowhegHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PowhegHooks * >(argp1);
  result = (bool)(arg1)->canVetoFSREmission();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PowhegHooks_doVetoFSREmission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PowhegHooks *arg1 = (Pythia8::PowhegHooks *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  int arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:PowhegHooks_doVetoFSREmission",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PowhegHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowhegHooks_doVetoFSREmission" "', argument " "1"" of type '" "Pythia8::PowhegHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PowhegHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PowhegHooks_doVetoFSREmission" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PowhegHooks_doVetoFSREmission" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PowhegHooks_doVetoFSREmission" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PowhegHooks_doVetoFSREmission" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PowhegHooks_doVetoFSREmission" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (bool)(arg1)->doVetoFSREmission(arg2,(Pythia8::Event const &)*arg3,arg4,arg5);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PowhegHooks_canVetoMPIEmission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PowhegHooks *arg1 = (Pythia8::PowhegHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PowhegHooks_canVetoMPIEmission",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PowhegHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowhegHooks_canVetoMPIEmission" "', argument " "1"" of type '" "Pythia8::PowhegHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PowhegHooks * >(argp1);
  result = (bool)(arg1)->canVetoMPIEmission();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PowhegHooks_doVetoMPIEmission(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PowhegHooks *arg1 = (Pythia8::PowhegHooks *) 0 ;
  int arg2 ;
  Pythia8::Event *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:PowhegHooks_doVetoMPIEmission",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PowhegHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowhegHooks_doVetoMPIEmission" "', argument " "1"" of type '" "Pythia8::PowhegHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PowhegHooks * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PowhegHooks_doVetoMPIEmission" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PowhegHooks_doVetoMPIEmission" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PowhegHooks_doVetoMPIEmission" "', argument " "3"" of type '" "Pythia8::Event const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Event * >(argp3);
  result = (bool)(arg1)->doVetoMPIEmission(arg2,(Pythia8::Event const &)*arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PowhegHooks_getNISRveto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PowhegHooks *arg1 = (Pythia8::PowhegHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PowhegHooks_getNISRveto",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PowhegHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowhegHooks_getNISRveto" "', argument " "1"" of type '" "Pythia8::PowhegHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PowhegHooks * >(argp1);
  result = (int)(arg1)->getNISRveto();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PowhegHooks_getNFSRveto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PowhegHooks *arg1 = (Pythia8::PowhegHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  int result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PowhegHooks_getNFSRveto",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PowhegHooks, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowhegHooks_getNFSRveto" "', argument " "1"" of type '" "Pythia8::PowhegHooks *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PowhegHooks * >(argp1);
  result = (int)(arg1)->getNFSRveto();
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PowhegHooks_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__PowhegHooks, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_PowhegProcs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  Pythia8::PowhegProcs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_PowhegProcs",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PowhegProcs" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PowhegProcs" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PowhegProcs" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PowhegProcs" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode5 = SWIG_AsVal_bool(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_PowhegProcs" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  result = (Pythia8::PowhegProcs *)new Pythia8::PowhegProcs(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PowhegProcs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PowhegProcs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  Pythia8::PowhegProcs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_PowhegProcs",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PowhegProcs" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PowhegProcs" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PowhegProcs" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PowhegProcs" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::PowhegProcs *)new Pythia8::PowhegProcs(arg1,arg2,arg3,arg4);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PowhegProcs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PowhegProcs__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  Pythia8::PowhegProcs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:new_PowhegProcs",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PowhegProcs" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PowhegProcs" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PowhegProcs" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::PowhegProcs *)new Pythia8::PowhegProcs(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PowhegProcs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PowhegProcs__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = (Pythia8::Pythia *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Pythia8::PowhegProcs *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_PowhegProcs",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Pythia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PowhegProcs" "', argument " "1"" of type '" "Pythia8::Pythia *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_PowhegProcs" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (Pythia8::PowhegProcs *)new Pythia8::PowhegProcs(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PowhegProcs, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PowhegProcs(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_PowhegProcs__SWIG_3(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_PowhegProcs__SWIG_2(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PowhegProcs__SWIG_1(self, args);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pythia8__Pythia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_PowhegProcs__SWIG_0(self, args);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PowhegProcs'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    Pythia8::PowhegProcs::PowhegProcs(Pythia8::Pythia *,std::string,std::string,std::string,bool)\n"
    "    Pythia8::PowhegProcs::PowhegProcs(Pythia8::Pythia *,std::string,std::string,std::string)\n"
    "    Pythia8::PowhegProcs::PowhegProcs(Pythia8::Pythia *,std::string,std::string)\n"
    "    Pythia8::PowhegProcs::PowhegProcs(Pythia8::Pythia *,std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_PowhegProcs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PowhegProcs *arg1 = (Pythia8::PowhegProcs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_PowhegProcs",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PowhegProcs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PowhegProcs" "', argument " "1"" of type '" "Pythia8::PowhegProcs *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PowhegProcs * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PowhegProcs_readString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PowhegProcs *arg1 = (Pythia8::PowhegProcs *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PowhegProcs_readString",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PowhegProcs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowhegProcs_readString" "', argument " "1"" of type '" "Pythia8::PowhegProcs *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PowhegProcs * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PowhegProcs_readString" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->readString(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PowhegProcs_readFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PowhegProcs *arg1 = (Pythia8::PowhegProcs *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PowhegProcs_readFile",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PowhegProcs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowhegProcs_readFile" "', argument " "1"" of type '" "Pythia8::PowhegProcs *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PowhegProcs * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "PowhegProcs_readFile" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->readFile(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PowhegProcs_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PowhegProcs *arg1 = (Pythia8::PowhegProcs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PowhegProcs_init",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PowhegProcs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowhegProcs_init" "', argument " "1"" of type '" "Pythia8::PowhegProcs *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PowhegProcs * >(argp1);
  result = (bool)(arg1)->init();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PowhegProcs_lhaup_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PowhegProcs *arg1 = (Pythia8::PowhegProcs *) 0 ;
  Pythia8::LHAup *arg2 = (Pythia8::LHAup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:PowhegProcs_lhaup_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PowhegProcs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowhegProcs_lhaup_set" "', argument " "1"" of type '" "Pythia8::PowhegProcs *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PowhegProcs * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__LHAup, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PowhegProcs_lhaup_set" "', argument " "2"" of type '" "Pythia8::LHAup *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::LHAup * >(argp2);
  if (arg1) (arg1)->lhaup = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PowhegProcs_lhaup_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::PowhegProcs *arg1 = (Pythia8::PowhegProcs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::LHAup *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:PowhegProcs_lhaup_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__PowhegProcs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowhegProcs_lhaup_get" "', argument " "1"" of type '" "Pythia8::PowhegProcs *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::PowhegProcs * >(argp1);
  result = (Pythia8::LHAup *) ((arg1)->lhaup);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__LHAup, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PowhegProcs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__PowhegProcs, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_HeavyIons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HeavyIons *arg1 = (Pythia8::HeavyIons *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_HeavyIons",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HeavyIons, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HeavyIons" "', argument " "1"" of type '" "Pythia8::HeavyIons *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HeavyIons * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeavyIons_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HeavyIons *arg1 = (Pythia8::HeavyIons *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HeavyIons_init",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HeavyIons, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeavyIons_init" "', argument " "1"" of type '" "Pythia8::HeavyIons *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HeavyIons * >(argp1);
  result = (bool)(arg1)->init();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeavyIons_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HeavyIons *arg1 = (Pythia8::HeavyIons *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HeavyIons_next",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HeavyIons, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeavyIons_next" "', argument " "1"" of type '" "Pythia8::HeavyIons *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HeavyIons * >(argp1);
  result = (bool)(arg1)->next();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeavyIons_addSpecialSettings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HeavyIons_addSpecialSettings",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeavyIons_addSpecialSettings" "', argument " "1"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HeavyIons_addSpecialSettings" "', argument " "1"" of type '" "Pythia8::Settings &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  Pythia8::HeavyIons::addSpecialSettings(*arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeavyIons_isHeavyIon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Settings *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HeavyIons_isHeavyIon",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Settings,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeavyIons_isHeavyIon" "', argument " "1"" of type '" "Pythia8::Settings &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HeavyIons_isHeavyIon" "', argument " "1"" of type '" "Pythia8::Settings &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Settings * >(argp1);
  result = (bool)Pythia8::HeavyIons::isHeavyIon(*arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeavyIons_setHIUserHooksPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HeavyIons *arg1 = (Pythia8::HeavyIons *) 0 ;
  Pythia8::HIUserHooks *arg2 = (Pythia8::HIUserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HeavyIons_setHIUserHooksPtr",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HeavyIons, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeavyIons_setHIUserHooksPtr" "', argument " "1"" of type '" "Pythia8::HeavyIons *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HeavyIons * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__HIUserHooks, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeavyIons_setHIUserHooksPtr" "', argument " "2"" of type '" "Pythia8::HIUserHooks *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::HIUserHooks * >(argp2);
  result = (bool)(arg1)->setHIUserHooksPtr(arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeavyIons_hiinfo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HeavyIons *arg1 = (Pythia8::HeavyIons *) 0 ;
  Pythia8::HIInfo *arg2 = (Pythia8::HIInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:HeavyIons_hiinfo_set",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HeavyIons, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeavyIons_hiinfo_set" "', argument " "1"" of type '" "Pythia8::HeavyIons *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HeavyIons * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeavyIons_hiinfo_set" "', argument " "2"" of type '" "Pythia8::HIInfo *""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::HIInfo * >(argp2);
  if (arg1) (arg1)->hiinfo = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeavyIons_hiinfo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HeavyIons *arg1 = (Pythia8::HeavyIons *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::HIInfo *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HeavyIons_hiinfo_get",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HeavyIons, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeavyIons_hiinfo_get" "', argument " "1"" of type '" "Pythia8::HeavyIons *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HeavyIons * >(argp1);
  result = (Pythia8::HIInfo *)& ((arg1)->hiinfo);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HIInfo, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeavyIons_stat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::HeavyIons *arg1 = (Pythia8::HeavyIons *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:HeavyIons_stat",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__HeavyIons, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeavyIons_stat" "', argument " "1"" of type '" "Pythia8::HeavyIons *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::HeavyIons * >(argp1);
  (arg1)->stat();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HeavyIons_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__HeavyIons, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_Angantyr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::Angantyr *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_Angantyr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Pythia,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Angantyr" "', argument " "1"" of type '" "Pythia8::Pythia &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Angantyr" "', argument " "1"" of type '" "Pythia8::Pythia &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (Pythia8::Angantyr *)new Pythia8::Angantyr(*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Angantyr, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_Angantyr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Angantyr *arg1 = (Pythia8::Angantyr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_Angantyr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Angantyr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Angantyr" "', argument " "1"" of type '" "Pythia8::Angantyr *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Angantyr * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Angantyr_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Angantyr *arg1 = (Pythia8::Angantyr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Angantyr_init",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Angantyr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Angantyr_init" "', argument " "1"" of type '" "Pythia8::Angantyr *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Angantyr * >(argp1);
  result = (bool)(arg1)->init();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Angantyr_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Angantyr *arg1 = (Pythia8::Angantyr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Angantyr_next",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Angantyr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Angantyr_next" "', argument " "1"" of type '" "Pythia8::Angantyr *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Angantyr * >(argp1);
  result = (bool)(arg1)->next();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Angantyr_setUserHooksPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Angantyr *arg1 = (Pythia8::Angantyr *) 0 ;
  Pythia8::Angantyr::PythiaObject arg2 ;
  Pythia8::UserHooks *arg3 = (Pythia8::UserHooks *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:Angantyr_setUserHooksPtr",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__Angantyr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Angantyr_setUserHooksPtr" "', argument " "1"" of type '" "Pythia8::Angantyr *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Angantyr * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Angantyr_setUserHooksPtr" "', argument " "2"" of type '" "Pythia8::Angantyr::PythiaObject""'");
  } 
  arg2 = static_cast< Pythia8::Angantyr::PythiaObject >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Angantyr_setUserHooksPtr" "', argument " "3"" of type '" "Pythia8::UserHooks *""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::UserHooks * >(argp3);
  result = (bool)(arg1)->setUserHooksPtr(arg2,arg3);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Angantyr_getTransforms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 arg1 ;
  Pythia8::Vec4 arg2 ;
  Pythia8::Vec4 *arg3 = 0 ;
  std::pair< Pythia8::RotBstMatrix,Pythia8::RotBstMatrix > *arg4 = 0 ;
  int arg5 ;
  int arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Angantyr_getTransforms",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Angantyr_getTransforms" "', argument " "1"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Angantyr_getTransforms" "', argument " "1"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Angantyr_getTransforms" "', argument " "2"" of type '" "Pythia8::Vec4""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Angantyr_getTransforms" "', argument " "2"" of type '" "Pythia8::Vec4""'");
    } else {
      Pythia8::Vec4 * temp = reinterpret_cast< Pythia8::Vec4 * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Angantyr_getTransforms" "', argument " "3"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Angantyr_getTransforms" "', argument " "3"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg3 = reinterpret_cast< Pythia8::Vec4 * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__pairT_Pythia8__RotBstMatrix_Pythia8__RotBstMatrix_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Angantyr_getTransforms" "', argument " "4"" of type '" "std::pair< Pythia8::RotBstMatrix,Pythia8::RotBstMatrix > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Angantyr_getTransforms" "', argument " "4"" of type '" "std::pair< Pythia8::RotBstMatrix,Pythia8::RotBstMatrix > &""'"); 
  }
  arg4 = reinterpret_cast< std::pair< Pythia8::RotBstMatrix,Pythia8::RotBstMatrix > * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Angantyr_getTransforms" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Angantyr_getTransforms" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  result = (bool)Pythia8::Angantyr::getTransforms(arg1,arg2,(Pythia8::Vec4 const &)*arg3,*arg4,arg5,arg6);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Angantyr_mT2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Angantyr_mT2",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Angantyr_mT2" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Angantyr_mT2" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  result = (double)Pythia8::Angantyr::mT2((Pythia8::Vec4 const &)*arg1);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Angantyr_mT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Vec4 *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  double result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:Angantyr_mT",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Angantyr_mT" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Angantyr_mT" "', argument " "1"" of type '" "Pythia8::Vec4 const &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Vec4 * >(argp1);
  result = (double)Pythia8::Angantyr::mT((Pythia8::Vec4 const &)*arg1);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *Angantyr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__Angantyr, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_JetMatchingAlpgenInputAlpgen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::JetMatchingAlpgenInputAlpgen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_JetMatchingAlpgenInputAlpgen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Pythia,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_JetMatchingAlpgenInputAlpgen" "', argument " "1"" of type '" "Pythia8::Pythia &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JetMatchingAlpgenInputAlpgen" "', argument " "1"" of type '" "Pythia8::Pythia &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (Pythia8::JetMatchingAlpgenInputAlpgen *)new Pythia8::JetMatchingAlpgenInputAlpgen(*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__JetMatchingAlpgenInputAlpgen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_JetMatchingAlpgenInputAlpgen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingAlpgenInputAlpgen *arg1 = (Pythia8::JetMatchingAlpgenInputAlpgen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_JetMatchingAlpgenInputAlpgen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingAlpgenInputAlpgen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_JetMatchingAlpgenInputAlpgen" "', argument " "1"" of type '" "Pythia8::JetMatchingAlpgenInputAlpgen *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingAlpgenInputAlpgen * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatchingAlpgenInputAlpgen_initAfterBeams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingAlpgenInputAlpgen *arg1 = (Pythia8::JetMatchingAlpgenInputAlpgen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:JetMatchingAlpgenInputAlpgen_initAfterBeams",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingAlpgenInputAlpgen, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatchingAlpgenInputAlpgen_initAfterBeams" "', argument " "1"" of type '" "Pythia8::JetMatchingAlpgenInputAlpgen *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingAlpgenInputAlpgen * >(argp1);
  result = (bool)(arg1)->initAfterBeams();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatchingAlpgenInputAlpgen_canVetoProcessLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingAlpgenInputAlpgen *arg1 = (Pythia8::JetMatchingAlpgenInputAlpgen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:JetMatchingAlpgenInputAlpgen_canVetoProcessLevel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingAlpgenInputAlpgen, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatchingAlpgenInputAlpgen_canVetoProcessLevel" "', argument " "1"" of type '" "Pythia8::JetMatchingAlpgenInputAlpgen *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingAlpgenInputAlpgen * >(argp1);
  result = (bool)(arg1)->canVetoProcessLevel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatchingAlpgenInputAlpgen_doVetoProcessLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingAlpgenInputAlpgen *arg1 = (Pythia8::JetMatchingAlpgenInputAlpgen *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:JetMatchingAlpgenInputAlpgen_doVetoProcessLevel",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingAlpgenInputAlpgen, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatchingAlpgenInputAlpgen_doVetoProcessLevel" "', argument " "1"" of type '" "Pythia8::JetMatchingAlpgenInputAlpgen *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingAlpgenInputAlpgen * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JetMatchingAlpgenInputAlpgen_doVetoProcessLevel" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JetMatchingAlpgenInputAlpgen_doVetoProcessLevel" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->doVetoProcessLevel(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatchingAlpgenInputAlpgen_canVetoPartonLevelEarly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingAlpgenInputAlpgen *arg1 = (Pythia8::JetMatchingAlpgenInputAlpgen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:JetMatchingAlpgenInputAlpgen_canVetoPartonLevelEarly",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingAlpgenInputAlpgen, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatchingAlpgenInputAlpgen_canVetoPartonLevelEarly" "', argument " "1"" of type '" "Pythia8::JetMatchingAlpgenInputAlpgen *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingAlpgenInputAlpgen * >(argp1);
  result = (bool)(arg1)->canVetoPartonLevelEarly();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatchingAlpgenInputAlpgen_doVetoPartonLevelEarly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingAlpgenInputAlpgen *arg1 = (Pythia8::JetMatchingAlpgenInputAlpgen *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:JetMatchingAlpgenInputAlpgen_doVetoPartonLevelEarly",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingAlpgenInputAlpgen, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatchingAlpgenInputAlpgen_doVetoPartonLevelEarly" "', argument " "1"" of type '" "Pythia8::JetMatchingAlpgenInputAlpgen *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingAlpgenInputAlpgen * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JetMatchingAlpgenInputAlpgen_doVetoPartonLevelEarly" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JetMatchingAlpgenInputAlpgen_doVetoPartonLevelEarly" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->doVetoPartonLevelEarly((Pythia8::Event const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *JetMatchingAlpgenInputAlpgen_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__JetMatchingAlpgenInputAlpgen, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_JetMatchingMadgraphInputAlpgen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::Pythia *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  Pythia8::JetMatchingMadgraphInputAlpgen *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_JetMatchingMadgraphInputAlpgen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_Pythia8__Pythia,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_JetMatchingMadgraphInputAlpgen" "', argument " "1"" of type '" "Pythia8::Pythia &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JetMatchingMadgraphInputAlpgen" "', argument " "1"" of type '" "Pythia8::Pythia &""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::Pythia * >(argp1);
  result = (Pythia8::JetMatchingMadgraphInputAlpgen *)new Pythia8::JetMatchingMadgraphInputAlpgen(*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__JetMatchingMadgraphInputAlpgen, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_JetMatchingMadgraphInputAlpgen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingMadgraphInputAlpgen *arg1 = (Pythia8::JetMatchingMadgraphInputAlpgen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_JetMatchingMadgraphInputAlpgen",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingMadgraphInputAlpgen, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_JetMatchingMadgraphInputAlpgen" "', argument " "1"" of type '" "Pythia8::JetMatchingMadgraphInputAlpgen *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingMadgraphInputAlpgen * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatchingMadgraphInputAlpgen_initAfterBeams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingMadgraphInputAlpgen *arg1 = (Pythia8::JetMatchingMadgraphInputAlpgen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:JetMatchingMadgraphInputAlpgen_initAfterBeams",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingMadgraphInputAlpgen, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatchingMadgraphInputAlpgen_initAfterBeams" "', argument " "1"" of type '" "Pythia8::JetMatchingMadgraphInputAlpgen *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingMadgraphInputAlpgen * >(argp1);
  result = (bool)(arg1)->initAfterBeams();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatchingMadgraphInputAlpgen_canVetoProcessLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingMadgraphInputAlpgen *arg1 = (Pythia8::JetMatchingMadgraphInputAlpgen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:JetMatchingMadgraphInputAlpgen_canVetoProcessLevel",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingMadgraphInputAlpgen, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatchingMadgraphInputAlpgen_canVetoProcessLevel" "', argument " "1"" of type '" "Pythia8::JetMatchingMadgraphInputAlpgen *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingMadgraphInputAlpgen * >(argp1);
  result = (bool)(arg1)->canVetoProcessLevel();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatchingMadgraphInputAlpgen_doVetoProcessLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingMadgraphInputAlpgen *arg1 = (Pythia8::JetMatchingMadgraphInputAlpgen *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:JetMatchingMadgraphInputAlpgen_doVetoProcessLevel",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingMadgraphInputAlpgen, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatchingMadgraphInputAlpgen_doVetoProcessLevel" "', argument " "1"" of type '" "Pythia8::JetMatchingMadgraphInputAlpgen *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingMadgraphInputAlpgen * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JetMatchingMadgraphInputAlpgen_doVetoProcessLevel" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JetMatchingMadgraphInputAlpgen_doVetoProcessLevel" "', argument " "2"" of type '" "Pythia8::Event &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->doVetoProcessLevel(*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatchingMadgraphInputAlpgen_canVetoPartonLevelEarly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingMadgraphInputAlpgen *arg1 = (Pythia8::JetMatchingMadgraphInputAlpgen *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:JetMatchingMadgraphInputAlpgen_canVetoPartonLevelEarly",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingMadgraphInputAlpgen, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatchingMadgraphInputAlpgen_canVetoPartonLevelEarly" "', argument " "1"" of type '" "Pythia8::JetMatchingMadgraphInputAlpgen *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingMadgraphInputAlpgen * >(argp1);
  result = (bool)(arg1)->canVetoPartonLevelEarly();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_JetMatchingMadgraphInputAlpgen_doVetoPartonLevelEarly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::JetMatchingMadgraphInputAlpgen *arg1 = (Pythia8::JetMatchingMadgraphInputAlpgen *) 0 ;
  Pythia8::Event *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:JetMatchingMadgraphInputAlpgen_doVetoPartonLevelEarly",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__JetMatchingMadgraphInputAlpgen, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JetMatchingMadgraphInputAlpgen_doVetoPartonLevelEarly" "', argument " "1"" of type '" "Pythia8::JetMatchingMadgraphInputAlpgen *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::JetMatchingMadgraphInputAlpgen * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Event,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JetMatchingMadgraphInputAlpgen_doVetoPartonLevelEarly" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JetMatchingMadgraphInputAlpgen_doVetoPartonLevelEarly" "', argument " "2"" of type '" "Pythia8::Event const &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Event * >(argp2);
  result = (bool)(arg1)->doVetoPartonLevelEarly((Pythia8::Event const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *JetMatchingMadgraphInputAlpgen_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__JetMatchingMadgraphInputAlpgen, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_CombineMatchingInput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CombineMatchingInput *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_CombineMatchingInput")) SWIG_fail;
  result = (Pythia8::CombineMatchingInput *)new Pythia8::CombineMatchingInput();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__CombineMatchingInput, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CombineMatchingInput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CombineMatchingInput *arg1 = (Pythia8::CombineMatchingInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_CombineMatchingInput",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CombineMatchingInput, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CombineMatchingInput" "', argument " "1"" of type '" "Pythia8::CombineMatchingInput *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CombineMatchingInput * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CombineMatchingInput_getHook(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  Pythia8::CombineMatchingInput *arg1 = (Pythia8::CombineMatchingInput *) 0 ;
  Pythia8::Pythia *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  Swig::Director *director = 0;
  Pythia8::UserHooks *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:CombineMatchingInput_getHook",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pythia8__CombineMatchingInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CombineMatchingInput_getHook" "', argument " "1"" of type '" "Pythia8::CombineMatchingInput *""'"); 
  }
  arg1 = reinterpret_cast< Pythia8::CombineMatchingInput * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Pythia,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CombineMatchingInput_getHook" "', argument " "2"" of type '" "Pythia8::Pythia &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CombineMatchingInput_getHook" "', argument " "2"" of type '" "Pythia8::Pythia &""'"); 
  }
  arg2 = reinterpret_cast< Pythia8::Pythia * >(argp2);
  result = (Pythia8::UserHooks *)(arg1)->getHook(*arg2);
  director = SWIG_DIRECTOR_CAST(result);
  if (director) {
    resultobj = director->swig_get_self();
    Py_INCREF(resultobj);
  } else {
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__UserHooks, 0 |  0 );
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CombineMatchingInput_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_Pythia8__CombineMatchingInput, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MapStringFlag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::less< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Flag > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MapStringFlag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__lessT_std__string_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MapStringFlag" "', argument " "1"" of type '" "std::less< std::string > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MapStringFlag" "', argument " "1"" of type '" "std::less< std::string > const &""'"); 
  }
  arg1 = reinterpret_cast< std::less< std::string > * >(argp1);
  result = (std::map< std::string,Pythia8::Flag > *)new std::map< std::string,Pythia8::Flag >((std::less< std::string > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFlag_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag_iterator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFlag___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag___nonzero__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_Flag_Sg____nonzero__((std::map< std::string,Pythia8::Flag > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFlag___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag___bool__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_Flag_Sg____bool__((std::map< std::string,Pythia8::Flag > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Flag >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFlag___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag___len__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  result = std_map_Sl_std_string_Sc_Pythia8_Flag_Sg____len__((std::map< std::string,Pythia8::Flag > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  std::map< std::string,Pythia8::Flag >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Flag >::mapped_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringFlag___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag___getitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringFlag___getitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFlag___getitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  try {
    result = (std::map< std::string,Pythia8::Flag >::mapped_type *) &std_map_Sl_std_string_Sc_Pythia8_Flag_Sg____getitem__(arg1,(std::string const &)*arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Flag, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  std::map< std::string,Pythia8::Flag >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringFlag___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag___delitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringFlag___delitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFlag___delitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  try {
    std_map_Sl_std_string_Sc_Pythia8_Flag_Sg____delitem__(arg1,(std::string const &)*arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag_has_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  std::map< std::string,Pythia8::Flag >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringFlag_has_key",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag_has_key" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringFlag_has_key" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFlag_has_key" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__has_key((std::map< std::string,Pythia8::Flag > const *)arg1,(std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFlag_keys",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag_keys" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__keys(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag_values(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFlag_values",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag_values" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__values(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag_items(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFlag_items",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag_items" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__items(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  std::map< std::string,Pythia8::Flag >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringFlag___contains__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag___contains__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringFlag___contains__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFlag___contains__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_Flag_Sg____contains__(arg1,(std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag_key_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFlag_key_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag_key_iterator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__key_iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag_value_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFlag_value_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag_value_iterator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__value_iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  std::map< std::string,Pythia8::Flag >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringFlag___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag___setitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringFlag___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFlag___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  std_map_Sl_std_string_Sc_Pythia8_Flag_Sg____setitem____SWIG_0(arg1,(std::string const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  std::map< std::string,Pythia8::Flag >::key_type *arg2 = 0 ;
  std::map< std::string,Pythia8::Flag >::mapped_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MapStringFlag___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag___setitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringFlag___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFlag___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Flag,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MapStringFlag___setitem__" "', argument " "3"" of type '" "std::map< std::string,Pythia8::Flag >::mapped_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFlag___setitem__" "', argument " "3"" of type '" "std::map< std::string,Pythia8::Flag >::mapped_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::map< std::string,Pythia8::Flag >::mapped_type * >(argp3);
  try {
    std_map_Sl_std_string_Sc_Pythia8_Flag_Sg____setitem____SWIG_1(arg1,(std::string const &)*arg2,(Pythia8::Flag const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MapStringFlag___setitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Flag, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MapStringFlag___setitem____SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MapStringFlag___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< std::string,Pythia8::Flag >::__setitem__(std::map< std::string,Pythia8::Flag >::key_type const &)\n"
    "    std::map< std::string,Pythia8::Flag >::__setitem__(std::map< std::string,Pythia8::Flag >::key_type const &,std::map< std::string,Pythia8::Flag >::mapped_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapStringFlag_asdict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFlag_asdict",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag_asdict" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__asdict(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapStringFlag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MapStringFlag")) SWIG_fail;
  result = (std::map< std::string,Pythia8::Flag > *)new std::map< std::string,Pythia8::Flag >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapStringFlag__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Flag > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MapStringFlag",&obj0)) SWIG_fail;
  {
    std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > > *ptr = (std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MapStringFlag" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MapStringFlag" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::map< std::string,Pythia8::Flag > *)new std::map< std::string,Pythia8::Flag >((std::map< std::string,Pythia8::Flag > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapStringFlag(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_MapStringFlag__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__lessT_std__string_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MapStringFlag__SWIG_0(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MapStringFlag__SWIG_2(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MapStringFlag'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< std::string,Pythia8::Flag >::map(std::less< std::string > const &)\n"
    "    std::map< std::string,Pythia8::Flag >::map()\n"
    "    std::map< std::string,Pythia8::Flag >::map(std::map< std::string,Pythia8::Flag > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapStringFlag_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFlag_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag_empty" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  result = (bool)((std::map< std::string,Pythia8::Flag > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Flag >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFlag_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag_size" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  result = ((std::map< std::string,Pythia8::Flag > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  std::map< std::string,Pythia8::Flag > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringFlag_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag_swap" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringFlag_swap" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFlag_swap" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag > &""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Flag >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFlag_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag_begin" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Flag >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Flag >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFlag_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag_end" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Flag >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Flag >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFlag_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag_rbegin" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Flag >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Flag >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFlag_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag_rend" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Flag >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFlag_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag_clear" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< std::pair< std::string const,Pythia8::Flag > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFlag_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag_get_allocator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  result = ((std::map< std::string,Pythia8::Flag > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new std::map< std::string,Pythia8::Flag >::allocator_type(static_cast< const std::map< std::string,Pythia8::Flag >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  std::map< std::string,Pythia8::Flag >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Flag >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringFlag_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag_erase" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringFlag_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFlag_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->erase((std::map< std::string,Pythia8::Flag >::key_type const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  std::map< std::string,Pythia8::Flag >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Flag >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringFlag_count",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag_count" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringFlag_count" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFlag_count" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = ((std::map< std::string,Pythia8::Flag > const *)arg1)->count((std::map< std::string,Pythia8::Flag >::key_type const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  std::map< std::string,Pythia8::Flag >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringFlag_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag_erase" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringFlag_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< std::string,Pythia8::Flag >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::Flag >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringFlag_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::iterator""'");
    }
  }
  std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__erase__SWIG_1(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag_erase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  std::map< std::string,Pythia8::Flag >::iterator arg2 ;
  std::map< std::string,Pythia8::Flag >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MapStringFlag_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag_erase" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringFlag_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< std::string,Pythia8::Flag >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::Flag >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringFlag_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringFlag_erase" "', argument " "3"" of type '" "std::map< std::string,Pythia8::Flag >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< std::string,Pythia8::Flag >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::Flag >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringFlag_erase" "', argument " "3"" of type '" "std::map< std::string,Pythia8::Flag >::iterator""'");
    }
  }
  std_map_Sl_std_string_Sc_Pythia8_Flag_Sg__erase__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::Flag >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_MapStringFlag_erase__SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MapStringFlag_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::Flag >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::Flag >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_MapStringFlag_erase__SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MapStringFlag_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< std::string,Pythia8::Flag >::erase(std::map< std::string,Pythia8::Flag >::key_type const &)\n"
    "    std::map< std::string,Pythia8::Flag >::erase(std::map< std::string,Pythia8::Flag >::iterator)\n"
    "    std::map< std::string,Pythia8::Flag >::erase(std::map< std::string,Pythia8::Flag >::iterator,std::map< std::string,Pythia8::Flag >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapStringFlag_find(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  std::map< std::string,Pythia8::Flag >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Flag >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringFlag_find",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag_find" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringFlag_find" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFlag_find" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->find((std::map< std::string,Pythia8::Flag >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Flag >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag_lower_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  std::map< std::string,Pythia8::Flag >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Flag >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringFlag_lower_bound",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag_lower_bound" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringFlag_lower_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFlag_lower_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->lower_bound((std::map< std::string,Pythia8::Flag >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Flag >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFlag_upper_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  std::map< std::string,Pythia8::Flag >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Flag >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringFlag_upper_bound",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFlag_upper_bound" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringFlag_upper_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFlag_upper_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Flag >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->upper_bound((std::map< std::string,Pythia8::Flag >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Flag >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MapStringFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Flag > *arg1 = (std::map< std::string,Pythia8::Flag > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MapStringFlag",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MapStringFlag" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Flag > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Flag > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MapStringFlag_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MapStringMode__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::less< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Mode > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MapStringMode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__lessT_std__string_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MapStringMode" "', argument " "1"" of type '" "std::less< std::string > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MapStringMode" "', argument " "1"" of type '" "std::less< std::string > const &""'"); 
  }
  arg1 = reinterpret_cast< std::less< std::string > * >(argp1);
  result = (std::map< std::string,Pythia8::Mode > *)new std::map< std::string,Pythia8::Mode >((std::less< std::string > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMode_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode_iterator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMode___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode___nonzero__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_Mode_Sg____nonzero__((std::map< std::string,Pythia8::Mode > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMode___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode___bool__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_Mode_Sg____bool__((std::map< std::string,Pythia8::Mode > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Mode >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMode___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode___len__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  result = std_map_Sl_std_string_Sc_Pythia8_Mode_Sg____len__((std::map< std::string,Pythia8::Mode > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  std::map< std::string,Pythia8::Mode >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Mode >::mapped_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringMode___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode___getitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringMode___getitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMode___getitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  try {
    result = (std::map< std::string,Pythia8::Mode >::mapped_type *) &std_map_Sl_std_string_Sc_Pythia8_Mode_Sg____getitem__(arg1,(std::string const &)*arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Mode, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  std::map< std::string,Pythia8::Mode >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringMode___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode___delitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringMode___delitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMode___delitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  try {
    std_map_Sl_std_string_Sc_Pythia8_Mode_Sg____delitem__(arg1,(std::string const &)*arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode_has_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  std::map< std::string,Pythia8::Mode >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringMode_has_key",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode_has_key" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringMode_has_key" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMode_has_key" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__has_key((std::map< std::string,Pythia8::Mode > const *)arg1,(std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMode_keys",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode_keys" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__keys(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode_values(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMode_values",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode_values" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__values(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode_items(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMode_items",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode_items" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__items(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  std::map< std::string,Pythia8::Mode >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringMode___contains__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode___contains__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringMode___contains__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMode___contains__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_Mode_Sg____contains__(arg1,(std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode_key_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMode_key_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode_key_iterator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__key_iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode_value_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMode_value_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode_value_iterator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__value_iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  std::map< std::string,Pythia8::Mode >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringMode___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode___setitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringMode___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMode___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  std_map_Sl_std_string_Sc_Pythia8_Mode_Sg____setitem____SWIG_0(arg1,(std::string const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  std::map< std::string,Pythia8::Mode >::key_type *arg2 = 0 ;
  std::map< std::string,Pythia8::Mode >::mapped_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MapStringMode___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode___setitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringMode___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMode___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Mode,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MapStringMode___setitem__" "', argument " "3"" of type '" "std::map< std::string,Pythia8::Mode >::mapped_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMode___setitem__" "', argument " "3"" of type '" "std::map< std::string,Pythia8::Mode >::mapped_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::map< std::string,Pythia8::Mode >::mapped_type * >(argp3);
  try {
    std_map_Sl_std_string_Sc_Pythia8_Mode_Sg____setitem____SWIG_1(arg1,(std::string const &)*arg2,(Pythia8::Mode const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MapStringMode___setitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Mode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MapStringMode___setitem____SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MapStringMode___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< std::string,Pythia8::Mode >::__setitem__(std::map< std::string,Pythia8::Mode >::key_type const &)\n"
    "    std::map< std::string,Pythia8::Mode >::__setitem__(std::map< std::string,Pythia8::Mode >::key_type const &,std::map< std::string,Pythia8::Mode >::mapped_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapStringMode_asdict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMode_asdict",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode_asdict" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__asdict(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapStringMode__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MapStringMode")) SWIG_fail;
  result = (std::map< std::string,Pythia8::Mode > *)new std::map< std::string,Pythia8::Mode >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapStringMode__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Mode > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MapStringMode",&obj0)) SWIG_fail;
  {
    std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > > *ptr = (std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MapStringMode" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MapStringMode" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::map< std::string,Pythia8::Mode > *)new std::map< std::string,Pythia8::Mode >((std::map< std::string,Pythia8::Mode > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapStringMode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_MapStringMode__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__lessT_std__string_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MapStringMode__SWIG_0(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MapStringMode__SWIG_2(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MapStringMode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< std::string,Pythia8::Mode >::map(std::less< std::string > const &)\n"
    "    std::map< std::string,Pythia8::Mode >::map()\n"
    "    std::map< std::string,Pythia8::Mode >::map(std::map< std::string,Pythia8::Mode > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapStringMode_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMode_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode_empty" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  result = (bool)((std::map< std::string,Pythia8::Mode > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Mode >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMode_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode_size" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  result = ((std::map< std::string,Pythia8::Mode > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  std::map< std::string,Pythia8::Mode > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringMode_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode_swap" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringMode_swap" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMode_swap" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode > &""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Mode >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMode_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode_begin" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Mode >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Mode >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMode_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode_end" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Mode >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Mode >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMode_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode_rbegin" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Mode >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Mode >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMode_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode_rend" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Mode >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMode_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode_clear" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< std::pair< std::string const,Pythia8::Mode > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMode_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode_get_allocator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  result = ((std::map< std::string,Pythia8::Mode > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new std::map< std::string,Pythia8::Mode >::allocator_type(static_cast< const std::map< std::string,Pythia8::Mode >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  std::map< std::string,Pythia8::Mode >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Mode >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringMode_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode_erase" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringMode_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMode_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->erase((std::map< std::string,Pythia8::Mode >::key_type const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  std::map< std::string,Pythia8::Mode >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Mode >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringMode_count",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode_count" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringMode_count" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMode_count" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = ((std::map< std::string,Pythia8::Mode > const *)arg1)->count((std::map< std::string,Pythia8::Mode >::key_type const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  std::map< std::string,Pythia8::Mode >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringMode_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode_erase" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringMode_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< std::string,Pythia8::Mode >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::Mode >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringMode_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::iterator""'");
    }
  }
  std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__erase__SWIG_1(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode_erase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  std::map< std::string,Pythia8::Mode >::iterator arg2 ;
  std::map< std::string,Pythia8::Mode >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MapStringMode_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode_erase" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringMode_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< std::string,Pythia8::Mode >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::Mode >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringMode_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringMode_erase" "', argument " "3"" of type '" "std::map< std::string,Pythia8::Mode >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< std::string,Pythia8::Mode >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::Mode >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringMode_erase" "', argument " "3"" of type '" "std::map< std::string,Pythia8::Mode >::iterator""'");
    }
  }
  std_map_Sl_std_string_Sc_Pythia8_Mode_Sg__erase__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::Mode >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_MapStringMode_erase__SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MapStringMode_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::Mode >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::Mode >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_MapStringMode_erase__SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MapStringMode_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< std::string,Pythia8::Mode >::erase(std::map< std::string,Pythia8::Mode >::key_type const &)\n"
    "    std::map< std::string,Pythia8::Mode >::erase(std::map< std::string,Pythia8::Mode >::iterator)\n"
    "    std::map< std::string,Pythia8::Mode >::erase(std::map< std::string,Pythia8::Mode >::iterator,std::map< std::string,Pythia8::Mode >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapStringMode_find(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  std::map< std::string,Pythia8::Mode >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Mode >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringMode_find",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode_find" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringMode_find" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMode_find" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->find((std::map< std::string,Pythia8::Mode >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Mode >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode_lower_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  std::map< std::string,Pythia8::Mode >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Mode >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringMode_lower_bound",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode_lower_bound" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringMode_lower_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMode_lower_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->lower_bound((std::map< std::string,Pythia8::Mode >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Mode >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMode_upper_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  std::map< std::string,Pythia8::Mode >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Mode >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringMode_upper_bound",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMode_upper_bound" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringMode_upper_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMode_upper_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Mode >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->upper_bound((std::map< std::string,Pythia8::Mode >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Mode >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MapStringMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Mode > *arg1 = (std::map< std::string,Pythia8::Mode > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MapStringMode",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MapStringMode" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Mode > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Mode > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MapStringMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MapStringParm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::less< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Parm > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MapStringParm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__lessT_std__string_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MapStringParm" "', argument " "1"" of type '" "std::less< std::string > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MapStringParm" "', argument " "1"" of type '" "std::less< std::string > const &""'"); 
  }
  arg1 = reinterpret_cast< std::less< std::string > * >(argp1);
  result = (std::map< std::string,Pythia8::Parm > *)new std::map< std::string,Pythia8::Parm >((std::less< std::string > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringParm_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm_iterator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringParm___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm___nonzero__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_Parm_Sg____nonzero__((std::map< std::string,Pythia8::Parm > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringParm___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm___bool__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_Parm_Sg____bool__((std::map< std::string,Pythia8::Parm > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Parm >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringParm___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm___len__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  result = std_map_Sl_std_string_Sc_Pythia8_Parm_Sg____len__((std::map< std::string,Pythia8::Parm > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  std::map< std::string,Pythia8::Parm >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Parm >::mapped_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringParm___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm___getitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringParm___getitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringParm___getitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  try {
    result = (std::map< std::string,Pythia8::Parm >::mapped_type *) &std_map_Sl_std_string_Sc_Pythia8_Parm_Sg____getitem__(arg1,(std::string const &)*arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Parm, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  std::map< std::string,Pythia8::Parm >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringParm___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm___delitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringParm___delitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringParm___delitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  try {
    std_map_Sl_std_string_Sc_Pythia8_Parm_Sg____delitem__(arg1,(std::string const &)*arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm_has_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  std::map< std::string,Pythia8::Parm >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringParm_has_key",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm_has_key" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringParm_has_key" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringParm_has_key" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__has_key((std::map< std::string,Pythia8::Parm > const *)arg1,(std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringParm_keys",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm_keys" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__keys(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm_values(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringParm_values",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm_values" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__values(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm_items(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringParm_items",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm_items" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__items(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  std::map< std::string,Pythia8::Parm >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringParm___contains__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm___contains__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringParm___contains__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringParm___contains__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_Parm_Sg____contains__(arg1,(std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm_key_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringParm_key_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm_key_iterator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__key_iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm_value_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringParm_value_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm_value_iterator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__value_iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  std::map< std::string,Pythia8::Parm >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringParm___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm___setitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringParm___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringParm___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  std_map_Sl_std_string_Sc_Pythia8_Parm_Sg____setitem____SWIG_0(arg1,(std::string const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  std::map< std::string,Pythia8::Parm >::key_type *arg2 = 0 ;
  std::map< std::string,Pythia8::Parm >::mapped_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MapStringParm___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm___setitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringParm___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringParm___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Parm,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MapStringParm___setitem__" "', argument " "3"" of type '" "std::map< std::string,Pythia8::Parm >::mapped_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringParm___setitem__" "', argument " "3"" of type '" "std::map< std::string,Pythia8::Parm >::mapped_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::map< std::string,Pythia8::Parm >::mapped_type * >(argp3);
  try {
    std_map_Sl_std_string_Sc_Pythia8_Parm_Sg____setitem____SWIG_1(arg1,(std::string const &)*arg2,(Pythia8::Parm const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MapStringParm___setitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Parm, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MapStringParm___setitem____SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MapStringParm___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< std::string,Pythia8::Parm >::__setitem__(std::map< std::string,Pythia8::Parm >::key_type const &)\n"
    "    std::map< std::string,Pythia8::Parm >::__setitem__(std::map< std::string,Pythia8::Parm >::key_type const &,std::map< std::string,Pythia8::Parm >::mapped_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapStringParm_asdict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringParm_asdict",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm_asdict" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__asdict(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapStringParm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MapStringParm")) SWIG_fail;
  result = (std::map< std::string,Pythia8::Parm > *)new std::map< std::string,Pythia8::Parm >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapStringParm__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Parm > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MapStringParm",&obj0)) SWIG_fail;
  {
    std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > > *ptr = (std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MapStringParm" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MapStringParm" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::map< std::string,Pythia8::Parm > *)new std::map< std::string,Pythia8::Parm >((std::map< std::string,Pythia8::Parm > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapStringParm(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_MapStringParm__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__lessT_std__string_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MapStringParm__SWIG_0(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MapStringParm__SWIG_2(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MapStringParm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< std::string,Pythia8::Parm >::map(std::less< std::string > const &)\n"
    "    std::map< std::string,Pythia8::Parm >::map()\n"
    "    std::map< std::string,Pythia8::Parm >::map(std::map< std::string,Pythia8::Parm > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapStringParm_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringParm_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm_empty" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  result = (bool)((std::map< std::string,Pythia8::Parm > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Parm >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringParm_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm_size" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  result = ((std::map< std::string,Pythia8::Parm > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  std::map< std::string,Pythia8::Parm > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringParm_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm_swap" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringParm_swap" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringParm_swap" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm > &""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Parm >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringParm_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm_begin" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Parm >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Parm >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringParm_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm_end" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Parm >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Parm >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringParm_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm_rbegin" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Parm >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Parm >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringParm_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm_rend" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Parm >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringParm_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm_clear" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< std::pair< std::string const,Pythia8::Parm > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringParm_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm_get_allocator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  result = ((std::map< std::string,Pythia8::Parm > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new std::map< std::string,Pythia8::Parm >::allocator_type(static_cast< const std::map< std::string,Pythia8::Parm >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  std::map< std::string,Pythia8::Parm >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Parm >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringParm_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm_erase" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringParm_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringParm_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->erase((std::map< std::string,Pythia8::Parm >::key_type const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  std::map< std::string,Pythia8::Parm >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Parm >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringParm_count",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm_count" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringParm_count" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringParm_count" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = ((std::map< std::string,Pythia8::Parm > const *)arg1)->count((std::map< std::string,Pythia8::Parm >::key_type const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  std::map< std::string,Pythia8::Parm >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringParm_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm_erase" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringParm_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< std::string,Pythia8::Parm >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::Parm >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringParm_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::iterator""'");
    }
  }
  std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__erase__SWIG_1(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm_erase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  std::map< std::string,Pythia8::Parm >::iterator arg2 ;
  std::map< std::string,Pythia8::Parm >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MapStringParm_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm_erase" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringParm_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< std::string,Pythia8::Parm >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::Parm >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringParm_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringParm_erase" "', argument " "3"" of type '" "std::map< std::string,Pythia8::Parm >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< std::string,Pythia8::Parm >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::Parm >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringParm_erase" "', argument " "3"" of type '" "std::map< std::string,Pythia8::Parm >::iterator""'");
    }
  }
  std_map_Sl_std_string_Sc_Pythia8_Parm_Sg__erase__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::Parm >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_MapStringParm_erase__SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MapStringParm_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::Parm >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::Parm >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_MapStringParm_erase__SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MapStringParm_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< std::string,Pythia8::Parm >::erase(std::map< std::string,Pythia8::Parm >::key_type const &)\n"
    "    std::map< std::string,Pythia8::Parm >::erase(std::map< std::string,Pythia8::Parm >::iterator)\n"
    "    std::map< std::string,Pythia8::Parm >::erase(std::map< std::string,Pythia8::Parm >::iterator,std::map< std::string,Pythia8::Parm >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapStringParm_find(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  std::map< std::string,Pythia8::Parm >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Parm >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringParm_find",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm_find" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringParm_find" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringParm_find" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->find((std::map< std::string,Pythia8::Parm >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Parm >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm_lower_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  std::map< std::string,Pythia8::Parm >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Parm >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringParm_lower_bound",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm_lower_bound" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringParm_lower_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringParm_lower_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->lower_bound((std::map< std::string,Pythia8::Parm >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Parm >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringParm_upper_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  std::map< std::string,Pythia8::Parm >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Parm >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringParm_upper_bound",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringParm_upper_bound" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringParm_upper_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringParm_upper_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Parm >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->upper_bound((std::map< std::string,Pythia8::Parm >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Parm >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MapStringParm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Parm > *arg1 = (std::map< std::string,Pythia8::Parm > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MapStringParm",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MapStringParm" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Parm > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Parm > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MapStringParm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MapStringWord__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::less< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Word > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MapStringWord",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__lessT_std__string_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MapStringWord" "', argument " "1"" of type '" "std::less< std::string > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MapStringWord" "', argument " "1"" of type '" "std::less< std::string > const &""'"); 
  }
  arg1 = reinterpret_cast< std::less< std::string > * >(argp1);
  result = (std::map< std::string,Pythia8::Word > *)new std::map< std::string,Pythia8::Word >((std::less< std::string > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringWord_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord_iterator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_Pythia8_Word_Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringWord___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord___nonzero__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_Word_Sg____nonzero__((std::map< std::string,Pythia8::Word > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringWord___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord___bool__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_Word_Sg____bool__((std::map< std::string,Pythia8::Word > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Word >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringWord___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord___len__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  result = std_map_Sl_std_string_Sc_Pythia8_Word_Sg____len__((std::map< std::string,Pythia8::Word > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  std::map< std::string,Pythia8::Word >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Word >::mapped_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringWord___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord___getitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringWord___getitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringWord___getitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  try {
    result = (std::map< std::string,Pythia8::Word >::mapped_type *) &std_map_Sl_std_string_Sc_Pythia8_Word_Sg____getitem__(arg1,(std::string const &)*arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Word, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  std::map< std::string,Pythia8::Word >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringWord___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord___delitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringWord___delitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringWord___delitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  try {
    std_map_Sl_std_string_Sc_Pythia8_Word_Sg____delitem__(arg1,(std::string const &)*arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord_has_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  std::map< std::string,Pythia8::Word >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringWord_has_key",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord_has_key" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringWord_has_key" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringWord_has_key" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_Word_Sg__has_key((std::map< std::string,Pythia8::Word > const *)arg1,(std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringWord_keys",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord_keys" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_Word_Sg__keys(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord_values(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringWord_values",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord_values" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_Word_Sg__values(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord_items(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringWord_items",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord_items" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_Word_Sg__items(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  std::map< std::string,Pythia8::Word >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringWord___contains__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord___contains__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringWord___contains__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringWord___contains__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_Word_Sg____contains__(arg1,(std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord_key_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringWord_key_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord_key_iterator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_Pythia8_Word_Sg__key_iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord_value_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringWord_value_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord_value_iterator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_Pythia8_Word_Sg__value_iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  std::map< std::string,Pythia8::Word >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringWord___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord___setitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringWord___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringWord___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  std_map_Sl_std_string_Sc_Pythia8_Word_Sg____setitem____SWIG_0(arg1,(std::string const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  std::map< std::string,Pythia8::Word >::key_type *arg2 = 0 ;
  std::map< std::string,Pythia8::Word >::mapped_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MapStringWord___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord___setitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringWord___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringWord___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Word,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MapStringWord___setitem__" "', argument " "3"" of type '" "std::map< std::string,Pythia8::Word >::mapped_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringWord___setitem__" "', argument " "3"" of type '" "std::map< std::string,Pythia8::Word >::mapped_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::map< std::string,Pythia8::Word >::mapped_type * >(argp3);
  try {
    std_map_Sl_std_string_Sc_Pythia8_Word_Sg____setitem____SWIG_1(arg1,(std::string const &)*arg2,(Pythia8::Word const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MapStringWord___setitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Word, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MapStringWord___setitem____SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MapStringWord___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< std::string,Pythia8::Word >::__setitem__(std::map< std::string,Pythia8::Word >::key_type const &)\n"
    "    std::map< std::string,Pythia8::Word >::__setitem__(std::map< std::string,Pythia8::Word >::key_type const &,std::map< std::string,Pythia8::Word >::mapped_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapStringWord_asdict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringWord_asdict",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord_asdict" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_Word_Sg__asdict(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapStringWord__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MapStringWord")) SWIG_fail;
  result = (std::map< std::string,Pythia8::Word > *)new std::map< std::string,Pythia8::Word >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapStringWord__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Word > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MapStringWord",&obj0)) SWIG_fail;
  {
    std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > > *ptr = (std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MapStringWord" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MapStringWord" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::map< std::string,Pythia8::Word > *)new std::map< std::string,Pythia8::Word >((std::map< std::string,Pythia8::Word > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapStringWord(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_MapStringWord__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__lessT_std__string_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MapStringWord__SWIG_0(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MapStringWord__SWIG_2(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MapStringWord'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< std::string,Pythia8::Word >::map(std::less< std::string > const &)\n"
    "    std::map< std::string,Pythia8::Word >::map()\n"
    "    std::map< std::string,Pythia8::Word >::map(std::map< std::string,Pythia8::Word > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapStringWord_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringWord_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord_empty" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  result = (bool)((std::map< std::string,Pythia8::Word > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Word >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringWord_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord_size" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  result = ((std::map< std::string,Pythia8::Word > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  std::map< std::string,Pythia8::Word > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringWord_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord_swap" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringWord_swap" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringWord_swap" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word > &""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Word >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringWord_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord_begin" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Word >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Word >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringWord_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord_end" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Word >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Word >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringWord_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord_rbegin" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Word >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::Word >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringWord_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord_rend" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Word >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringWord_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord_clear" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< std::pair< std::string const,Pythia8::Word > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringWord_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord_get_allocator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  result = ((std::map< std::string,Pythia8::Word > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new std::map< std::string,Pythia8::Word >::allocator_type(static_cast< const std::map< std::string,Pythia8::Word >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  std::map< std::string,Pythia8::Word >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Word >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringWord_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord_erase" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringWord_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringWord_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->erase((std::map< std::string,Pythia8::Word >::key_type const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  std::map< std::string,Pythia8::Word >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Word >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringWord_count",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord_count" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringWord_count" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringWord_count" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = ((std::map< std::string,Pythia8::Word > const *)arg1)->count((std::map< std::string,Pythia8::Word >::key_type const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  std::map< std::string,Pythia8::Word >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringWord_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord_erase" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringWord_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< std::string,Pythia8::Word >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::Word >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringWord_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::iterator""'");
    }
  }
  std_map_Sl_std_string_Sc_Pythia8_Word_Sg__erase__SWIG_1(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord_erase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  std::map< std::string,Pythia8::Word >::iterator arg2 ;
  std::map< std::string,Pythia8::Word >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MapStringWord_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord_erase" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringWord_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< std::string,Pythia8::Word >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::Word >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringWord_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringWord_erase" "', argument " "3"" of type '" "std::map< std::string,Pythia8::Word >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< std::string,Pythia8::Word >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::Word >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringWord_erase" "', argument " "3"" of type '" "std::map< std::string,Pythia8::Word >::iterator""'");
    }
  }
  std_map_Sl_std_string_Sc_Pythia8_Word_Sg__erase__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::Word >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_MapStringWord_erase__SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MapStringWord_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::Word >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::Word >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_MapStringWord_erase__SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MapStringWord_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< std::string,Pythia8::Word >::erase(std::map< std::string,Pythia8::Word >::key_type const &)\n"
    "    std::map< std::string,Pythia8::Word >::erase(std::map< std::string,Pythia8::Word >::iterator)\n"
    "    std::map< std::string,Pythia8::Word >::erase(std::map< std::string,Pythia8::Word >::iterator,std::map< std::string,Pythia8::Word >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapStringWord_find(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  std::map< std::string,Pythia8::Word >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Word >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringWord_find",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord_find" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringWord_find" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringWord_find" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->find((std::map< std::string,Pythia8::Word >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Word >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord_lower_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  std::map< std::string,Pythia8::Word >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Word >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringWord_lower_bound",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord_lower_bound" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringWord_lower_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringWord_lower_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->lower_bound((std::map< std::string,Pythia8::Word >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Word >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringWord_upper_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  std::map< std::string,Pythia8::Word >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::Word >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringWord_upper_bound",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringWord_upper_bound" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringWord_upper_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringWord_upper_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::Word >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->upper_bound((std::map< std::string,Pythia8::Word >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::Word >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MapStringWord(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::Word > *arg1 = (std::map< std::string,Pythia8::Word > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MapStringWord",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MapStringWord" "', argument " "1"" of type '" "std::map< std::string,Pythia8::Word > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::Word > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MapStringWord_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MapStringFVec__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::less< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::FVec > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MapStringFVec",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__lessT_std__string_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MapStringFVec" "', argument " "1"" of type '" "std::less< std::string > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MapStringFVec" "', argument " "1"" of type '" "std::less< std::string > const &""'"); 
  }
  arg1 = reinterpret_cast< std::less< std::string > * >(argp1);
  result = (std::map< std::string,Pythia8::FVec > *)new std::map< std::string,Pythia8::FVec >((std::less< std::string > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFVec_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec_iterator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFVec___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec___nonzero__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_FVec_Sg____nonzero__((std::map< std::string,Pythia8::FVec > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFVec___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec___bool__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_FVec_Sg____bool__((std::map< std::string,Pythia8::FVec > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::FVec >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFVec___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec___len__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  result = std_map_Sl_std_string_Sc_Pythia8_FVec_Sg____len__((std::map< std::string,Pythia8::FVec > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  std::map< std::string,Pythia8::FVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::FVec >::mapped_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringFVec___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec___getitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringFVec___getitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFVec___getitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  try {
    result = (std::map< std::string,Pythia8::FVec >::mapped_type *) &std_map_Sl_std_string_Sc_Pythia8_FVec_Sg____getitem__(arg1,(std::string const &)*arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__FVec, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  std::map< std::string,Pythia8::FVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringFVec___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec___delitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringFVec___delitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFVec___delitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  try {
    std_map_Sl_std_string_Sc_Pythia8_FVec_Sg____delitem__(arg1,(std::string const &)*arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec_has_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  std::map< std::string,Pythia8::FVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringFVec_has_key",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec_has_key" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringFVec_has_key" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFVec_has_key" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__has_key((std::map< std::string,Pythia8::FVec > const *)arg1,(std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFVec_keys",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec_keys" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__keys(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec_values(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFVec_values",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec_values" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__values(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec_items(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFVec_items",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec_items" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__items(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  std::map< std::string,Pythia8::FVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringFVec___contains__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec___contains__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringFVec___contains__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFVec___contains__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_FVec_Sg____contains__(arg1,(std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec_key_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFVec_key_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec_key_iterator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__key_iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec_value_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFVec_value_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec_value_iterator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__value_iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  std::map< std::string,Pythia8::FVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringFVec___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec___setitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringFVec___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFVec___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  std_map_Sl_std_string_Sc_Pythia8_FVec_Sg____setitem____SWIG_0(arg1,(std::string const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  std::map< std::string,Pythia8::FVec >::key_type *arg2 = 0 ;
  std::map< std::string,Pythia8::FVec >::mapped_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MapStringFVec___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec___setitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringFVec___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFVec___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__FVec,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MapStringFVec___setitem__" "', argument " "3"" of type '" "std::map< std::string,Pythia8::FVec >::mapped_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFVec___setitem__" "', argument " "3"" of type '" "std::map< std::string,Pythia8::FVec >::mapped_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::map< std::string,Pythia8::FVec >::mapped_type * >(argp3);
  try {
    std_map_Sl_std_string_Sc_Pythia8_FVec_Sg____setitem____SWIG_1(arg1,(std::string const &)*arg2,(Pythia8::FVec const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MapStringFVec___setitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__FVec, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MapStringFVec___setitem____SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MapStringFVec___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< std::string,Pythia8::FVec >::__setitem__(std::map< std::string,Pythia8::FVec >::key_type const &)\n"
    "    std::map< std::string,Pythia8::FVec >::__setitem__(std::map< std::string,Pythia8::FVec >::key_type const &,std::map< std::string,Pythia8::FVec >::mapped_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapStringFVec_asdict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFVec_asdict",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec_asdict" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__asdict(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapStringFVec__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MapStringFVec")) SWIG_fail;
  result = (std::map< std::string,Pythia8::FVec > *)new std::map< std::string,Pythia8::FVec >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapStringFVec__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::FVec > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MapStringFVec",&obj0)) SWIG_fail;
  {
    std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > > *ptr = (std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MapStringFVec" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MapStringFVec" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::map< std::string,Pythia8::FVec > *)new std::map< std::string,Pythia8::FVec >((std::map< std::string,Pythia8::FVec > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapStringFVec(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_MapStringFVec__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__lessT_std__string_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MapStringFVec__SWIG_0(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MapStringFVec__SWIG_2(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MapStringFVec'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< std::string,Pythia8::FVec >::map(std::less< std::string > const &)\n"
    "    std::map< std::string,Pythia8::FVec >::map()\n"
    "    std::map< std::string,Pythia8::FVec >::map(std::map< std::string,Pythia8::FVec > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapStringFVec_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFVec_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec_empty" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  result = (bool)((std::map< std::string,Pythia8::FVec > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::FVec >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFVec_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec_size" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  result = ((std::map< std::string,Pythia8::FVec > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  std::map< std::string,Pythia8::FVec > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringFVec_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec_swap" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringFVec_swap" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFVec_swap" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec > &""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::FVec >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFVec_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec_begin" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::FVec >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::FVec >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFVec_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec_end" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::FVec >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::FVec >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFVec_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec_rbegin" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::FVec >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::FVec >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFVec_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec_rend" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::FVec >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFVec_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec_clear" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< std::pair< std::string const,Pythia8::FVec > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringFVec_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec_get_allocator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  result = ((std::map< std::string,Pythia8::FVec > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new std::map< std::string,Pythia8::FVec >::allocator_type(static_cast< const std::map< std::string,Pythia8::FVec >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  std::map< std::string,Pythia8::FVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::FVec >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringFVec_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec_erase" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringFVec_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFVec_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->erase((std::map< std::string,Pythia8::FVec >::key_type const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  std::map< std::string,Pythia8::FVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::FVec >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringFVec_count",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec_count" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringFVec_count" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFVec_count" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = ((std::map< std::string,Pythia8::FVec > const *)arg1)->count((std::map< std::string,Pythia8::FVec >::key_type const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  std::map< std::string,Pythia8::FVec >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringFVec_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec_erase" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringFVec_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< std::string,Pythia8::FVec >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::FVec >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringFVec_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::iterator""'");
    }
  }
  std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__erase__SWIG_1(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec_erase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  std::map< std::string,Pythia8::FVec >::iterator arg2 ;
  std::map< std::string,Pythia8::FVec >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MapStringFVec_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec_erase" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringFVec_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< std::string,Pythia8::FVec >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::FVec >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringFVec_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringFVec_erase" "', argument " "3"" of type '" "std::map< std::string,Pythia8::FVec >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< std::string,Pythia8::FVec >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::FVec >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringFVec_erase" "', argument " "3"" of type '" "std::map< std::string,Pythia8::FVec >::iterator""'");
    }
  }
  std_map_Sl_std_string_Sc_Pythia8_FVec_Sg__erase__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::FVec >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_MapStringFVec_erase__SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MapStringFVec_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::FVec >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::FVec >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_MapStringFVec_erase__SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MapStringFVec_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< std::string,Pythia8::FVec >::erase(std::map< std::string,Pythia8::FVec >::key_type const &)\n"
    "    std::map< std::string,Pythia8::FVec >::erase(std::map< std::string,Pythia8::FVec >::iterator)\n"
    "    std::map< std::string,Pythia8::FVec >::erase(std::map< std::string,Pythia8::FVec >::iterator,std::map< std::string,Pythia8::FVec >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapStringFVec_find(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  std::map< std::string,Pythia8::FVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::FVec >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringFVec_find",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec_find" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringFVec_find" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFVec_find" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->find((std::map< std::string,Pythia8::FVec >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::FVec >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec_lower_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  std::map< std::string,Pythia8::FVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::FVec >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringFVec_lower_bound",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec_lower_bound" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringFVec_lower_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFVec_lower_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->lower_bound((std::map< std::string,Pythia8::FVec >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::FVec >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringFVec_upper_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  std::map< std::string,Pythia8::FVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::FVec >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringFVec_upper_bound",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringFVec_upper_bound" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringFVec_upper_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringFVec_upper_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::FVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->upper_bound((std::map< std::string,Pythia8::FVec >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::FVec >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MapStringFVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::FVec > *arg1 = (std::map< std::string,Pythia8::FVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MapStringFVec",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MapStringFVec" "', argument " "1"" of type '" "std::map< std::string,Pythia8::FVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::FVec > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MapStringFVec_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MapStringMVec__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::less< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::MVec > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MapStringMVec",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__lessT_std__string_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MapStringMVec" "', argument " "1"" of type '" "std::less< std::string > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MapStringMVec" "', argument " "1"" of type '" "std::less< std::string > const &""'"); 
  }
  arg1 = reinterpret_cast< std::less< std::string > * >(argp1);
  result = (std::map< std::string,Pythia8::MVec > *)new std::map< std::string,Pythia8::MVec >((std::less< std::string > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMVec_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec_iterator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMVec___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec___nonzero__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_MVec_Sg____nonzero__((std::map< std::string,Pythia8::MVec > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMVec___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec___bool__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_MVec_Sg____bool__((std::map< std::string,Pythia8::MVec > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::MVec >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMVec___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec___len__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  result = std_map_Sl_std_string_Sc_Pythia8_MVec_Sg____len__((std::map< std::string,Pythia8::MVec > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  std::map< std::string,Pythia8::MVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::MVec >::mapped_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringMVec___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec___getitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringMVec___getitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMVec___getitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  try {
    result = (std::map< std::string,Pythia8::MVec >::mapped_type *) &std_map_Sl_std_string_Sc_Pythia8_MVec_Sg____getitem__(arg1,(std::string const &)*arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__MVec, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  std::map< std::string,Pythia8::MVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringMVec___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec___delitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringMVec___delitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMVec___delitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  try {
    std_map_Sl_std_string_Sc_Pythia8_MVec_Sg____delitem__(arg1,(std::string const &)*arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec_has_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  std::map< std::string,Pythia8::MVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringMVec_has_key",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec_has_key" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringMVec_has_key" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMVec_has_key" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__has_key((std::map< std::string,Pythia8::MVec > const *)arg1,(std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMVec_keys",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec_keys" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__keys(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec_values(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMVec_values",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec_values" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__values(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec_items(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMVec_items",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec_items" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__items(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  std::map< std::string,Pythia8::MVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringMVec___contains__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec___contains__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringMVec___contains__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMVec___contains__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_MVec_Sg____contains__(arg1,(std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec_key_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMVec_key_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec_key_iterator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__key_iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec_value_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMVec_value_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec_value_iterator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__value_iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  std::map< std::string,Pythia8::MVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringMVec___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec___setitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringMVec___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMVec___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  std_map_Sl_std_string_Sc_Pythia8_MVec_Sg____setitem____SWIG_0(arg1,(std::string const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  std::map< std::string,Pythia8::MVec >::key_type *arg2 = 0 ;
  std::map< std::string,Pythia8::MVec >::mapped_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MapStringMVec___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec___setitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringMVec___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMVec___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__MVec,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MapStringMVec___setitem__" "', argument " "3"" of type '" "std::map< std::string,Pythia8::MVec >::mapped_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMVec___setitem__" "', argument " "3"" of type '" "std::map< std::string,Pythia8::MVec >::mapped_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::map< std::string,Pythia8::MVec >::mapped_type * >(argp3);
  try {
    std_map_Sl_std_string_Sc_Pythia8_MVec_Sg____setitem____SWIG_1(arg1,(std::string const &)*arg2,(Pythia8::MVec const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MapStringMVec___setitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__MVec, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MapStringMVec___setitem____SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MapStringMVec___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< std::string,Pythia8::MVec >::__setitem__(std::map< std::string,Pythia8::MVec >::key_type const &)\n"
    "    std::map< std::string,Pythia8::MVec >::__setitem__(std::map< std::string,Pythia8::MVec >::key_type const &,std::map< std::string,Pythia8::MVec >::mapped_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapStringMVec_asdict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMVec_asdict",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec_asdict" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__asdict(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapStringMVec__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MapStringMVec")) SWIG_fail;
  result = (std::map< std::string,Pythia8::MVec > *)new std::map< std::string,Pythia8::MVec >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapStringMVec__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::MVec > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MapStringMVec",&obj0)) SWIG_fail;
  {
    std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > > *ptr = (std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MapStringMVec" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MapStringMVec" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::map< std::string,Pythia8::MVec > *)new std::map< std::string,Pythia8::MVec >((std::map< std::string,Pythia8::MVec > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapStringMVec(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_MapStringMVec__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__lessT_std__string_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MapStringMVec__SWIG_0(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MapStringMVec__SWIG_2(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MapStringMVec'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< std::string,Pythia8::MVec >::map(std::less< std::string > const &)\n"
    "    std::map< std::string,Pythia8::MVec >::map()\n"
    "    std::map< std::string,Pythia8::MVec >::map(std::map< std::string,Pythia8::MVec > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapStringMVec_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMVec_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec_empty" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  result = (bool)((std::map< std::string,Pythia8::MVec > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::MVec >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMVec_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec_size" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  result = ((std::map< std::string,Pythia8::MVec > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  std::map< std::string,Pythia8::MVec > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringMVec_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec_swap" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringMVec_swap" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMVec_swap" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec > &""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::MVec >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMVec_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec_begin" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::MVec >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::MVec >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMVec_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec_end" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::MVec >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::MVec >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMVec_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec_rbegin" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::MVec >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::MVec >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMVec_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec_rend" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::MVec >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMVec_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec_clear" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< std::pair< std::string const,Pythia8::MVec > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringMVec_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec_get_allocator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  result = ((std::map< std::string,Pythia8::MVec > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new std::map< std::string,Pythia8::MVec >::allocator_type(static_cast< const std::map< std::string,Pythia8::MVec >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  std::map< std::string,Pythia8::MVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::MVec >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringMVec_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec_erase" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringMVec_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMVec_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->erase((std::map< std::string,Pythia8::MVec >::key_type const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  std::map< std::string,Pythia8::MVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::MVec >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringMVec_count",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec_count" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringMVec_count" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMVec_count" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = ((std::map< std::string,Pythia8::MVec > const *)arg1)->count((std::map< std::string,Pythia8::MVec >::key_type const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  std::map< std::string,Pythia8::MVec >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringMVec_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec_erase" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringMVec_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< std::string,Pythia8::MVec >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::MVec >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringMVec_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::iterator""'");
    }
  }
  std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__erase__SWIG_1(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec_erase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  std::map< std::string,Pythia8::MVec >::iterator arg2 ;
  std::map< std::string,Pythia8::MVec >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MapStringMVec_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec_erase" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringMVec_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< std::string,Pythia8::MVec >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::MVec >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringMVec_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringMVec_erase" "', argument " "3"" of type '" "std::map< std::string,Pythia8::MVec >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< std::string,Pythia8::MVec >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::MVec >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringMVec_erase" "', argument " "3"" of type '" "std::map< std::string,Pythia8::MVec >::iterator""'");
    }
  }
  std_map_Sl_std_string_Sc_Pythia8_MVec_Sg__erase__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::MVec >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_MapStringMVec_erase__SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MapStringMVec_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::MVec >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::MVec >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_MapStringMVec_erase__SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MapStringMVec_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< std::string,Pythia8::MVec >::erase(std::map< std::string,Pythia8::MVec >::key_type const &)\n"
    "    std::map< std::string,Pythia8::MVec >::erase(std::map< std::string,Pythia8::MVec >::iterator)\n"
    "    std::map< std::string,Pythia8::MVec >::erase(std::map< std::string,Pythia8::MVec >::iterator,std::map< std::string,Pythia8::MVec >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapStringMVec_find(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  std::map< std::string,Pythia8::MVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::MVec >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringMVec_find",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec_find" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringMVec_find" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMVec_find" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->find((std::map< std::string,Pythia8::MVec >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::MVec >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec_lower_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  std::map< std::string,Pythia8::MVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::MVec >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringMVec_lower_bound",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec_lower_bound" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringMVec_lower_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMVec_lower_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->lower_bound((std::map< std::string,Pythia8::MVec >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::MVec >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringMVec_upper_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  std::map< std::string,Pythia8::MVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::MVec >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringMVec_upper_bound",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringMVec_upper_bound" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringMVec_upper_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringMVec_upper_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::MVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->upper_bound((std::map< std::string,Pythia8::MVec >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::MVec >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MapStringMVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::MVec > *arg1 = (std::map< std::string,Pythia8::MVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MapStringMVec",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MapStringMVec" "', argument " "1"" of type '" "std::map< std::string,Pythia8::MVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::MVec > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MapStringMVec_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_MapStringPVec__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::less< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::PVec > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MapStringPVec",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__lessT_std__string_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MapStringPVec" "', argument " "1"" of type '" "std::less< std::string > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MapStringPVec" "', argument " "1"" of type '" "std::less< std::string > const &""'"); 
  }
  arg1 = reinterpret_cast< std::less< std::string > * >(argp1);
  result = (std::map< std::string,Pythia8::PVec > *)new std::map< std::string,Pythia8::PVec >((std::less< std::string > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringPVec_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec_iterator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringPVec___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec___nonzero__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_PVec_Sg____nonzero__((std::map< std::string,Pythia8::PVec > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringPVec___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec___bool__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_PVec_Sg____bool__((std::map< std::string,Pythia8::PVec > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::PVec >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringPVec___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec___len__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  result = std_map_Sl_std_string_Sc_Pythia8_PVec_Sg____len__((std::map< std::string,Pythia8::PVec > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  std::map< std::string,Pythia8::PVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::PVec >::mapped_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringPVec___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec___getitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringPVec___getitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringPVec___getitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  try {
    result = (std::map< std::string,Pythia8::PVec >::mapped_type *) &std_map_Sl_std_string_Sc_Pythia8_PVec_Sg____getitem__(arg1,(std::string const &)*arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__PVec, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  std::map< std::string,Pythia8::PVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringPVec___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec___delitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringPVec___delitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringPVec___delitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  try {
    std_map_Sl_std_string_Sc_Pythia8_PVec_Sg____delitem__(arg1,(std::string const &)*arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec_has_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  std::map< std::string,Pythia8::PVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringPVec_has_key",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec_has_key" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringPVec_has_key" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringPVec_has_key" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__has_key((std::map< std::string,Pythia8::PVec > const *)arg1,(std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringPVec_keys",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec_keys" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__keys(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec_values(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringPVec_values",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec_values" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__values(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec_items(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringPVec_items",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec_items" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__items(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  std::map< std::string,Pythia8::PVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringPVec___contains__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec___contains__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringPVec___contains__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringPVec___contains__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)std_map_Sl_std_string_Sc_Pythia8_PVec_Sg____contains__(arg1,(std::string const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec_key_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringPVec_key_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec_key_iterator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__key_iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec_value_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringPVec_value_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec_value_iterator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  result = (swig::SwigPyIterator *)std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__value_iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  std::map< std::string,Pythia8::PVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringPVec___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec___setitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringPVec___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringPVec___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  std_map_Sl_std_string_Sc_Pythia8_PVec_Sg____setitem____SWIG_0(arg1,(std::string const &)*arg2);
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  std::map< std::string,Pythia8::PVec >::key_type *arg2 = 0 ;
  std::map< std::string,Pythia8::PVec >::mapped_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MapStringPVec___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec___setitem__" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringPVec___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringPVec___setitem__" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__PVec,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MapStringPVec___setitem__" "', argument " "3"" of type '" "std::map< std::string,Pythia8::PVec >::mapped_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringPVec___setitem__" "', argument " "3"" of type '" "std::map< std::string,Pythia8::PVec >::mapped_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::map< std::string,Pythia8::PVec >::mapped_type * >(argp3);
  try {
    std_map_Sl_std_string_Sc_Pythia8_PVec_Sg____setitem____SWIG_1(arg1,(std::string const &)*arg2,(Pythia8::PVec const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MapStringPVec___setitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__PVec, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MapStringPVec___setitem____SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MapStringPVec___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< std::string,Pythia8::PVec >::__setitem__(std::map< std::string,Pythia8::PVec >::key_type const &)\n"
    "    std::map< std::string,Pythia8::PVec >::__setitem__(std::map< std::string,Pythia8::PVec >::key_type const &,std::map< std::string,Pythia8::PVec >::mapped_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapStringPVec_asdict(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringPVec_asdict",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec_asdict" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  result = (PyObject *)std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__asdict(arg1);
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapStringPVec__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_MapStringPVec")) SWIG_fail;
  result = (std::map< std::string,Pythia8::PVec > *)new std::map< std::string,Pythia8::PVec >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapStringPVec__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::PVec > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_MapStringPVec",&obj0)) SWIG_fail;
  {
    std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > > *ptr = (std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MapStringPVec" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MapStringPVec" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::map< std::string,Pythia8::PVec > *)new std::map< std::string,Pythia8::PVec >((std::map< std::string,Pythia8::PVec > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MapStringPVec(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_MapStringPVec__SWIG_1(self, args);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__lessT_std__string_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MapStringPVec__SWIG_0(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MapStringPVec__SWIG_2(self, args);
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MapStringPVec'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< std::string,Pythia8::PVec >::map(std::less< std::string > const &)\n"
    "    std::map< std::string,Pythia8::PVec >::map()\n"
    "    std::map< std::string,Pythia8::PVec >::map(std::map< std::string,Pythia8::PVec > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapStringPVec_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringPVec_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec_empty" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  result = (bool)((std::map< std::string,Pythia8::PVec > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::PVec >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringPVec_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec_size" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  result = ((std::map< std::string,Pythia8::PVec > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  std::map< std::string,Pythia8::PVec > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringPVec_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec_swap" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringPVec_swap" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringPVec_swap" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec > &""'"); 
  }
  arg2 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::PVec >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringPVec_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec_begin" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::PVec >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::PVec >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringPVec_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec_end" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::PVec >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::PVec >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringPVec_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec_rbegin" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::PVec >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::map< std::string,Pythia8::PVec >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringPVec_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec_rend" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::PVec >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringPVec_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec_clear" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< std::pair< std::string const,Pythia8::PVec > > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:MapStringPVec_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec_get_allocator" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  result = ((std::map< std::string,Pythia8::PVec > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new std::map< std::string,Pythia8::PVec >::allocator_type(static_cast< const std::map< std::string,Pythia8::PVec >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  std::map< std::string,Pythia8::PVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::PVec >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringPVec_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec_erase" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringPVec_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringPVec_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->erase((std::map< std::string,Pythia8::PVec >::key_type const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  std::map< std::string,Pythia8::PVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::PVec >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringPVec_count",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec_count" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringPVec_count" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringPVec_count" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = ((std::map< std::string,Pythia8::PVec > const *)arg1)->count((std::map< std::string,Pythia8::PVec >::key_type const &)*arg2);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  std::map< std::string,Pythia8::PVec >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringPVec_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec_erase" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringPVec_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< std::string,Pythia8::PVec >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::PVec >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringPVec_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::iterator""'");
    }
  }
  std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__erase__SWIG_1(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec_erase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  std::map< std::string,Pythia8::PVec >::iterator arg2 ;
  std::map< std::string,Pythia8::PVec >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:MapStringPVec_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec_erase" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringPVec_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< std::string,Pythia8::PVec >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::PVec >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringPVec_erase" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringPVec_erase" "', argument " "3"" of type '" "std::map< std::string,Pythia8::PVec >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< std::string,Pythia8::PVec >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::PVec >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MapStringPVec_erase" "', argument " "3"" of type '" "std::map< std::string,Pythia8::PVec >::iterator""'");
    }
  }
  std_map_Sl_std_string_Sc_Pythia8_PVec_Sg__erase__SWIG_2(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::PVec >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_MapStringPVec_erase__SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MapStringPVec_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::PVec >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::map< std::string,Pythia8::PVec >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_MapStringPVec_erase__SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'MapStringPVec_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< std::string,Pythia8::PVec >::erase(std::map< std::string,Pythia8::PVec >::key_type const &)\n"
    "    std::map< std::string,Pythia8::PVec >::erase(std::map< std::string,Pythia8::PVec >::iterator)\n"
    "    std::map< std::string,Pythia8::PVec >::erase(std::map< std::string,Pythia8::PVec >::iterator,std::map< std::string,Pythia8::PVec >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MapStringPVec_find(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  std::map< std::string,Pythia8::PVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::PVec >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringPVec_find",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec_find" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringPVec_find" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringPVec_find" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->find((std::map< std::string,Pythia8::PVec >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::PVec >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec_lower_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  std::map< std::string,Pythia8::PVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::PVec >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringPVec_lower_bound",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec_lower_bound" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringPVec_lower_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringPVec_lower_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->lower_bound((std::map< std::string,Pythia8::PVec >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::PVec >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MapStringPVec_upper_bound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  std::map< std::string,Pythia8::PVec >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::map< std::string,Pythia8::PVec >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:MapStringPVec_upper_bound",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MapStringPVec_upper_bound" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MapStringPVec_upper_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::key_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MapStringPVec_upper_bound" "', argument " "2"" of type '" "std::map< std::string,Pythia8::PVec >::key_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->upper_bound((std::map< std::string,Pythia8::PVec >::key_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< std::string,Pythia8::PVec >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MapStringPVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::map< std::string,Pythia8::PVec > *arg1 = (std::map< std::string,Pythia8::PVec > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_MapStringPVec",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MapStringPVec" "', argument " "1"" of type '" "std::map< std::string,Pythia8::PVec > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< std::string,Pythia8::PVec > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MapStringPVec_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_VectorClustering_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:VectorClustering_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering_iterator" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  result = (swig::SwigPyIterator *)std_vector_Sl_Pythia8_Clustering_Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorClustering___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering___nonzero__" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  result = (bool)std_vector_Sl_Pythia8_Clustering_Sg____nonzero__((std::vector< Pythia8::Clustering > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorClustering___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering___bool__" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  result = (bool)std_vector_Sl_Pythia8_Clustering_Sg____bool__((std::vector< Pythia8::Clustering > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::Clustering >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorClustering___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering___len__" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  result = std_vector_Sl_Pythia8_Clustering_Sg____len__((std::vector< Pythia8::Clustering > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  std::vector< Pythia8::Clustering >::difference_type arg2 ;
  std::vector< Pythia8::Clustering >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorClustering___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering___getslice__" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorClustering___getslice__" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::Clustering >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorClustering___getslice__" "', argument " "3"" of type '" "std::vector< Pythia8::Clustering >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::Clustering >::difference_type >(val3);
  try {
    result = (std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > *)std_vector_Sl_Pythia8_Clustering_Sg____getslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  std::vector< Pythia8::Clustering >::difference_type arg2 ;
  std::vector< Pythia8::Clustering >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorClustering___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering___setslice__" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorClustering___setslice__" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::Clustering >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorClustering___setslice__" "', argument " "3"" of type '" "std::vector< Pythia8::Clustering >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::Clustering >::difference_type >(val3);
  try {
    std_vector_Sl_Pythia8_Clustering_Sg____setslice____SWIG_0(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  std::vector< Pythia8::Clustering >::difference_type arg2 ;
  std::vector< Pythia8::Clustering >::difference_type arg3 ;
  std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorClustering___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering___setslice__" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorClustering___setslice__" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::Clustering >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorClustering___setslice__" "', argument " "3"" of type '" "std::vector< Pythia8::Clustering >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::Clustering >::difference_type >(val3);
  {
    std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > *ptr = (std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorClustering___setslice__" "', argument " "4"" of type '" "std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorClustering___setslice__" "', argument " "4"" of type '" "std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > const &""'"); 
    }
    arg4 = ptr;
  }
  try {
    std_vector_Sl_Pythia8_Clustering_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > const &)*arg4);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorClustering___setslice____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorClustering___setslice____SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorClustering___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::Clustering >::__setslice__(std::vector< Pythia8::Clustering >::difference_type,std::vector< Pythia8::Clustering >::difference_type)\n"
    "    std::vector< Pythia8::Clustering >::__setslice__(std::vector< Pythia8::Clustering >::difference_type,std::vector< Pythia8::Clustering >::difference_type,std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorClustering___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  std::vector< Pythia8::Clustering >::difference_type arg2 ;
  std::vector< Pythia8::Clustering >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorClustering___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering___delslice__" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorClustering___delslice__" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::Clustering >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorClustering___delslice__" "', argument " "3"" of type '" "std::vector< Pythia8::Clustering >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::Clustering >::difference_type >(val3);
  try {
    std_vector_Sl_Pythia8_Clustering_Sg____delslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  std::vector< Pythia8::Clustering >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorClustering___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering___delitem__" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorClustering___delitem__" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::Clustering >::difference_type >(val2);
  try {
    std_vector_Sl_Pythia8_Clustering_Sg____delitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorClustering___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering___getitem__" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorClustering___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    result = (std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > *)std_vector_Sl_Pythia8_Clustering_Sg____getitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorClustering___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering___setitem__" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorClustering___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  {
    std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > *ptr = (std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorClustering___setitem__" "', argument " "3"" of type '" "std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorClustering___setitem__" "', argument " "3"" of type '" "std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    std_vector_Sl_Pythia8_Clustering_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorClustering___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering___setitem__" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorClustering___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_Pythia8_Clustering_Sg____setitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorClustering___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering___delitem__" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorClustering___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_Pythia8_Clustering_Sg____delitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorClustering___delitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorClustering___delitem____SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorClustering___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::Clustering >::__delitem__(std::vector< Pythia8::Clustering >::difference_type)\n"
    "    std::vector< Pythia8::Clustering >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorClustering___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  std::vector< Pythia8::Clustering >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< Pythia8::Clustering >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorClustering___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering___getitem__" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorClustering___getitem__" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::Clustering >::difference_type >(val2);
  try {
    result = (std::vector< Pythia8::Clustering >::value_type *) &std_vector_Sl_Pythia8_Clustering_Sg____getitem____SWIG_1((std::vector< Pythia8::Clustering > const *)arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorClustering___getitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorClustering___getitem____SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorClustering___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::Clustering >::__getitem__(PySliceObject *)\n"
    "    std::vector< Pythia8::Clustering >::__getitem__(std::vector< Pythia8::Clustering >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorClustering___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  std::vector< Pythia8::Clustering >::difference_type arg2 ;
  std::vector< Pythia8::Clustering >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorClustering___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering___setitem__" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorClustering___setitem__" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::Clustering >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Clustering,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorClustering___setitem__" "', argument " "3"" of type '" "std::vector< Pythia8::Clustering >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorClustering___setitem__" "', argument " "3"" of type '" "std::vector< Pythia8::Clustering >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::Clustering >::value_type * >(argp3);
  try {
    std_vector_Sl_Pythia8_Clustering_Sg____setitem____SWIG_2(arg1,arg2,(Pythia8::Clustering const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorClustering___setitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorClustering___setitem____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Clustering, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorClustering___setitem____SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorClustering___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::Clustering >::__setitem__(PySliceObject *,std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > const &)\n"
    "    std::vector< Pythia8::Clustering >::__setitem__(PySliceObject *)\n"
    "    std::vector< Pythia8::Clustering >::__setitem__(std::vector< Pythia8::Clustering >::difference_type,std::vector< Pythia8::Clustering >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorClustering_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::Clustering >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorClustering_pop",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering_pop" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  try {
    result = std_vector_Sl_Pythia8_Clustering_Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj((new std::vector< Pythia8::Clustering >::value_type(static_cast< const std::vector< Pythia8::Clustering >::value_type& >(result))), SWIGTYPE_p_Pythia8__Clustering, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  std::vector< Pythia8::Clustering >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorClustering_append",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering_append" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Clustering,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorClustering_append" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorClustering_append" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::Clustering >::value_type * >(argp2);
  std_vector_Sl_Pythia8_Clustering_Sg__append(arg1,(Pythia8::Clustering const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorClustering__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_VectorClustering")) SWIG_fail;
  result = (std::vector< Pythia8::Clustering > *)new std::vector< Pythia8::Clustering >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorClustering__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::Clustering > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorClustering",&obj0)) SWIG_fail;
  {
    std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > *ptr = (std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorClustering" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorClustering" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::vector< Pythia8::Clustering > *)new std::vector< Pythia8::Clustering >((std::vector< Pythia8::Clustering > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorClustering_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering_empty" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  result = (bool)((std::vector< Pythia8::Clustering > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::Clustering >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorClustering_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering_size" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  result = ((std::vector< Pythia8::Clustering > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  std::vector< Pythia8::Clustering > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorClustering_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering_swap" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorClustering_swap" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorClustering_swap" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::Clustering >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorClustering_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering_begin" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::Clustering >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::Clustering >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorClustering_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering_end" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::Clustering >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::Clustering >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorClustering_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering_rbegin" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::Clustering >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::Clustering >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorClustering_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering_rend" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::Clustering >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorClustering_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering_clear" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< Pythia8::Clustering > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorClustering_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering_get_allocator" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  result = ((std::vector< Pythia8::Clustering > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new std::vector< Pythia8::Clustering >::allocator_type(static_cast< const std::vector< Pythia8::Clustering >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_Pythia8__Clustering_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorClustering__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::Clustering > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorClustering",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorClustering" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering >::size_type""'");
  } 
  arg1 = static_cast< std::vector< Pythia8::Clustering >::size_type >(val1);
  result = (std::vector< Pythia8::Clustering > *)new std::vector< Pythia8::Clustering >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorClustering_pop_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering_pop_back" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  std::vector< Pythia8::Clustering >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorClustering_resize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering_resize" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorClustering_resize" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::Clustering >::size_type >(val2);
  (arg1)->resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  std::vector< Pythia8::Clustering >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< Pythia8::Clustering >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorClustering_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering_erase" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorClustering_erase" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::Clustering >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::Clustering >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorClustering_erase" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering >::iterator""'");
    }
  }
  result = std_vector_Sl_Pythia8_Clustering_Sg__erase__SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::Clustering >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  std::vector< Pythia8::Clustering >::iterator arg2 ;
  std::vector< Pythia8::Clustering >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< Pythia8::Clustering >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorClustering_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering_erase" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorClustering_erase" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::Clustering >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::Clustering >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorClustering_erase" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorClustering_erase" "', argument " "3"" of type '" "std::vector< Pythia8::Clustering >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::Clustering >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::Clustering >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorClustering_erase" "', argument " "3"" of type '" "std::vector< Pythia8::Clustering >::iterator""'");
    }
  }
  result = std_vector_Sl_Pythia8_Clustering_Sg__erase__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::Clustering >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::Clustering >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_VectorClustering_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::Clustering >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::Clustering >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_VectorClustering_erase__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorClustering_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::Clustering >::erase(std::vector< Pythia8::Clustering >::iterator)\n"
    "    std::vector< Pythia8::Clustering >::erase(std::vector< Pythia8::Clustering >::iterator,std::vector< Pythia8::Clustering >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_VectorClustering__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering >::size_type arg1 ;
  std::vector< Pythia8::Clustering >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< Pythia8::Clustering > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorClustering",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorClustering" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering >::size_type""'");
  } 
  arg1 = static_cast< std::vector< Pythia8::Clustering >::size_type >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Clustering,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorClustering" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorClustering" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::Clustering >::value_type * >(argp2);
  result = (std::vector< Pythia8::Clustering > *)new std::vector< Pythia8::Clustering >(arg1,(std::vector< Pythia8::Clustering >::value_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorClustering(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_VectorClustering__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_VectorClustering__SWIG_2(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VectorClustering__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Clustering, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_VectorClustering__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorClustering'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::Clustering >::vector()\n"
    "    std::vector< Pythia8::Clustering >::vector(std::vector< Pythia8::Clustering > const &)\n"
    "    std::vector< Pythia8::Clustering >::vector(std::vector< Pythia8::Clustering >::size_type)\n"
    "    std::vector< Pythia8::Clustering >::vector(std::vector< Pythia8::Clustering >::size_type,std::vector< Pythia8::Clustering >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorClustering_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  std::vector< Pythia8::Clustering >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorClustering_push_back",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering_push_back" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Clustering,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorClustering_push_back" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorClustering_push_back" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::Clustering >::value_type * >(argp2);
  (arg1)->push_back((std::vector< Pythia8::Clustering >::value_type const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::Clustering >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorClustering_front",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering_front" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  result = (std::vector< Pythia8::Clustering >::value_type *) &((std::vector< Pythia8::Clustering > const *)arg1)->front();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::Clustering >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorClustering_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering_back" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  result = (std::vector< Pythia8::Clustering >::value_type *) &((std::vector< Pythia8::Clustering > const *)arg1)->back();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Clustering, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  std::vector< Pythia8::Clustering >::size_type arg2 ;
  std::vector< Pythia8::Clustering >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorClustering_assign",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering_assign" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorClustering_assign" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::Clustering >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Clustering,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorClustering_assign" "', argument " "3"" of type '" "std::vector< Pythia8::Clustering >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorClustering_assign" "', argument " "3"" of type '" "std::vector< Pythia8::Clustering >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::Clustering >::value_type * >(argp3);
  (arg1)->assign(arg2,(std::vector< Pythia8::Clustering >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  std::vector< Pythia8::Clustering >::size_type arg2 ;
  std::vector< Pythia8::Clustering >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorClustering_resize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering_resize" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorClustering_resize" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::Clustering >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Clustering,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorClustering_resize" "', argument " "3"" of type '" "std::vector< Pythia8::Clustering >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorClustering_resize" "', argument " "3"" of type '" "std::vector< Pythia8::Clustering >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::Clustering >::value_type * >(argp3);
  (arg1)->resize(arg2,(std::vector< Pythia8::Clustering >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorClustering_resize__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Clustering, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorClustering_resize__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorClustering_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::Clustering >::resize(std::vector< Pythia8::Clustering >::size_type)\n"
    "    std::vector< Pythia8::Clustering >::resize(std::vector< Pythia8::Clustering >::size_type,std::vector< Pythia8::Clustering >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorClustering_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  std::vector< Pythia8::Clustering >::iterator arg2 ;
  std::vector< Pythia8::Clustering >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< Pythia8::Clustering >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorClustering_insert",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering_insert" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorClustering_insert" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::Clustering >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::Clustering >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorClustering_insert" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Clustering,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorClustering_insert" "', argument " "3"" of type '" "std::vector< Pythia8::Clustering >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorClustering_insert" "', argument " "3"" of type '" "std::vector< Pythia8::Clustering >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::Clustering >::value_type * >(argp3);
  result = std_vector_Sl_Pythia8_Clustering_Sg__insert__SWIG_0(arg1,arg2,(Pythia8::Clustering const &)*arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::Clustering >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  std::vector< Pythia8::Clustering >::iterator arg2 ;
  std::vector< Pythia8::Clustering >::size_type arg3 ;
  std::vector< Pythia8::Clustering >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorClustering_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering_insert" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorClustering_insert" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::Clustering >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::Clustering >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorClustering_insert" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorClustering_insert" "', argument " "3"" of type '" "std::vector< Pythia8::Clustering >::size_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::Clustering >::size_type >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Clustering,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorClustering_insert" "', argument " "4"" of type '" "std::vector< Pythia8::Clustering >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorClustering_insert" "', argument " "4"" of type '" "std::vector< Pythia8::Clustering >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< Pythia8::Clustering >::value_type * >(argp4);
  std_vector_Sl_Pythia8_Clustering_Sg__insert__SWIG_1(arg1,arg2,arg3,(Pythia8::Clustering const &)*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::Clustering >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Clustering, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorClustering_insert__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::Clustering >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Pythia8__Clustering, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorClustering_insert__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorClustering_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::Clustering >::insert(std::vector< Pythia8::Clustering >::iterator,std::vector< Pythia8::Clustering >::value_type const &)\n"
    "    std::vector< Pythia8::Clustering >::insert(std::vector< Pythia8::Clustering >::iterator,std::vector< Pythia8::Clustering >::size_type,std::vector< Pythia8::Clustering >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorClustering_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  std::vector< Pythia8::Clustering >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorClustering_reserve",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering_reserve" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorClustering_reserve" "', argument " "2"" of type '" "std::vector< Pythia8::Clustering >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::Clustering >::size_type >(val2);
  (arg1)->reserve(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorClustering_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::Clustering >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorClustering_capacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorClustering_capacity" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  result = ((std::vector< Pythia8::Clustering > const *)arg1)->capacity();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VectorClustering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Clustering > *arg1 = (std::vector< Pythia8::Clustering > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorClustering",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorClustering" "', argument " "1"" of type '" "std::vector< Pythia8::Clustering > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Clustering > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VectorClustering_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_VectorHelicityParticle_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:VectorHelicityParticle_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle_iterator" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  result = (swig::SwigPyIterator *)std_vector_Sl_Pythia8_HelicityParticle_Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorHelicityParticle___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle___nonzero__" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  result = (bool)std_vector_Sl_Pythia8_HelicityParticle_Sg____nonzero__((std::vector< Pythia8::HelicityParticle > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorHelicityParticle___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle___bool__" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  result = (bool)std_vector_Sl_Pythia8_HelicityParticle_Sg____bool__((std::vector< Pythia8::HelicityParticle > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::HelicityParticle >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorHelicityParticle___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle___len__" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  result = std_vector_Sl_Pythia8_HelicityParticle_Sg____len__((std::vector< Pythia8::HelicityParticle > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  std::vector< Pythia8::HelicityParticle >::difference_type arg2 ;
  std::vector< Pythia8::HelicityParticle >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHelicityParticle___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle___getslice__" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHelicityParticle___getslice__" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::HelicityParticle >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHelicityParticle___getslice__" "', argument " "3"" of type '" "std::vector< Pythia8::HelicityParticle >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::HelicityParticle >::difference_type >(val3);
  try {
    result = (std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *)std_vector_Sl_Pythia8_HelicityParticle_Sg____getslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  std::vector< Pythia8::HelicityParticle >::difference_type arg2 ;
  std::vector< Pythia8::HelicityParticle >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHelicityParticle___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle___setslice__" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHelicityParticle___setslice__" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::HelicityParticle >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHelicityParticle___setslice__" "', argument " "3"" of type '" "std::vector< Pythia8::HelicityParticle >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::HelicityParticle >::difference_type >(val3);
  try {
    std_vector_Sl_Pythia8_HelicityParticle_Sg____setslice____SWIG_0(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  std::vector< Pythia8::HelicityParticle >::difference_type arg2 ;
  std::vector< Pythia8::HelicityParticle >::difference_type arg3 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorHelicityParticle___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle___setslice__" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHelicityParticle___setslice__" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::HelicityParticle >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHelicityParticle___setslice__" "', argument " "3"" of type '" "std::vector< Pythia8::HelicityParticle >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::HelicityParticle >::difference_type >(val3);
  {
    std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *ptr = (std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorHelicityParticle___setslice__" "', argument " "4"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorHelicityParticle___setslice__" "', argument " "4"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > const &""'"); 
    }
    arg4 = ptr;
  }
  try {
    std_vector_Sl_Pythia8_HelicityParticle_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > const &)*arg4);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorHelicityParticle___setslice____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorHelicityParticle___setslice____SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorHelicityParticle___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::HelicityParticle >::__setslice__(std::vector< Pythia8::HelicityParticle >::difference_type,std::vector< Pythia8::HelicityParticle >::difference_type)\n"
    "    std::vector< Pythia8::HelicityParticle >::__setslice__(std::vector< Pythia8::HelicityParticle >::difference_type,std::vector< Pythia8::HelicityParticle >::difference_type,std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  std::vector< Pythia8::HelicityParticle >::difference_type arg2 ;
  std::vector< Pythia8::HelicityParticle >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHelicityParticle___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle___delslice__" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHelicityParticle___delslice__" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::HelicityParticle >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHelicityParticle___delslice__" "', argument " "3"" of type '" "std::vector< Pythia8::HelicityParticle >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::HelicityParticle >::difference_type >(val3);
  try {
    std_vector_Sl_Pythia8_HelicityParticle_Sg____delslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  std::vector< Pythia8::HelicityParticle >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorHelicityParticle___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle___delitem__" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHelicityParticle___delitem__" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::HelicityParticle >::difference_type >(val2);
  try {
    std_vector_Sl_Pythia8_HelicityParticle_Sg____delitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorHelicityParticle___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle___getitem__" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHelicityParticle___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    result = (std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *)std_vector_Sl_Pythia8_HelicityParticle_Sg____getitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHelicityParticle___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle___setitem__" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHelicityParticle___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  {
    std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *ptr = (std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHelicityParticle___setitem__" "', argument " "3"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorHelicityParticle___setitem__" "', argument " "3"" of type '" "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    std_vector_Sl_Pythia8_HelicityParticle_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorHelicityParticle___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle___setitem__" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHelicityParticle___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_Pythia8_HelicityParticle_Sg____setitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorHelicityParticle___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle___delitem__" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHelicityParticle___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_Pythia8_HelicityParticle_Sg____delitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorHelicityParticle___delitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorHelicityParticle___delitem____SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorHelicityParticle___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::HelicityParticle >::__delitem__(std::vector< Pythia8::HelicityParticle >::difference_type)\n"
    "    std::vector< Pythia8::HelicityParticle >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  std::vector< Pythia8::HelicityParticle >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< Pythia8::HelicityParticle >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorHelicityParticle___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle___getitem__" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHelicityParticle___getitem__" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::HelicityParticle >::difference_type >(val2);
  try {
    result = (std::vector< Pythia8::HelicityParticle >::value_type *) &std_vector_Sl_Pythia8_HelicityParticle_Sg____getitem____SWIG_1((std::vector< Pythia8::HelicityParticle > const *)arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityParticle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorHelicityParticle___getitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorHelicityParticle___getitem____SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorHelicityParticle___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::HelicityParticle >::__getitem__(PySliceObject *)\n"
    "    std::vector< Pythia8::HelicityParticle >::__getitem__(std::vector< Pythia8::HelicityParticle >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  std::vector< Pythia8::HelicityParticle >::difference_type arg2 ;
  std::vector< Pythia8::HelicityParticle >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHelicityParticle___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle___setitem__" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHelicityParticle___setitem__" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::HelicityParticle >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__HelicityParticle,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHelicityParticle___setitem__" "', argument " "3"" of type '" "std::vector< Pythia8::HelicityParticle >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorHelicityParticle___setitem__" "', argument " "3"" of type '" "std::vector< Pythia8::HelicityParticle >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::HelicityParticle >::value_type * >(argp3);
  try {
    std_vector_Sl_Pythia8_HelicityParticle_Sg____setitem____SWIG_2(arg1,arg2,(Pythia8::HelicityParticle const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorHelicityParticle___setitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorHelicityParticle___setitem____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__HelicityParticle, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorHelicityParticle___setitem____SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorHelicityParticle___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::HelicityParticle >::__setitem__(PySliceObject *,std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > const &)\n"
    "    std::vector< Pythia8::HelicityParticle >::__setitem__(PySliceObject *)\n"
    "    std::vector< Pythia8::HelicityParticle >::__setitem__(std::vector< Pythia8::HelicityParticle >::difference_type,std::vector< Pythia8::HelicityParticle >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::HelicityParticle >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorHelicityParticle_pop",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle_pop" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  try {
    result = std_vector_Sl_Pythia8_HelicityParticle_Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj((new std::vector< Pythia8::HelicityParticle >::value_type(static_cast< const std::vector< Pythia8::HelicityParticle >::value_type& >(result))), SWIGTYPE_p_Pythia8__HelicityParticle, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  std::vector< Pythia8::HelicityParticle >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorHelicityParticle_append",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle_append" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__HelicityParticle,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorHelicityParticle_append" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorHelicityParticle_append" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle >::value_type * >(argp2);
  std_vector_Sl_Pythia8_HelicityParticle_Sg__append(arg1,(Pythia8::HelicityParticle const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorHelicityParticle__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_VectorHelicityParticle")) SWIG_fail;
  result = (std::vector< Pythia8::HelicityParticle > *)new std::vector< Pythia8::HelicityParticle >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorHelicityParticle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::HelicityParticle > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorHelicityParticle",&obj0)) SWIG_fail;
  {
    std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *ptr = (std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorHelicityParticle" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorHelicityParticle" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::vector< Pythia8::HelicityParticle > *)new std::vector< Pythia8::HelicityParticle >((std::vector< Pythia8::HelicityParticle > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorHelicityParticle_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle_empty" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  result = (bool)((std::vector< Pythia8::HelicityParticle > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::HelicityParticle >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorHelicityParticle_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle_size" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  result = ((std::vector< Pythia8::HelicityParticle > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  std::vector< Pythia8::HelicityParticle > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorHelicityParticle_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle_swap" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorHelicityParticle_swap" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorHelicityParticle_swap" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::HelicityParticle >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorHelicityParticle_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle_begin" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::HelicityParticle >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::HelicityParticle >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorHelicityParticle_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle_end" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::HelicityParticle >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::HelicityParticle >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorHelicityParticle_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle_rbegin" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::HelicityParticle >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::HelicityParticle >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorHelicityParticle_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle_rend" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::HelicityParticle >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorHelicityParticle_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle_clear" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< Pythia8::HelicityParticle > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorHelicityParticle_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle_get_allocator" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  result = ((std::vector< Pythia8::HelicityParticle > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new std::vector< Pythia8::HelicityParticle >::allocator_type(static_cast< const std::vector< Pythia8::HelicityParticle >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_Pythia8__HelicityParticle_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorHelicityParticle__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::HelicityParticle > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorHelicityParticle",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorHelicityParticle" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle >::size_type""'");
  } 
  arg1 = static_cast< std::vector< Pythia8::HelicityParticle >::size_type >(val1);
  result = (std::vector< Pythia8::HelicityParticle > *)new std::vector< Pythia8::HelicityParticle >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorHelicityParticle_pop_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle_pop_back" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  std::vector< Pythia8::HelicityParticle >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorHelicityParticle_resize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle_resize" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHelicityParticle_resize" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::HelicityParticle >::size_type >(val2);
  (arg1)->resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  std::vector< Pythia8::HelicityParticle >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< Pythia8::HelicityParticle >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorHelicityParticle_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle_erase" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHelicityParticle_erase" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::HelicityParticle >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::HelicityParticle >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHelicityParticle_erase" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle >::iterator""'");
    }
  }
  result = std_vector_Sl_Pythia8_HelicityParticle_Sg__erase__SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::HelicityParticle >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  std::vector< Pythia8::HelicityParticle >::iterator arg2 ;
  std::vector< Pythia8::HelicityParticle >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< Pythia8::HelicityParticle >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHelicityParticle_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle_erase" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHelicityParticle_erase" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::HelicityParticle >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::HelicityParticle >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHelicityParticle_erase" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHelicityParticle_erase" "', argument " "3"" of type '" "std::vector< Pythia8::HelicityParticle >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::HelicityParticle >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::HelicityParticle >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHelicityParticle_erase" "', argument " "3"" of type '" "std::vector< Pythia8::HelicityParticle >::iterator""'");
    }
  }
  result = std_vector_Sl_Pythia8_HelicityParticle_Sg__erase__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::HelicityParticle >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::HelicityParticle >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_VectorHelicityParticle_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::HelicityParticle >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::HelicityParticle >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_VectorHelicityParticle_erase__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorHelicityParticle_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::HelicityParticle >::erase(std::vector< Pythia8::HelicityParticle >::iterator)\n"
    "    std::vector< Pythia8::HelicityParticle >::erase(std::vector< Pythia8::HelicityParticle >::iterator,std::vector< Pythia8::HelicityParticle >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_VectorHelicityParticle__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle >::size_type arg1 ;
  std::vector< Pythia8::HelicityParticle >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< Pythia8::HelicityParticle > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorHelicityParticle",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorHelicityParticle" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle >::size_type""'");
  } 
  arg1 = static_cast< std::vector< Pythia8::HelicityParticle >::size_type >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__HelicityParticle,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorHelicityParticle" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorHelicityParticle" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle >::value_type * >(argp2);
  result = (std::vector< Pythia8::HelicityParticle > *)new std::vector< Pythia8::HelicityParticle >(arg1,(std::vector< Pythia8::HelicityParticle >::value_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorHelicityParticle(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_VectorHelicityParticle__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_VectorHelicityParticle__SWIG_2(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VectorHelicityParticle__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__HelicityParticle, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_VectorHelicityParticle__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorHelicityParticle'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::HelicityParticle >::vector()\n"
    "    std::vector< Pythia8::HelicityParticle >::vector(std::vector< Pythia8::HelicityParticle > const &)\n"
    "    std::vector< Pythia8::HelicityParticle >::vector(std::vector< Pythia8::HelicityParticle >::size_type)\n"
    "    std::vector< Pythia8::HelicityParticle >::vector(std::vector< Pythia8::HelicityParticle >::size_type,std::vector< Pythia8::HelicityParticle >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  std::vector< Pythia8::HelicityParticle >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorHelicityParticle_push_back",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle_push_back" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__HelicityParticle,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorHelicityParticle_push_back" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorHelicityParticle_push_back" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::HelicityParticle >::value_type * >(argp2);
  (arg1)->push_back((std::vector< Pythia8::HelicityParticle >::value_type const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::HelicityParticle >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorHelicityParticle_front",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle_front" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  result = (std::vector< Pythia8::HelicityParticle >::value_type *) &((std::vector< Pythia8::HelicityParticle > const *)arg1)->front();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityParticle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::HelicityParticle >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorHelicityParticle_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle_back" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  result = (std::vector< Pythia8::HelicityParticle >::value_type *) &((std::vector< Pythia8::HelicityParticle > const *)arg1)->back();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__HelicityParticle, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  std::vector< Pythia8::HelicityParticle >::size_type arg2 ;
  std::vector< Pythia8::HelicityParticle >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHelicityParticle_assign",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle_assign" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHelicityParticle_assign" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::HelicityParticle >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__HelicityParticle,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHelicityParticle_assign" "', argument " "3"" of type '" "std::vector< Pythia8::HelicityParticle >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorHelicityParticle_assign" "', argument " "3"" of type '" "std::vector< Pythia8::HelicityParticle >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::HelicityParticle >::value_type * >(argp3);
  (arg1)->assign(arg2,(std::vector< Pythia8::HelicityParticle >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  std::vector< Pythia8::HelicityParticle >::size_type arg2 ;
  std::vector< Pythia8::HelicityParticle >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHelicityParticle_resize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle_resize" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHelicityParticle_resize" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::HelicityParticle >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__HelicityParticle,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHelicityParticle_resize" "', argument " "3"" of type '" "std::vector< Pythia8::HelicityParticle >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorHelicityParticle_resize" "', argument " "3"" of type '" "std::vector< Pythia8::HelicityParticle >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::HelicityParticle >::value_type * >(argp3);
  (arg1)->resize(arg2,(std::vector< Pythia8::HelicityParticle >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorHelicityParticle_resize__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__HelicityParticle, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorHelicityParticle_resize__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorHelicityParticle_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::HelicityParticle >::resize(std::vector< Pythia8::HelicityParticle >::size_type)\n"
    "    std::vector< Pythia8::HelicityParticle >::resize(std::vector< Pythia8::HelicityParticle >::size_type,std::vector< Pythia8::HelicityParticle >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  std::vector< Pythia8::HelicityParticle >::iterator arg2 ;
  std::vector< Pythia8::HelicityParticle >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< Pythia8::HelicityParticle >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHelicityParticle_insert",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle_insert" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHelicityParticle_insert" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::HelicityParticle >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::HelicityParticle >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHelicityParticle_insert" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__HelicityParticle,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHelicityParticle_insert" "', argument " "3"" of type '" "std::vector< Pythia8::HelicityParticle >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorHelicityParticle_insert" "', argument " "3"" of type '" "std::vector< Pythia8::HelicityParticle >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::HelicityParticle >::value_type * >(argp3);
  result = std_vector_Sl_Pythia8_HelicityParticle_Sg__insert__SWIG_0(arg1,arg2,(Pythia8::HelicityParticle const &)*arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::HelicityParticle >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  std::vector< Pythia8::HelicityParticle >::iterator arg2 ;
  std::vector< Pythia8::HelicityParticle >::size_type arg3 ;
  std::vector< Pythia8::HelicityParticle >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorHelicityParticle_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle_insert" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHelicityParticle_insert" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::HelicityParticle >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::HelicityParticle >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHelicityParticle_insert" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHelicityParticle_insert" "', argument " "3"" of type '" "std::vector< Pythia8::HelicityParticle >::size_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::HelicityParticle >::size_type >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__HelicityParticle,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorHelicityParticle_insert" "', argument " "4"" of type '" "std::vector< Pythia8::HelicityParticle >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorHelicityParticle_insert" "', argument " "4"" of type '" "std::vector< Pythia8::HelicityParticle >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< Pythia8::HelicityParticle >::value_type * >(argp4);
  std_vector_Sl_Pythia8_HelicityParticle_Sg__insert__SWIG_1(arg1,arg2,arg3,(Pythia8::HelicityParticle const &)*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::HelicityParticle >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__HelicityParticle, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorHelicityParticle_insert__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::HelicityParticle >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Pythia8__HelicityParticle, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorHelicityParticle_insert__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorHelicityParticle_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::HelicityParticle >::insert(std::vector< Pythia8::HelicityParticle >::iterator,std::vector< Pythia8::HelicityParticle >::value_type const &)\n"
    "    std::vector< Pythia8::HelicityParticle >::insert(std::vector< Pythia8::HelicityParticle >::iterator,std::vector< Pythia8::HelicityParticle >::size_type,std::vector< Pythia8::HelicityParticle >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  std::vector< Pythia8::HelicityParticle >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorHelicityParticle_reserve",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle_reserve" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHelicityParticle_reserve" "', argument " "2"" of type '" "std::vector< Pythia8::HelicityParticle >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::HelicityParticle >::size_type >(val2);
  (arg1)->reserve(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorHelicityParticle_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::HelicityParticle >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorHelicityParticle_capacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHelicityParticle_capacity" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  result = ((std::vector< Pythia8::HelicityParticle > const *)arg1)->capacity();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VectorHelicityParticle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::HelicityParticle > *arg1 = (std::vector< Pythia8::HelicityParticle > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorHelicityParticle",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorHelicityParticle" "', argument " "1"" of type '" "std::vector< Pythia8::HelicityParticle > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::HelicityParticle > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VectorHelicityParticle_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:VectorProcessContainerPtr_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr_iterator" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  result = (swig::SwigPyIterator *)std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorProcessContainerPtr___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr___nonzero__" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  result = (bool)std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____nonzero__((std::vector< Pythia8::ProcessContainer * > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorProcessContainerPtr___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr___bool__" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  result = (bool)std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____bool__((std::vector< Pythia8::ProcessContainer * > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ProcessContainer * >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorProcessContainerPtr___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr___len__" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  result = std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____len__((std::vector< Pythia8::ProcessContainer * > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  std::vector< Pythia8::ProcessContainer * >::difference_type arg2 ;
  std::vector< Pythia8::ProcessContainer * >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorProcessContainerPtr___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr___getslice__" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorProcessContainerPtr___getslice__" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::ProcessContainer * >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorProcessContainerPtr___getslice__" "', argument " "3"" of type '" "std::vector< Pythia8::ProcessContainer * >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::ProcessContainer * >::difference_type >(val3);
  try {
    result = (std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > *)std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____getslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  std::vector< Pythia8::ProcessContainer * >::difference_type arg2 ;
  std::vector< Pythia8::ProcessContainer * >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorProcessContainerPtr___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr___setslice__" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorProcessContainerPtr___setslice__" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::ProcessContainer * >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorProcessContainerPtr___setslice__" "', argument " "3"" of type '" "std::vector< Pythia8::ProcessContainer * >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::ProcessContainer * >::difference_type >(val3);
  try {
    std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____setslice____SWIG_0(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  std::vector< Pythia8::ProcessContainer * >::difference_type arg2 ;
  std::vector< Pythia8::ProcessContainer * >::difference_type arg3 ;
  std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorProcessContainerPtr___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr___setslice__" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorProcessContainerPtr___setslice__" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::ProcessContainer * >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorProcessContainerPtr___setslice__" "', argument " "3"" of type '" "std::vector< Pythia8::ProcessContainer * >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::ProcessContainer * >::difference_type >(val3);
  {
    std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > > *ptr = (std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorProcessContainerPtr___setslice__" "', argument " "4"" of type '" "std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorProcessContainerPtr___setslice__" "', argument " "4"" of type '" "std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > const &""'"); 
    }
    arg4 = ptr;
  }
  try {
    std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > const &)*arg4);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorProcessContainerPtr___setslice____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorProcessContainerPtr___setslice____SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorProcessContainerPtr___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::ProcessContainer * >::__setslice__(std::vector< Pythia8::ProcessContainer * >::difference_type,std::vector< Pythia8::ProcessContainer * >::difference_type)\n"
    "    std::vector< Pythia8::ProcessContainer * >::__setslice__(std::vector< Pythia8::ProcessContainer * >::difference_type,std::vector< Pythia8::ProcessContainer * >::difference_type,std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  std::vector< Pythia8::ProcessContainer * >::difference_type arg2 ;
  std::vector< Pythia8::ProcessContainer * >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorProcessContainerPtr___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr___delslice__" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorProcessContainerPtr___delslice__" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::ProcessContainer * >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorProcessContainerPtr___delslice__" "', argument " "3"" of type '" "std::vector< Pythia8::ProcessContainer * >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::ProcessContainer * >::difference_type >(val3);
  try {
    std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____delslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  std::vector< Pythia8::ProcessContainer * >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorProcessContainerPtr___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr___delitem__" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorProcessContainerPtr___delitem__" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::ProcessContainer * >::difference_type >(val2);
  try {
    std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____delitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorProcessContainerPtr___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr___getitem__" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorProcessContainerPtr___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    result = (std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > *)std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____getitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorProcessContainerPtr___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr___setitem__" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorProcessContainerPtr___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  {
    std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > > *ptr = (std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorProcessContainerPtr___setitem__" "', argument " "3"" of type '" "std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorProcessContainerPtr___setitem__" "', argument " "3"" of type '" "std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorProcessContainerPtr___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr___setitem__" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorProcessContainerPtr___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____setitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorProcessContainerPtr___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr___delitem__" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorProcessContainerPtr___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____delitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorProcessContainerPtr___delitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorProcessContainerPtr___delitem____SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorProcessContainerPtr___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::ProcessContainer * >::__delitem__(std::vector< Pythia8::ProcessContainer * >::difference_type)\n"
    "    std::vector< Pythia8::ProcessContainer * >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  std::vector< Pythia8::ProcessContainer * >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< Pythia8::ProcessContainer * >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorProcessContainerPtr___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr___getitem__" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorProcessContainerPtr___getitem__" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::ProcessContainer * >::difference_type >(val2);
  try {
    result = (std::vector< Pythia8::ProcessContainer * >::value_type)std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____getitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorProcessContainerPtr___getitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorProcessContainerPtr___getitem____SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorProcessContainerPtr___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::ProcessContainer * >::__getitem__(PySliceObject *)\n"
    "    std::vector< Pythia8::ProcessContainer * >::__getitem__(std::vector< Pythia8::ProcessContainer * >::difference_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  std::vector< Pythia8::ProcessContainer * >::difference_type arg2 ;
  std::vector< Pythia8::ProcessContainer * >::value_type arg3 = (std::vector< Pythia8::ProcessContainer * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorProcessContainerPtr___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr___setitem__" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorProcessContainerPtr___setitem__" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::ProcessContainer * >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorProcessContainerPtr___setitem__" "', argument " "3"" of type '" "std::vector< Pythia8::ProcessContainer * >::value_type""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * >::value_type >(argp3);
  try {
    std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg____setitem____SWIG_2(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorProcessContainerPtr___setitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorProcessContainerPtr___setitem____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__ProcessContainer, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorProcessContainerPtr___setitem____SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorProcessContainerPtr___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::ProcessContainer * >::__setitem__(PySliceObject *,std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > const &)\n"
    "    std::vector< Pythia8::ProcessContainer * >::__setitem__(PySliceObject *)\n"
    "    std::vector< Pythia8::ProcessContainer * >::__setitem__(std::vector< Pythia8::ProcessContainer * >::difference_type,std::vector< Pythia8::ProcessContainer * >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ProcessContainer * >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorProcessContainerPtr_pop",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr_pop" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  try {
    result = (std::vector< Pythia8::ProcessContainer * >::value_type)std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  std::vector< Pythia8::ProcessContainer * >::value_type arg2 = (std::vector< Pythia8::ProcessContainer * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorProcessContainerPtr_append",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr_append" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorProcessContainerPtr_append" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer * >::value_type""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * >::value_type >(argp2);
  std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg__append(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorProcessContainerPtr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_VectorProcessContainerPtr")) SWIG_fail;
  result = (std::vector< Pythia8::ProcessContainer * > *)new std::vector< Pythia8::ProcessContainer * >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorProcessContainerPtr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ProcessContainer * > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorProcessContainerPtr",&obj0)) SWIG_fail;
  {
    std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > > *ptr = (std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorProcessContainerPtr" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorProcessContainerPtr" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::vector< Pythia8::ProcessContainer * > *)new std::vector< Pythia8::ProcessContainer * >((std::vector< Pythia8::ProcessContainer * > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorProcessContainerPtr_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr_empty" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  result = (bool)((std::vector< Pythia8::ProcessContainer * > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ProcessContainer * >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorProcessContainerPtr_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr_size" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  result = ((std::vector< Pythia8::ProcessContainer * > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  std::vector< Pythia8::ProcessContainer * > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorProcessContainerPtr_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr_swap" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorProcessContainerPtr_swap" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer * > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorProcessContainerPtr_swap" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer * > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ProcessContainer * >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorProcessContainerPtr_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr_begin" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::ProcessContainer * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ProcessContainer * >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorProcessContainerPtr_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr_end" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::ProcessContainer * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ProcessContainer * >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorProcessContainerPtr_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr_rbegin" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::ProcessContainer * >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ProcessContainer * >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorProcessContainerPtr_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr_rend" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::ProcessContainer * >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorProcessContainerPtr_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr_clear" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< Pythia8::ProcessContainer * > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorProcessContainerPtr_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr_get_allocator" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  result = ((std::vector< Pythia8::ProcessContainer * > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new std::vector< Pythia8::ProcessContainer * >::allocator_type(static_cast< const std::vector< Pythia8::ProcessContainer * >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_Pythia8__ProcessContainer_p_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorProcessContainerPtr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ProcessContainer * > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorProcessContainerPtr",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorProcessContainerPtr" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * >::size_type""'");
  } 
  arg1 = static_cast< std::vector< Pythia8::ProcessContainer * >::size_type >(val1);
  result = (std::vector< Pythia8::ProcessContainer * > *)new std::vector< Pythia8::ProcessContainer * >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorProcessContainerPtr_pop_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr_pop_back" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  std::vector< Pythia8::ProcessContainer * >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorProcessContainerPtr_resize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr_resize" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorProcessContainerPtr_resize" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer * >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::ProcessContainer * >::size_type >(val2);
  (arg1)->resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  std::vector< Pythia8::ProcessContainer * >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< Pythia8::ProcessContainer * >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorProcessContainerPtr_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr_erase" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorProcessContainerPtr_erase" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::ProcessContainer * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::ProcessContainer * >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorProcessContainerPtr_erase" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer * >::iterator""'");
    }
  }
  result = std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg__erase__SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::ProcessContainer * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  std::vector< Pythia8::ProcessContainer * >::iterator arg2 ;
  std::vector< Pythia8::ProcessContainer * >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< Pythia8::ProcessContainer * >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorProcessContainerPtr_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr_erase" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorProcessContainerPtr_erase" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::ProcessContainer * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::ProcessContainer * >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorProcessContainerPtr_erase" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer * >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorProcessContainerPtr_erase" "', argument " "3"" of type '" "std::vector< Pythia8::ProcessContainer * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::ProcessContainer * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::ProcessContainer * >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorProcessContainerPtr_erase" "', argument " "3"" of type '" "std::vector< Pythia8::ProcessContainer * >::iterator""'");
    }
  }
  result = std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg__erase__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::ProcessContainer * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::ProcessContainer * >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_VectorProcessContainerPtr_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::ProcessContainer * >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::ProcessContainer * >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_VectorProcessContainerPtr_erase__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorProcessContainerPtr_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::ProcessContainer * >::erase(std::vector< Pythia8::ProcessContainer * >::iterator)\n"
    "    std::vector< Pythia8::ProcessContainer * >::erase(std::vector< Pythia8::ProcessContainer * >::iterator,std::vector< Pythia8::ProcessContainer * >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_VectorProcessContainerPtr__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * >::size_type arg1 ;
  std::vector< Pythia8::ProcessContainer * >::value_type arg2 = (std::vector< Pythia8::ProcessContainer * >::value_type) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< Pythia8::ProcessContainer * > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorProcessContainerPtr",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorProcessContainerPtr" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * >::size_type""'");
  } 
  arg1 = static_cast< std::vector< Pythia8::ProcessContainer * >::size_type >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorProcessContainerPtr" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer * >::value_type""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * >::value_type >(argp2);
  result = (std::vector< Pythia8::ProcessContainer * > *)new std::vector< Pythia8::ProcessContainer * >(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorProcessContainerPtr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_VectorProcessContainerPtr__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_VectorProcessContainerPtr__SWIG_2(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VectorProcessContainerPtr__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__ProcessContainer, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_VectorProcessContainerPtr__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorProcessContainerPtr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::ProcessContainer * >::vector()\n"
    "    std::vector< Pythia8::ProcessContainer * >::vector(std::vector< Pythia8::ProcessContainer * > const &)\n"
    "    std::vector< Pythia8::ProcessContainer * >::vector(std::vector< Pythia8::ProcessContainer * >::size_type)\n"
    "    std::vector< Pythia8::ProcessContainer * >::vector(std::vector< Pythia8::ProcessContainer * >::size_type,std::vector< Pythia8::ProcessContainer * >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  std::vector< Pythia8::ProcessContainer * >::value_type arg2 = (std::vector< Pythia8::ProcessContainer * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorProcessContainerPtr_push_back",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr_push_back" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorProcessContainerPtr_push_back" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer * >::value_type""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * >::value_type >(argp2);
  (arg1)->push_back(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ProcessContainer * >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorProcessContainerPtr_front",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr_front" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  result = (std::vector< Pythia8::ProcessContainer * >::value_type)((std::vector< Pythia8::ProcessContainer * > const *)arg1)->front();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ProcessContainer * >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorProcessContainerPtr_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr_back" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  result = (std::vector< Pythia8::ProcessContainer * >::value_type)((std::vector< Pythia8::ProcessContainer * > const *)arg1)->back();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  std::vector< Pythia8::ProcessContainer * >::size_type arg2 ;
  std::vector< Pythia8::ProcessContainer * >::value_type arg3 = (std::vector< Pythia8::ProcessContainer * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorProcessContainerPtr_assign",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr_assign" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorProcessContainerPtr_assign" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer * >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::ProcessContainer * >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorProcessContainerPtr_assign" "', argument " "3"" of type '" "std::vector< Pythia8::ProcessContainer * >::value_type""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * >::value_type >(argp3);
  (arg1)->assign(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  std::vector< Pythia8::ProcessContainer * >::size_type arg2 ;
  std::vector< Pythia8::ProcessContainer * >::value_type arg3 = (std::vector< Pythia8::ProcessContainer * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorProcessContainerPtr_resize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr_resize" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorProcessContainerPtr_resize" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer * >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::ProcessContainer * >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorProcessContainerPtr_resize" "', argument " "3"" of type '" "std::vector< Pythia8::ProcessContainer * >::value_type""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * >::value_type >(argp3);
  (arg1)->resize(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorProcessContainerPtr_resize__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__ProcessContainer, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorProcessContainerPtr_resize__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorProcessContainerPtr_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::ProcessContainer * >::resize(std::vector< Pythia8::ProcessContainer * >::size_type)\n"
    "    std::vector< Pythia8::ProcessContainer * >::resize(std::vector< Pythia8::ProcessContainer * >::size_type,std::vector< Pythia8::ProcessContainer * >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  std::vector< Pythia8::ProcessContainer * >::iterator arg2 ;
  std::vector< Pythia8::ProcessContainer * >::value_type arg3 = (std::vector< Pythia8::ProcessContainer * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< Pythia8::ProcessContainer * >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorProcessContainerPtr_insert",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr_insert" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorProcessContainerPtr_insert" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::ProcessContainer * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::ProcessContainer * >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorProcessContainerPtr_insert" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer * >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorProcessContainerPtr_insert" "', argument " "3"" of type '" "std::vector< Pythia8::ProcessContainer * >::value_type""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * >::value_type >(argp3);
  result = std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg__insert__SWIG_0(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::ProcessContainer * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  std::vector< Pythia8::ProcessContainer * >::iterator arg2 ;
  std::vector< Pythia8::ProcessContainer * >::size_type arg3 ;
  std::vector< Pythia8::ProcessContainer * >::value_type arg4 = (std::vector< Pythia8::ProcessContainer * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorProcessContainerPtr_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr_insert" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorProcessContainerPtr_insert" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::ProcessContainer * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::ProcessContainer * >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorProcessContainerPtr_insert" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer * >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorProcessContainerPtr_insert" "', argument " "3"" of type '" "std::vector< Pythia8::ProcessContainer * >::size_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::ProcessContainer * >::size_type >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ProcessContainer, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorProcessContainerPtr_insert" "', argument " "4"" of type '" "std::vector< Pythia8::ProcessContainer * >::value_type""'"); 
  }
  arg4 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * >::value_type >(argp4);
  std_vector_Sl_Pythia8_ProcessContainer_Sm__Sg__insert__SWIG_1(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::ProcessContainer * >::iterator > *>(iter) != 0));
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__ProcessContainer, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorProcessContainerPtr_insert__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ProcessContainer*,std::allocator< Pythia8::ProcessContainer * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::ProcessContainer * >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__ProcessContainer, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorProcessContainerPtr_insert__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorProcessContainerPtr_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::ProcessContainer * >::insert(std::vector< Pythia8::ProcessContainer * >::iterator,std::vector< Pythia8::ProcessContainer * >::value_type)\n"
    "    std::vector< Pythia8::ProcessContainer * >::insert(std::vector< Pythia8::ProcessContainer * >::iterator,std::vector< Pythia8::ProcessContainer * >::size_type,std::vector< Pythia8::ProcessContainer * >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  std::vector< Pythia8::ProcessContainer * >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorProcessContainerPtr_reserve",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr_reserve" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorProcessContainerPtr_reserve" "', argument " "2"" of type '" "std::vector< Pythia8::ProcessContainer * >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::ProcessContainer * >::size_type >(val2);
  (arg1)->reserve(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorProcessContainerPtr_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ProcessContainer * >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorProcessContainerPtr_capacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorProcessContainerPtr_capacity" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  result = ((std::vector< Pythia8::ProcessContainer * > const *)arg1)->capacity();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VectorProcessContainerPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ProcessContainer * > *arg1 = (std::vector< Pythia8::ProcessContainer * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorProcessContainerPtr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorProcessContainerPtr" "', argument " "1"" of type '" "std::vector< Pythia8::ProcessContainer * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ProcessContainer * > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VectorProcessContainerPtr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:VectorResonanceWidthsPtr_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr_iterator" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  result = (swig::SwigPyIterator *)std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorResonanceWidthsPtr___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr___nonzero__" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  result = (bool)std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____nonzero__((std::vector< Pythia8::ResonanceWidths * > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorResonanceWidthsPtr___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr___bool__" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  result = (bool)std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____bool__((std::vector< Pythia8::ResonanceWidths * > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ResonanceWidths * >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorResonanceWidthsPtr___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr___len__" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  result = std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____len__((std::vector< Pythia8::ResonanceWidths * > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  std::vector< Pythia8::ResonanceWidths * >::difference_type arg2 ;
  std::vector< Pythia8::ResonanceWidths * >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorResonanceWidthsPtr___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr___getslice__" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorResonanceWidthsPtr___getslice__" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::ResonanceWidths * >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorResonanceWidthsPtr___getslice__" "', argument " "3"" of type '" "std::vector< Pythia8::ResonanceWidths * >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::ResonanceWidths * >::difference_type >(val3);
  try {
    result = (std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > *)std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____getslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  std::vector< Pythia8::ResonanceWidths * >::difference_type arg2 ;
  std::vector< Pythia8::ResonanceWidths * >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorResonanceWidthsPtr___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr___setslice__" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorResonanceWidthsPtr___setslice__" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::ResonanceWidths * >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorResonanceWidthsPtr___setslice__" "', argument " "3"" of type '" "std::vector< Pythia8::ResonanceWidths * >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::ResonanceWidths * >::difference_type >(val3);
  try {
    std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____setslice____SWIG_0(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  std::vector< Pythia8::ResonanceWidths * >::difference_type arg2 ;
  std::vector< Pythia8::ResonanceWidths * >::difference_type arg3 ;
  std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorResonanceWidthsPtr___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr___setslice__" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorResonanceWidthsPtr___setslice__" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::ResonanceWidths * >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorResonanceWidthsPtr___setslice__" "', argument " "3"" of type '" "std::vector< Pythia8::ResonanceWidths * >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::ResonanceWidths * >::difference_type >(val3);
  {
    std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > > *ptr = (std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorResonanceWidthsPtr___setslice__" "', argument " "4"" of type '" "std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorResonanceWidthsPtr___setslice__" "', argument " "4"" of type '" "std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > const &""'"); 
    }
    arg4 = ptr;
  }
  try {
    std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > const &)*arg4);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorResonanceWidthsPtr___setslice____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorResonanceWidthsPtr___setslice____SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorResonanceWidthsPtr___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::ResonanceWidths * >::__setslice__(std::vector< Pythia8::ResonanceWidths * >::difference_type,std::vector< Pythia8::ResonanceWidths * >::difference_type)\n"
    "    std::vector< Pythia8::ResonanceWidths * >::__setslice__(std::vector< Pythia8::ResonanceWidths * >::difference_type,std::vector< Pythia8::ResonanceWidths * >::difference_type,std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  std::vector< Pythia8::ResonanceWidths * >::difference_type arg2 ;
  std::vector< Pythia8::ResonanceWidths * >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorResonanceWidthsPtr___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr___delslice__" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorResonanceWidthsPtr___delslice__" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::ResonanceWidths * >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorResonanceWidthsPtr___delslice__" "', argument " "3"" of type '" "std::vector< Pythia8::ResonanceWidths * >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::ResonanceWidths * >::difference_type >(val3);
  try {
    std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____delslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  std::vector< Pythia8::ResonanceWidths * >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorResonanceWidthsPtr___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr___delitem__" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorResonanceWidthsPtr___delitem__" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::ResonanceWidths * >::difference_type >(val2);
  try {
    std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____delitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorResonanceWidthsPtr___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr___getitem__" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorResonanceWidthsPtr___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    result = (std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > *)std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____getitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorResonanceWidthsPtr___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr___setitem__" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorResonanceWidthsPtr___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  {
    std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > > *ptr = (std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorResonanceWidthsPtr___setitem__" "', argument " "3"" of type '" "std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorResonanceWidthsPtr___setitem__" "', argument " "3"" of type '" "std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorResonanceWidthsPtr___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr___setitem__" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorResonanceWidthsPtr___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____setitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorResonanceWidthsPtr___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr___delitem__" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorResonanceWidthsPtr___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____delitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorResonanceWidthsPtr___delitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorResonanceWidthsPtr___delitem____SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorResonanceWidthsPtr___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::ResonanceWidths * >::__delitem__(std::vector< Pythia8::ResonanceWidths * >::difference_type)\n"
    "    std::vector< Pythia8::ResonanceWidths * >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  std::vector< Pythia8::ResonanceWidths * >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< Pythia8::ResonanceWidths * >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorResonanceWidthsPtr___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr___getitem__" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorResonanceWidthsPtr___getitem__" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::ResonanceWidths * >::difference_type >(val2);
  try {
    result = (std::vector< Pythia8::ResonanceWidths * >::value_type)std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____getitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorResonanceWidthsPtr___getitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorResonanceWidthsPtr___getitem____SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorResonanceWidthsPtr___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::ResonanceWidths * >::__getitem__(PySliceObject *)\n"
    "    std::vector< Pythia8::ResonanceWidths * >::__getitem__(std::vector< Pythia8::ResonanceWidths * >::difference_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  std::vector< Pythia8::ResonanceWidths * >::difference_type arg2 ;
  std::vector< Pythia8::ResonanceWidths * >::value_type arg3 = (std::vector< Pythia8::ResonanceWidths * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorResonanceWidthsPtr___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr___setitem__" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorResonanceWidthsPtr___setitem__" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::ResonanceWidths * >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorResonanceWidthsPtr___setitem__" "', argument " "3"" of type '" "std::vector< Pythia8::ResonanceWidths * >::value_type""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * >::value_type >(argp3);
  try {
    std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg____setitem____SWIG_2(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorResonanceWidthsPtr___setitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorResonanceWidthsPtr___setitem____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__ResonanceWidths, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorResonanceWidthsPtr___setitem____SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorResonanceWidthsPtr___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::ResonanceWidths * >::__setitem__(PySliceObject *,std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > const &)\n"
    "    std::vector< Pythia8::ResonanceWidths * >::__setitem__(PySliceObject *)\n"
    "    std::vector< Pythia8::ResonanceWidths * >::__setitem__(std::vector< Pythia8::ResonanceWidths * >::difference_type,std::vector< Pythia8::ResonanceWidths * >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ResonanceWidths * >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorResonanceWidthsPtr_pop",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr_pop" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  try {
    result = (std::vector< Pythia8::ResonanceWidths * >::value_type)std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  std::vector< Pythia8::ResonanceWidths * >::value_type arg2 = (std::vector< Pythia8::ResonanceWidths * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorResonanceWidthsPtr_append",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr_append" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorResonanceWidthsPtr_append" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths * >::value_type""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * >::value_type >(argp2);
  std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg__append(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorResonanceWidthsPtr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_VectorResonanceWidthsPtr")) SWIG_fail;
  result = (std::vector< Pythia8::ResonanceWidths * > *)new std::vector< Pythia8::ResonanceWidths * >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorResonanceWidthsPtr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ResonanceWidths * > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorResonanceWidthsPtr",&obj0)) SWIG_fail;
  {
    std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > > *ptr = (std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorResonanceWidthsPtr" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorResonanceWidthsPtr" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::vector< Pythia8::ResonanceWidths * > *)new std::vector< Pythia8::ResonanceWidths * >((std::vector< Pythia8::ResonanceWidths * > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorResonanceWidthsPtr_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr_empty" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  result = (bool)((std::vector< Pythia8::ResonanceWidths * > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ResonanceWidths * >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorResonanceWidthsPtr_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr_size" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  result = ((std::vector< Pythia8::ResonanceWidths * > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  std::vector< Pythia8::ResonanceWidths * > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorResonanceWidthsPtr_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr_swap" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorResonanceWidthsPtr_swap" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths * > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorResonanceWidthsPtr_swap" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths * > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ResonanceWidths * >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorResonanceWidthsPtr_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr_begin" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::ResonanceWidths * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ResonanceWidths * >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorResonanceWidthsPtr_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr_end" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::ResonanceWidths * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ResonanceWidths * >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorResonanceWidthsPtr_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr_rbegin" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::ResonanceWidths * >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ResonanceWidths * >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorResonanceWidthsPtr_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr_rend" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::ResonanceWidths * >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorResonanceWidthsPtr_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr_clear" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< Pythia8::ResonanceWidths * > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorResonanceWidthsPtr_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr_get_allocator" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  result = ((std::vector< Pythia8::ResonanceWidths * > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new std::vector< Pythia8::ResonanceWidths * >::allocator_type(static_cast< const std::vector< Pythia8::ResonanceWidths * >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_Pythia8__ResonanceWidths_p_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorResonanceWidthsPtr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ResonanceWidths * > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorResonanceWidthsPtr",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorResonanceWidthsPtr" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * >::size_type""'");
  } 
  arg1 = static_cast< std::vector< Pythia8::ResonanceWidths * >::size_type >(val1);
  result = (std::vector< Pythia8::ResonanceWidths * > *)new std::vector< Pythia8::ResonanceWidths * >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorResonanceWidthsPtr_pop_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr_pop_back" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  std::vector< Pythia8::ResonanceWidths * >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorResonanceWidthsPtr_resize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr_resize" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorResonanceWidthsPtr_resize" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths * >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::ResonanceWidths * >::size_type >(val2);
  (arg1)->resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  std::vector< Pythia8::ResonanceWidths * >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< Pythia8::ResonanceWidths * >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorResonanceWidthsPtr_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr_erase" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorResonanceWidthsPtr_erase" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::ResonanceWidths * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::ResonanceWidths * >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorResonanceWidthsPtr_erase" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths * >::iterator""'");
    }
  }
  result = std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg__erase__SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::ResonanceWidths * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  std::vector< Pythia8::ResonanceWidths * >::iterator arg2 ;
  std::vector< Pythia8::ResonanceWidths * >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< Pythia8::ResonanceWidths * >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorResonanceWidthsPtr_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr_erase" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorResonanceWidthsPtr_erase" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::ResonanceWidths * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::ResonanceWidths * >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorResonanceWidthsPtr_erase" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths * >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorResonanceWidthsPtr_erase" "', argument " "3"" of type '" "std::vector< Pythia8::ResonanceWidths * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::ResonanceWidths * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::ResonanceWidths * >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorResonanceWidthsPtr_erase" "', argument " "3"" of type '" "std::vector< Pythia8::ResonanceWidths * >::iterator""'");
    }
  }
  result = std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg__erase__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::ResonanceWidths * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::ResonanceWidths * >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_VectorResonanceWidthsPtr_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::ResonanceWidths * >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::ResonanceWidths * >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_VectorResonanceWidthsPtr_erase__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorResonanceWidthsPtr_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::ResonanceWidths * >::erase(std::vector< Pythia8::ResonanceWidths * >::iterator)\n"
    "    std::vector< Pythia8::ResonanceWidths * >::erase(std::vector< Pythia8::ResonanceWidths * >::iterator,std::vector< Pythia8::ResonanceWidths * >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_VectorResonanceWidthsPtr__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * >::size_type arg1 ;
  std::vector< Pythia8::ResonanceWidths * >::value_type arg2 = (std::vector< Pythia8::ResonanceWidths * >::value_type) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< Pythia8::ResonanceWidths * > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorResonanceWidthsPtr",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorResonanceWidthsPtr" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * >::size_type""'");
  } 
  arg1 = static_cast< std::vector< Pythia8::ResonanceWidths * >::size_type >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorResonanceWidthsPtr" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths * >::value_type""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * >::value_type >(argp2);
  result = (std::vector< Pythia8::ResonanceWidths * > *)new std::vector< Pythia8::ResonanceWidths * >(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorResonanceWidthsPtr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_VectorResonanceWidthsPtr__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_VectorResonanceWidthsPtr__SWIG_2(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VectorResonanceWidthsPtr__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__ResonanceWidths, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_VectorResonanceWidthsPtr__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorResonanceWidthsPtr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::ResonanceWidths * >::vector()\n"
    "    std::vector< Pythia8::ResonanceWidths * >::vector(std::vector< Pythia8::ResonanceWidths * > const &)\n"
    "    std::vector< Pythia8::ResonanceWidths * >::vector(std::vector< Pythia8::ResonanceWidths * >::size_type)\n"
    "    std::vector< Pythia8::ResonanceWidths * >::vector(std::vector< Pythia8::ResonanceWidths * >::size_type,std::vector< Pythia8::ResonanceWidths * >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  std::vector< Pythia8::ResonanceWidths * >::value_type arg2 = (std::vector< Pythia8::ResonanceWidths * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorResonanceWidthsPtr_push_back",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr_push_back" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorResonanceWidthsPtr_push_back" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths * >::value_type""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * >::value_type >(argp2);
  (arg1)->push_back(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ResonanceWidths * >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorResonanceWidthsPtr_front",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr_front" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  result = (std::vector< Pythia8::ResonanceWidths * >::value_type)((std::vector< Pythia8::ResonanceWidths * > const *)arg1)->front();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ResonanceWidths * >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorResonanceWidthsPtr_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr_back" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  result = (std::vector< Pythia8::ResonanceWidths * >::value_type)((std::vector< Pythia8::ResonanceWidths * > const *)arg1)->back();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  std::vector< Pythia8::ResonanceWidths * >::size_type arg2 ;
  std::vector< Pythia8::ResonanceWidths * >::value_type arg3 = (std::vector< Pythia8::ResonanceWidths * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorResonanceWidthsPtr_assign",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr_assign" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorResonanceWidthsPtr_assign" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths * >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::ResonanceWidths * >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorResonanceWidthsPtr_assign" "', argument " "3"" of type '" "std::vector< Pythia8::ResonanceWidths * >::value_type""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * >::value_type >(argp3);
  (arg1)->assign(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  std::vector< Pythia8::ResonanceWidths * >::size_type arg2 ;
  std::vector< Pythia8::ResonanceWidths * >::value_type arg3 = (std::vector< Pythia8::ResonanceWidths * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorResonanceWidthsPtr_resize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr_resize" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorResonanceWidthsPtr_resize" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths * >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::ResonanceWidths * >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorResonanceWidthsPtr_resize" "', argument " "3"" of type '" "std::vector< Pythia8::ResonanceWidths * >::value_type""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * >::value_type >(argp3);
  (arg1)->resize(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorResonanceWidthsPtr_resize__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__ResonanceWidths, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorResonanceWidthsPtr_resize__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorResonanceWidthsPtr_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::ResonanceWidths * >::resize(std::vector< Pythia8::ResonanceWidths * >::size_type)\n"
    "    std::vector< Pythia8::ResonanceWidths * >::resize(std::vector< Pythia8::ResonanceWidths * >::size_type,std::vector< Pythia8::ResonanceWidths * >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  std::vector< Pythia8::ResonanceWidths * >::iterator arg2 ;
  std::vector< Pythia8::ResonanceWidths * >::value_type arg3 = (std::vector< Pythia8::ResonanceWidths * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< Pythia8::ResonanceWidths * >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorResonanceWidthsPtr_insert",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr_insert" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorResonanceWidthsPtr_insert" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::ResonanceWidths * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::ResonanceWidths * >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorResonanceWidthsPtr_insert" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths * >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorResonanceWidthsPtr_insert" "', argument " "3"" of type '" "std::vector< Pythia8::ResonanceWidths * >::value_type""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * >::value_type >(argp3);
  result = std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg__insert__SWIG_0(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::ResonanceWidths * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  std::vector< Pythia8::ResonanceWidths * >::iterator arg2 ;
  std::vector< Pythia8::ResonanceWidths * >::size_type arg3 ;
  std::vector< Pythia8::ResonanceWidths * >::value_type arg4 = (std::vector< Pythia8::ResonanceWidths * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorResonanceWidthsPtr_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr_insert" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorResonanceWidthsPtr_insert" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::ResonanceWidths * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::ResonanceWidths * >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorResonanceWidthsPtr_insert" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths * >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorResonanceWidthsPtr_insert" "', argument " "3"" of type '" "std::vector< Pythia8::ResonanceWidths * >::size_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::ResonanceWidths * >::size_type >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__ResonanceWidths, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorResonanceWidthsPtr_insert" "', argument " "4"" of type '" "std::vector< Pythia8::ResonanceWidths * >::value_type""'"); 
  }
  arg4 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * >::value_type >(argp4);
  std_vector_Sl_Pythia8_ResonanceWidths_Sm__Sg__insert__SWIG_1(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::ResonanceWidths * >::iterator > *>(iter) != 0));
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__ResonanceWidths, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorResonanceWidthsPtr_insert__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::ResonanceWidths*,std::allocator< Pythia8::ResonanceWidths * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::ResonanceWidths * >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__ResonanceWidths, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorResonanceWidthsPtr_insert__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorResonanceWidthsPtr_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::ResonanceWidths * >::insert(std::vector< Pythia8::ResonanceWidths * >::iterator,std::vector< Pythia8::ResonanceWidths * >::value_type)\n"
    "    std::vector< Pythia8::ResonanceWidths * >::insert(std::vector< Pythia8::ResonanceWidths * >::iterator,std::vector< Pythia8::ResonanceWidths * >::size_type,std::vector< Pythia8::ResonanceWidths * >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  std::vector< Pythia8::ResonanceWidths * >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorResonanceWidthsPtr_reserve",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr_reserve" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorResonanceWidthsPtr_reserve" "', argument " "2"" of type '" "std::vector< Pythia8::ResonanceWidths * >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::ResonanceWidths * >::size_type >(val2);
  (arg1)->reserve(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorResonanceWidthsPtr_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::ResonanceWidths * >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorResonanceWidthsPtr_capacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorResonanceWidthsPtr_capacity" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  result = ((std::vector< Pythia8::ResonanceWidths * > const *)arg1)->capacity();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VectorResonanceWidthsPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::ResonanceWidths * > *arg1 = (std::vector< Pythia8::ResonanceWidths * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorResonanceWidthsPtr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorResonanceWidthsPtr" "', argument " "1"" of type '" "std::vector< Pythia8::ResonanceWidths * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::ResonanceWidths * > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VectorResonanceWidthsPtr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:VectorSigmaProcessPtr_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr_iterator" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  result = (swig::SwigPyIterator *)std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorSigmaProcessPtr___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr___nonzero__" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  result = (bool)std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____nonzero__((std::vector< Pythia8::SigmaProcess * > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorSigmaProcessPtr___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr___bool__" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  result = (bool)std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____bool__((std::vector< Pythia8::SigmaProcess * > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::SigmaProcess * >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorSigmaProcessPtr___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr___len__" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  result = std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____len__((std::vector< Pythia8::SigmaProcess * > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  std::vector< Pythia8::SigmaProcess * >::difference_type arg2 ;
  std::vector< Pythia8::SigmaProcess * >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorSigmaProcessPtr___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr___getslice__" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorSigmaProcessPtr___getslice__" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::SigmaProcess * >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorSigmaProcessPtr___getslice__" "', argument " "3"" of type '" "std::vector< Pythia8::SigmaProcess * >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::SigmaProcess * >::difference_type >(val3);
  try {
    result = (std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > *)std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____getslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  std::vector< Pythia8::SigmaProcess * >::difference_type arg2 ;
  std::vector< Pythia8::SigmaProcess * >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorSigmaProcessPtr___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr___setslice__" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorSigmaProcessPtr___setslice__" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::SigmaProcess * >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorSigmaProcessPtr___setslice__" "', argument " "3"" of type '" "std::vector< Pythia8::SigmaProcess * >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::SigmaProcess * >::difference_type >(val3);
  try {
    std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____setslice____SWIG_0(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  std::vector< Pythia8::SigmaProcess * >::difference_type arg2 ;
  std::vector< Pythia8::SigmaProcess * >::difference_type arg3 ;
  std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorSigmaProcessPtr___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr___setslice__" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorSigmaProcessPtr___setslice__" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::SigmaProcess * >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorSigmaProcessPtr___setslice__" "', argument " "3"" of type '" "std::vector< Pythia8::SigmaProcess * >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::SigmaProcess * >::difference_type >(val3);
  {
    std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > > *ptr = (std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorSigmaProcessPtr___setslice__" "', argument " "4"" of type '" "std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorSigmaProcessPtr___setslice__" "', argument " "4"" of type '" "std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > const &""'"); 
    }
    arg4 = ptr;
  }
  try {
    std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > const &)*arg4);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorSigmaProcessPtr___setslice____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorSigmaProcessPtr___setslice____SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorSigmaProcessPtr___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::SigmaProcess * >::__setslice__(std::vector< Pythia8::SigmaProcess * >::difference_type,std::vector< Pythia8::SigmaProcess * >::difference_type)\n"
    "    std::vector< Pythia8::SigmaProcess * >::__setslice__(std::vector< Pythia8::SigmaProcess * >::difference_type,std::vector< Pythia8::SigmaProcess * >::difference_type,std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  std::vector< Pythia8::SigmaProcess * >::difference_type arg2 ;
  std::vector< Pythia8::SigmaProcess * >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorSigmaProcessPtr___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr___delslice__" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorSigmaProcessPtr___delslice__" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::SigmaProcess * >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorSigmaProcessPtr___delslice__" "', argument " "3"" of type '" "std::vector< Pythia8::SigmaProcess * >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::SigmaProcess * >::difference_type >(val3);
  try {
    std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____delslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  std::vector< Pythia8::SigmaProcess * >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorSigmaProcessPtr___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr___delitem__" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorSigmaProcessPtr___delitem__" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::SigmaProcess * >::difference_type >(val2);
  try {
    std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____delitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorSigmaProcessPtr___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr___getitem__" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorSigmaProcessPtr___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    result = (std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > *)std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____getitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorSigmaProcessPtr___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr___setitem__" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorSigmaProcessPtr___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  {
    std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > > *ptr = (std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorSigmaProcessPtr___setitem__" "', argument " "3"" of type '" "std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorSigmaProcessPtr___setitem__" "', argument " "3"" of type '" "std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorSigmaProcessPtr___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr___setitem__" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorSigmaProcessPtr___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____setitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorSigmaProcessPtr___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr___delitem__" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorSigmaProcessPtr___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____delitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorSigmaProcessPtr___delitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorSigmaProcessPtr___delitem____SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorSigmaProcessPtr___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::SigmaProcess * >::__delitem__(std::vector< Pythia8::SigmaProcess * >::difference_type)\n"
    "    std::vector< Pythia8::SigmaProcess * >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  std::vector< Pythia8::SigmaProcess * >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< Pythia8::SigmaProcess * >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorSigmaProcessPtr___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr___getitem__" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorSigmaProcessPtr___getitem__" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::SigmaProcess * >::difference_type >(val2);
  try {
    result = (std::vector< Pythia8::SigmaProcess * >::value_type)std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____getitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorSigmaProcessPtr___getitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorSigmaProcessPtr___getitem____SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorSigmaProcessPtr___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::SigmaProcess * >::__getitem__(PySliceObject *)\n"
    "    std::vector< Pythia8::SigmaProcess * >::__getitem__(std::vector< Pythia8::SigmaProcess * >::difference_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  std::vector< Pythia8::SigmaProcess * >::difference_type arg2 ;
  std::vector< Pythia8::SigmaProcess * >::value_type arg3 = (std::vector< Pythia8::SigmaProcess * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorSigmaProcessPtr___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr___setitem__" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorSigmaProcessPtr___setitem__" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::SigmaProcess * >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorSigmaProcessPtr___setitem__" "', argument " "3"" of type '" "std::vector< Pythia8::SigmaProcess * >::value_type""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * >::value_type >(argp3);
  try {
    std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg____setitem____SWIG_2(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorSigmaProcessPtr___setitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorSigmaProcessPtr___setitem____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorSigmaProcessPtr___setitem____SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorSigmaProcessPtr___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::SigmaProcess * >::__setitem__(PySliceObject *,std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > const &)\n"
    "    std::vector< Pythia8::SigmaProcess * >::__setitem__(PySliceObject *)\n"
    "    std::vector< Pythia8::SigmaProcess * >::__setitem__(std::vector< Pythia8::SigmaProcess * >::difference_type,std::vector< Pythia8::SigmaProcess * >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::SigmaProcess * >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorSigmaProcessPtr_pop",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr_pop" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  try {
    result = (std::vector< Pythia8::SigmaProcess * >::value_type)std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  std::vector< Pythia8::SigmaProcess * >::value_type arg2 = (std::vector< Pythia8::SigmaProcess * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorSigmaProcessPtr_append",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr_append" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorSigmaProcessPtr_append" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess * >::value_type""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * >::value_type >(argp2);
  std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg__append(arg1,arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorSigmaProcessPtr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_VectorSigmaProcessPtr")) SWIG_fail;
  result = (std::vector< Pythia8::SigmaProcess * > *)new std::vector< Pythia8::SigmaProcess * >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorSigmaProcessPtr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::SigmaProcess * > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorSigmaProcessPtr",&obj0)) SWIG_fail;
  {
    std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > > *ptr = (std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorSigmaProcessPtr" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorSigmaProcessPtr" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::vector< Pythia8::SigmaProcess * > *)new std::vector< Pythia8::SigmaProcess * >((std::vector< Pythia8::SigmaProcess * > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorSigmaProcessPtr_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr_empty" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  result = (bool)((std::vector< Pythia8::SigmaProcess * > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::SigmaProcess * >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorSigmaProcessPtr_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr_size" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  result = ((std::vector< Pythia8::SigmaProcess * > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  std::vector< Pythia8::SigmaProcess * > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorSigmaProcessPtr_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr_swap" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorSigmaProcessPtr_swap" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess * > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorSigmaProcessPtr_swap" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess * > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::SigmaProcess * >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorSigmaProcessPtr_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr_begin" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::SigmaProcess * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::SigmaProcess * >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorSigmaProcessPtr_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr_end" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::SigmaProcess * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::SigmaProcess * >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorSigmaProcessPtr_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr_rbegin" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::SigmaProcess * >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::SigmaProcess * >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorSigmaProcessPtr_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr_rend" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::SigmaProcess * >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorSigmaProcessPtr_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr_clear" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< Pythia8::SigmaProcess * > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorSigmaProcessPtr_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr_get_allocator" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  result = ((std::vector< Pythia8::SigmaProcess * > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new std::vector< Pythia8::SigmaProcess * >::allocator_type(static_cast< const std::vector< Pythia8::SigmaProcess * >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_Pythia8__SigmaProcess_p_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorSigmaProcessPtr__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::SigmaProcess * > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorSigmaProcessPtr",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorSigmaProcessPtr" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * >::size_type""'");
  } 
  arg1 = static_cast< std::vector< Pythia8::SigmaProcess * >::size_type >(val1);
  result = (std::vector< Pythia8::SigmaProcess * > *)new std::vector< Pythia8::SigmaProcess * >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorSigmaProcessPtr_pop_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr_pop_back" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  std::vector< Pythia8::SigmaProcess * >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorSigmaProcessPtr_resize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr_resize" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorSigmaProcessPtr_resize" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess * >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::SigmaProcess * >::size_type >(val2);
  (arg1)->resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  std::vector< Pythia8::SigmaProcess * >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< Pythia8::SigmaProcess * >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorSigmaProcessPtr_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr_erase" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorSigmaProcessPtr_erase" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::SigmaProcess * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::SigmaProcess * >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorSigmaProcessPtr_erase" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess * >::iterator""'");
    }
  }
  result = std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg__erase__SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::SigmaProcess * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  std::vector< Pythia8::SigmaProcess * >::iterator arg2 ;
  std::vector< Pythia8::SigmaProcess * >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< Pythia8::SigmaProcess * >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorSigmaProcessPtr_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr_erase" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorSigmaProcessPtr_erase" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::SigmaProcess * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::SigmaProcess * >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorSigmaProcessPtr_erase" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess * >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorSigmaProcessPtr_erase" "', argument " "3"" of type '" "std::vector< Pythia8::SigmaProcess * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::SigmaProcess * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::SigmaProcess * >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorSigmaProcessPtr_erase" "', argument " "3"" of type '" "std::vector< Pythia8::SigmaProcess * >::iterator""'");
    }
  }
  result = std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg__erase__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::SigmaProcess * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::SigmaProcess * >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_VectorSigmaProcessPtr_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::SigmaProcess * >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::SigmaProcess * >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_VectorSigmaProcessPtr_erase__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorSigmaProcessPtr_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::SigmaProcess * >::erase(std::vector< Pythia8::SigmaProcess * >::iterator)\n"
    "    std::vector< Pythia8::SigmaProcess * >::erase(std::vector< Pythia8::SigmaProcess * >::iterator,std::vector< Pythia8::SigmaProcess * >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_VectorSigmaProcessPtr__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * >::size_type arg1 ;
  std::vector< Pythia8::SigmaProcess * >::value_type arg2 = (std::vector< Pythia8::SigmaProcess * >::value_type) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< Pythia8::SigmaProcess * > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorSigmaProcessPtr",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorSigmaProcessPtr" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * >::size_type""'");
  } 
  arg1 = static_cast< std::vector< Pythia8::SigmaProcess * >::size_type >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorSigmaProcessPtr" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess * >::value_type""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * >::value_type >(argp2);
  result = (std::vector< Pythia8::SigmaProcess * > *)new std::vector< Pythia8::SigmaProcess * >(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorSigmaProcessPtr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_VectorSigmaProcessPtr__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_VectorSigmaProcessPtr__SWIG_2(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VectorSigmaProcessPtr__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_VectorSigmaProcessPtr__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorSigmaProcessPtr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::SigmaProcess * >::vector()\n"
    "    std::vector< Pythia8::SigmaProcess * >::vector(std::vector< Pythia8::SigmaProcess * > const &)\n"
    "    std::vector< Pythia8::SigmaProcess * >::vector(std::vector< Pythia8::SigmaProcess * >::size_type)\n"
    "    std::vector< Pythia8::SigmaProcess * >::vector(std::vector< Pythia8::SigmaProcess * >::size_type,std::vector< Pythia8::SigmaProcess * >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  std::vector< Pythia8::SigmaProcess * >::value_type arg2 = (std::vector< Pythia8::SigmaProcess * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorSigmaProcessPtr_push_back",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr_push_back" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorSigmaProcessPtr_push_back" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess * >::value_type""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * >::value_type >(argp2);
  (arg1)->push_back(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::SigmaProcess * >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorSigmaProcessPtr_front",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr_front" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  result = (std::vector< Pythia8::SigmaProcess * >::value_type)((std::vector< Pythia8::SigmaProcess * > const *)arg1)->front();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::SigmaProcess * >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorSigmaProcessPtr_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr_back" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  result = (std::vector< Pythia8::SigmaProcess * >::value_type)((std::vector< Pythia8::SigmaProcess * > const *)arg1)->back();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  std::vector< Pythia8::SigmaProcess * >::size_type arg2 ;
  std::vector< Pythia8::SigmaProcess * >::value_type arg3 = (std::vector< Pythia8::SigmaProcess * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorSigmaProcessPtr_assign",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr_assign" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorSigmaProcessPtr_assign" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess * >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::SigmaProcess * >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorSigmaProcessPtr_assign" "', argument " "3"" of type '" "std::vector< Pythia8::SigmaProcess * >::value_type""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * >::value_type >(argp3);
  (arg1)->assign(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  std::vector< Pythia8::SigmaProcess * >::size_type arg2 ;
  std::vector< Pythia8::SigmaProcess * >::value_type arg3 = (std::vector< Pythia8::SigmaProcess * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorSigmaProcessPtr_resize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr_resize" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorSigmaProcessPtr_resize" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess * >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::SigmaProcess * >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorSigmaProcessPtr_resize" "', argument " "3"" of type '" "std::vector< Pythia8::SigmaProcess * >::value_type""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * >::value_type >(argp3);
  (arg1)->resize(arg2,arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorSigmaProcessPtr_resize__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorSigmaProcessPtr_resize__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorSigmaProcessPtr_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::SigmaProcess * >::resize(std::vector< Pythia8::SigmaProcess * >::size_type)\n"
    "    std::vector< Pythia8::SigmaProcess * >::resize(std::vector< Pythia8::SigmaProcess * >::size_type,std::vector< Pythia8::SigmaProcess * >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  std::vector< Pythia8::SigmaProcess * >::iterator arg2 ;
  std::vector< Pythia8::SigmaProcess * >::value_type arg3 = (std::vector< Pythia8::SigmaProcess * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< Pythia8::SigmaProcess * >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorSigmaProcessPtr_insert",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr_insert" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorSigmaProcessPtr_insert" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::SigmaProcess * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::SigmaProcess * >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorSigmaProcessPtr_insert" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess * >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorSigmaProcessPtr_insert" "', argument " "3"" of type '" "std::vector< Pythia8::SigmaProcess * >::value_type""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * >::value_type >(argp3);
  result = std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg__insert__SWIG_0(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::SigmaProcess * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  std::vector< Pythia8::SigmaProcess * >::iterator arg2 ;
  std::vector< Pythia8::SigmaProcess * >::size_type arg3 ;
  std::vector< Pythia8::SigmaProcess * >::value_type arg4 = (std::vector< Pythia8::SigmaProcess * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorSigmaProcessPtr_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr_insert" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorSigmaProcessPtr_insert" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::SigmaProcess * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::SigmaProcess * >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorSigmaProcessPtr_insert" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess * >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorSigmaProcessPtr_insert" "', argument " "3"" of type '" "std::vector< Pythia8::SigmaProcess * >::size_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::SigmaProcess * >::size_type >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Pythia8__SigmaProcess, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorSigmaProcessPtr_insert" "', argument " "4"" of type '" "std::vector< Pythia8::SigmaProcess * >::value_type""'"); 
  }
  arg4 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * >::value_type >(argp4);
  std_vector_Sl_Pythia8_SigmaProcess_Sm__Sg__insert__SWIG_1(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::SigmaProcess * >::iterator > *>(iter) != 0));
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorSigmaProcessPtr_insert__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::SigmaProcess*,std::allocator< Pythia8::SigmaProcess * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::SigmaProcess * >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Pythia8__SigmaProcess, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorSigmaProcessPtr_insert__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorSigmaProcessPtr_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::SigmaProcess * >::insert(std::vector< Pythia8::SigmaProcess * >::iterator,std::vector< Pythia8::SigmaProcess * >::value_type)\n"
    "    std::vector< Pythia8::SigmaProcess * >::insert(std::vector< Pythia8::SigmaProcess * >::iterator,std::vector< Pythia8::SigmaProcess * >::size_type,std::vector< Pythia8::SigmaProcess * >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  std::vector< Pythia8::SigmaProcess * >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorSigmaProcessPtr_reserve",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr_reserve" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorSigmaProcessPtr_reserve" "', argument " "2"" of type '" "std::vector< Pythia8::SigmaProcess * >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::SigmaProcess * >::size_type >(val2);
  (arg1)->reserve(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorSigmaProcessPtr_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::SigmaProcess * >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorSigmaProcessPtr_capacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorSigmaProcessPtr_capacity" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  result = ((std::vector< Pythia8::SigmaProcess * > const *)arg1)->capacity();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VectorSigmaProcessPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::SigmaProcess * > *arg1 = (std::vector< Pythia8::SigmaProcess * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorSigmaProcessPtr",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorSigmaProcessPtr" "', argument " "1"" of type '" "std::vector< Pythia8::SigmaProcess * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::SigmaProcess * > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VectorSigmaProcessPtr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_VectorVec4_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &obj0;
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVec4_iterator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4_iterator" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  result = (swig::SwigPyIterator *)std_vector_Sl_Pythia8_Vec4_Sg__iterator(arg1,arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVec4___nonzero__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4___nonzero__" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  result = (bool)std_vector_Sl_Pythia8_Vec4_Sg____nonzero__((std::vector< Pythia8::Vec4 > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVec4___bool__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4___bool__" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  result = (bool)std_vector_Sl_Pythia8_Vec4_Sg____bool__((std::vector< Pythia8::Vec4 > const *)arg1);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::Vec4 >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVec4___len__",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4___len__" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  result = std_vector_Sl_Pythia8_Vec4_Sg____len__((std::vector< Pythia8::Vec4 > const *)arg1);
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  std::vector< Pythia8::Vec4 >::difference_type arg2 ;
  std::vector< Pythia8::Vec4 >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVec4___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4___getslice__" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVec4___getslice__" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::Vec4 >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVec4___getslice__" "', argument " "3"" of type '" "std::vector< Pythia8::Vec4 >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::Vec4 >::difference_type >(val3);
  try {
    result = (std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > *)std_vector_Sl_Pythia8_Vec4_Sg____getslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  std::vector< Pythia8::Vec4 >::difference_type arg2 ;
  std::vector< Pythia8::Vec4 >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVec4___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4___setslice__" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVec4___setslice__" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::Vec4 >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVec4___setslice__" "', argument " "3"" of type '" "std::vector< Pythia8::Vec4 >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::Vec4 >::difference_type >(val3);
  try {
    std_vector_Sl_Pythia8_Vec4_Sg____setslice____SWIG_0(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  std::vector< Pythia8::Vec4 >::difference_type arg2 ;
  std::vector< Pythia8::Vec4 >::difference_type arg3 ;
  std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorVec4___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4___setslice__" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVec4___setslice__" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::Vec4 >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVec4___setslice__" "', argument " "3"" of type '" "std::vector< Pythia8::Vec4 >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::Vec4 >::difference_type >(val3);
  {
    std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > *ptr = (std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > *)0;
    res4 = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorVec4___setslice__" "', argument " "4"" of type '" "std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVec4___setslice__" "', argument " "4"" of type '" "std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > const &""'"); 
    }
    arg4 = ptr;
  }
  try {
    std_vector_Sl_Pythia8_Vec4_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > const &)*arg4);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VectorVec4___setslice____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorVec4___setslice____SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVec4___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::Vec4 >::__setslice__(std::vector< Pythia8::Vec4 >::difference_type,std::vector< Pythia8::Vec4 >::difference_type)\n"
    "    std::vector< Pythia8::Vec4 >::__setslice__(std::vector< Pythia8::Vec4 >::difference_type,std::vector< Pythia8::Vec4 >::difference_type,std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorVec4___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  std::vector< Pythia8::Vec4 >::difference_type arg2 ;
  std::vector< Pythia8::Vec4 >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVec4___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4___delslice__" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVec4___delslice__" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::Vec4 >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVec4___delslice__" "', argument " "3"" of type '" "std::vector< Pythia8::Vec4 >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::Vec4 >::difference_type >(val3);
  try {
    std_vector_Sl_Pythia8_Vec4_Sg____delslice__(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  std::vector< Pythia8::Vec4 >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVec4___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4___delitem__" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVec4___delitem__" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::Vec4 >::difference_type >(val2);
  try {
    std_vector_Sl_Pythia8_Vec4_Sg____delitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVec4___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4___getitem__" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVec4___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    result = (std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > *)std_vector_Sl_Pythia8_Vec4_Sg____getitem____SWIG_0(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVec4___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4___setitem__" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVec4___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  {
    std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > *ptr = (std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVec4___setitem__" "', argument " "3"" of type '" "std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVec4___setitem__" "', argument " "3"" of type '" "std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > const &""'"); 
    }
    arg3 = ptr;
  }
  try {
    std_vector_Sl_Pythia8_Vec4_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVec4___setitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4___setitem__" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVec4___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_Pythia8_Vec4_Sg____setitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVec4___delitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4___delitem__" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  {
    if (!PySlice_Check(obj1)) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVec4___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) obj1;
  }
  try {
    std_vector_Sl_Pythia8_Vec4_Sg____delitem____SWIG_1(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorVec4___delitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorVec4___delitem____SWIG_0(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVec4___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::Vec4 >::__delitem__(std::vector< Pythia8::Vec4 >::difference_type)\n"
    "    std::vector< Pythia8::Vec4 >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorVec4___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  std::vector< Pythia8::Vec4 >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< Pythia8::Vec4 >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVec4___getitem__",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4___getitem__" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVec4___getitem__" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::Vec4 >::difference_type >(val2);
  try {
    result = (std::vector< Pythia8::Vec4 >::value_type *) &std_vector_Sl_Pythia8_Vec4_Sg____getitem____SWIG_1((std::vector< Pythia8::Vec4 > const *)arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorVec4___getitem____SWIG_0(self, args);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorVec4___getitem____SWIG_1(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVec4___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::Vec4 >::__getitem__(PySliceObject *)\n"
    "    std::vector< Pythia8::Vec4 >::__getitem__(std::vector< Pythia8::Vec4 >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorVec4___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  std::vector< Pythia8::Vec4 >::difference_type arg2 ;
  std::vector< Pythia8::Vec4 >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVec4___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4___setitem__" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVec4___setitem__" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::Vec4 >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVec4___setitem__" "', argument " "3"" of type '" "std::vector< Pythia8::Vec4 >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVec4___setitem__" "', argument " "3"" of type '" "std::vector< Pythia8::Vec4 >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::Vec4 >::value_type * >(argp3);
  try {
    std_vector_Sl_Pythia8_Vec4_Sg____setitem____SWIG_2(arg1,arg2,(Pythia8::Vec4 const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_VectorVec4___setitem____SWIG_1(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorVec4___setitem____SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorVec4___setitem____SWIG_2(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVec4___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::Vec4 >::__setitem__(PySliceObject *,std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > const &)\n"
    "    std::vector< Pythia8::Vec4 >::__setitem__(PySliceObject *)\n"
    "    std::vector< Pythia8::Vec4 >::__setitem__(std::vector< Pythia8::Vec4 >::difference_type,std::vector< Pythia8::Vec4 >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorVec4_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::Vec4 >::value_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVec4_pop",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4_pop" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  try {
    result = std_vector_Sl_Pythia8_Vec4_Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  resultobj = SWIG_NewPointerObj((new std::vector< Pythia8::Vec4 >::value_type(static_cast< const std::vector< Pythia8::Vec4 >::value_type& >(result))), SWIGTYPE_p_Pythia8__Vec4, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  std::vector< Pythia8::Vec4 >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVec4_append",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4_append" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVec4_append" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVec4_append" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::Vec4 >::value_type * >(argp2);
  std_vector_Sl_Pythia8_Vec4_Sg__append(arg1,(Pythia8::Vec4 const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorVec4__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)":new_VectorVec4")) SWIG_fail;
  result = (std::vector< Pythia8::Vec4 > *)new std::vector< Pythia8::Vec4 >();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorVec4__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::Vec4 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorVec4",&obj0)) SWIG_fail;
  {
    std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > *ptr = (std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > *)0;
    res1 = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorVec4" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorVec4" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::vector< Pythia8::Vec4 > *)new std::vector< Pythia8::Vec4 >((std::vector< Pythia8::Vec4 > const &)*arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  bool result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVec4_empty",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4_empty" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  result = (bool)((std::vector< Pythia8::Vec4 > const *)arg1)->empty();
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::Vec4 >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVec4_size",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4_size" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  result = ((std::vector< Pythia8::Vec4 > const *)arg1)->size();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  std::vector< Pythia8::Vec4 > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVec4_swap",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4_swap" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVec4_swap" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVec4_swap" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp2);
  (arg1)->swap(*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::Vec4 >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVec4_begin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4_begin" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  result = (arg1)->begin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::Vec4 >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::Vec4 >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVec4_end",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4_end" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  result = (arg1)->end();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::Vec4 >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::Vec4 >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVec4_rbegin",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4_rbegin" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  result = (arg1)->rbegin();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::Vec4 >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::Vec4 >::reverse_iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVec4_rend",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4_rend" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  result = (arg1)->rend();
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::Vec4 >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVec4_clear",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4_clear" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  (arg1)->clear();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  SwigValueWrapper< std::allocator< Pythia8::Vec4 > > result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVec4_get_allocator",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4_get_allocator" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  result = ((std::vector< Pythia8::Vec4 > const *)arg1)->get_allocator();
  resultobj = SWIG_NewPointerObj((new std::vector< Pythia8::Vec4 >::allocator_type(static_cast< const std::vector< Pythia8::Vec4 >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_Pythia8__Vec4_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorVec4__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::Vec4 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:new_VectorVec4",&obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorVec4" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 >::size_type""'");
  } 
  arg1 = static_cast< std::vector< Pythia8::Vec4 >::size_type >(val1);
  result = (std::vector< Pythia8::Vec4 > *)new std::vector< Pythia8::Vec4 >(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVec4_pop_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4_pop_back" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  (arg1)->pop_back();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  std::vector< Pythia8::Vec4 >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVec4_resize",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4_resize" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVec4_resize" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::Vec4 >::size_type >(val2);
  (arg1)->resize(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  std::vector< Pythia8::Vec4 >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< Pythia8::Vec4 >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVec4_erase",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4_erase" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVec4_erase" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::Vec4 >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::Vec4 >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVec4_erase" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 >::iterator""'");
    }
  }
  result = std_vector_Sl_Pythia8_Vec4_Sg__erase__SWIG_0(arg1,arg2);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::Vec4 >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  std::vector< Pythia8::Vec4 >::iterator arg2 ;
  std::vector< Pythia8::Vec4 >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< Pythia8::Vec4 >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVec4_erase",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4_erase" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVec4_erase" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::Vec4 >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::Vec4 >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVec4_erase" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVec4_erase" "', argument " "3"" of type '" "std::vector< Pythia8::Vec4 >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::Vec4 >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::Vec4 >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVec4_erase" "', argument " "3"" of type '" "std::vector< Pythia8::Vec4 >::iterator""'");
    }
  }
  result = std_vector_Sl_Pythia8_Vec4_Sg__erase__SWIG_1(arg1,arg2,arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::Vec4 >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::Vec4 >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_VectorVec4_erase__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::Vec4 >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::Vec4 >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_VectorVec4_erase__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVec4_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::Vec4 >::erase(std::vector< Pythia8::Vec4 >::iterator)\n"
    "    std::vector< Pythia8::Vec4 >::erase(std::vector< Pythia8::Vec4 >::iterator,std::vector< Pythia8::Vec4 >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_VectorVec4__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 >::size_type arg1 ;
  std::vector< Pythia8::Vec4 >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  std::vector< Pythia8::Vec4 > *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorVec4",&obj0,&obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorVec4" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 >::size_type""'");
  } 
  arg1 = static_cast< std::vector< Pythia8::Vec4 >::size_type >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorVec4" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorVec4" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::Vec4 >::value_type * >(argp2);
  result = (std::vector< Pythia8::Vec4 > *)new std::vector< Pythia8::Vec4 >(arg1,(std::vector< Pythia8::Vec4 >::value_type const &)*arg2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_VectorVec4(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 0) {
    return _wrap_new_VectorVec4__SWIG_0(self, args);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_VectorVec4__SWIG_2(self, args);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VectorVec4__SWIG_1(self, args);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_VectorVec4__SWIG_3(self, args);
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorVec4'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::Vec4 >::vector()\n"
    "    std::vector< Pythia8::Vec4 >::vector(std::vector< Pythia8::Vec4 > const &)\n"
    "    std::vector< Pythia8::Vec4 >::vector(std::vector< Pythia8::Vec4 >::size_type)\n"
    "    std::vector< Pythia8::Vec4 >::vector(std::vector< Pythia8::Vec4 >::size_type,std::vector< Pythia8::Vec4 >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorVec4_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  std::vector< Pythia8::Vec4 >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVec4_push_back",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4_push_back" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVec4_push_back" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVec4_push_back" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< Pythia8::Vec4 >::value_type * >(argp2);
  (arg1)->push_back((std::vector< Pythia8::Vec4 >::value_type const &)*arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::Vec4 >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVec4_front",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4_front" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  result = (std::vector< Pythia8::Vec4 >::value_type *) &((std::vector< Pythia8::Vec4 > const *)arg1)->front();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::Vec4 >::value_type *result = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVec4_back",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4_back" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  result = (std::vector< Pythia8::Vec4 >::value_type *) &((std::vector< Pythia8::Vec4 > const *)arg1)->back();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pythia8__Vec4, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  std::vector< Pythia8::Vec4 >::size_type arg2 ;
  std::vector< Pythia8::Vec4 >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVec4_assign",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4_assign" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVec4_assign" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::Vec4 >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVec4_assign" "', argument " "3"" of type '" "std::vector< Pythia8::Vec4 >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVec4_assign" "', argument " "3"" of type '" "std::vector< Pythia8::Vec4 >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::Vec4 >::value_type * >(argp3);
  (arg1)->assign(arg2,(std::vector< Pythia8::Vec4 >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  std::vector< Pythia8::Vec4 >::size_type arg2 ;
  std::vector< Pythia8::Vec4 >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVec4_resize",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4_resize" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVec4_resize" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::Vec4 >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVec4_resize" "', argument " "3"" of type '" "std::vector< Pythia8::Vec4 >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVec4_resize" "', argument " "3"" of type '" "std::vector< Pythia8::Vec4 >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::Vec4 >::value_type * >(argp3);
  (arg1)->resize(arg2,(std::vector< Pythia8::Vec4 >::value_type const &)*arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorVec4_resize__SWIG_0(self, args);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorVec4_resize__SWIG_1(self, args);
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVec4_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::Vec4 >::resize(std::vector< Pythia8::Vec4 >::size_type)\n"
    "    std::vector< Pythia8::Vec4 >::resize(std::vector< Pythia8::Vec4 >::size_type,std::vector< Pythia8::Vec4 >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorVec4_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  std::vector< Pythia8::Vec4 >::iterator arg2 ;
  std::vector< Pythia8::Vec4 >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  std::vector< Pythia8::Vec4 >::iterator result;
  
  if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVec4_insert",&obj0,&obj1,&obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4_insert" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVec4_insert" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::Vec4 >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::Vec4 >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVec4_insert" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVec4_insert" "', argument " "3"" of type '" "std::vector< Pythia8::Vec4 >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVec4_insert" "', argument " "3"" of type '" "std::vector< Pythia8::Vec4 >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< Pythia8::Vec4 >::value_type * >(argp3);
  result = std_vector_Sl_Pythia8_Vec4_Sg__insert__SWIG_0(arg1,arg2,(Pythia8::Vec4 const &)*arg3);
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Pythia8::Vec4 >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  std::vector< Pythia8::Vec4 >::iterator arg2 ;
  std::vector< Pythia8::Vec4 >::size_type arg3 ;
  std::vector< Pythia8::Vec4 >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorVec4_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4_insert" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVec4_insert" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< Pythia8::Vec4 >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::Vec4 >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVec4_insert" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVec4_insert" "', argument " "3"" of type '" "std::vector< Pythia8::Vec4 >::size_type""'");
  } 
  arg3 = static_cast< std::vector< Pythia8::Vec4 >::size_type >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_Pythia8__Vec4,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorVec4_insert" "', argument " "4"" of type '" "std::vector< Pythia8::Vec4 >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVec4_insert" "', argument " "4"" of type '" "std::vector< Pythia8::Vec4 >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< Pythia8::Vec4 >::value_type * >(argp4);
  std_vector_Sl_Pythia8_Vec4_Sg__insert__SWIG_1(arg1,arg2,arg3,(Pythia8::Vec4 const &)*arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  Py_ssize_t ii;
  
  if (!PyTuple_Check(args)) SWIG_fail;
  argc = args ? PyObject_Length(args) : 0;
  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
    argv[ii] = PyTuple_GET_ITEM(args,ii);
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::Vec4 >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VectorVec4_insert__SWIG_0(self, args);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Pythia8::Vec4 >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_Pythia8__Vec4, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VectorVec4_insert__SWIG_1(self, args);
          }
        }
      }
    }
  }
  
fail:
  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVec4_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< Pythia8::Vec4 >::insert(std::vector< Pythia8::Vec4 >::iterator,std::vector< Pythia8::Vec4 >::value_type const &)\n"
    "    std::vector< Pythia8::Vec4 >::insert(std::vector< Pythia8::Vec4 >::iterator,std::vector< Pythia8::Vec4 >::size_type,std::vector< Pythia8::Vec4 >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_VectorVec4_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  std::vector< Pythia8::Vec4 >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"OO:VectorVec4_reserve",&obj0,&obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4_reserve" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVec4_reserve" "', argument " "2"" of type '" "std::vector< Pythia8::Vec4 >::size_type""'");
  } 
  arg2 = static_cast< std::vector< Pythia8::Vec4 >::size_type >(val2);
  (arg1)->reserve(arg2);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_VectorVec4_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  std::vector< Pythia8::Vec4 >::size_type result;
  
  if (!PyArg_ParseTuple(args,(char *)"O:VectorVec4_capacity",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVec4_capacity" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  result = ((std::vector< Pythia8::Vec4 > const *)arg1)->capacity();
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_VectorVec4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< Pythia8::Vec4 > *arg1 = (std::vector< Pythia8::Vec4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  
  if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorVec4",&obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorVec4" "', argument " "1"" of type '" "std::vector< Pythia8::Vec4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< Pythia8::Vec4 > * >(argp1);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *VectorVec4_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

static PyMethodDef SwigMethods[] = {
	 { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
	 { (char *)"delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator_copy", _wrap_SwigPyIterator_copy, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator_next", _wrap_SwigPyIterator_next, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator___next__", _wrap_SwigPyIterator___next__, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator_previous", _wrap_SwigPyIterator_previous, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, NULL},
	 { (char *)"SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_VARARGS, NULL},
	 { (char *)"ios_base_register_callback", _wrap_ios_base_register_callback, METH_VARARGS, NULL},
	 { (char *)"ios_base_flags", _wrap_ios_base_flags, METH_VARARGS, NULL},
	 { (char *)"ios_base_setf", _wrap_ios_base_setf, METH_VARARGS, NULL},
	 { (char *)"ios_base_unsetf", _wrap_ios_base_unsetf, METH_VARARGS, NULL},
	 { (char *)"ios_base_precision", _wrap_ios_base_precision, METH_VARARGS, NULL},
	 { (char *)"ios_base_width", _wrap_ios_base_width, METH_VARARGS, NULL},
	 { (char *)"ios_base_sync_with_stdio", _wrap_ios_base_sync_with_stdio, METH_VARARGS, NULL},
	 { (char *)"ios_base_imbue", _wrap_ios_base_imbue, METH_VARARGS, NULL},
	 { (char *)"ios_base_getloc", _wrap_ios_base_getloc, METH_VARARGS, NULL},
	 { (char *)"ios_base_xalloc", _wrap_ios_base_xalloc, METH_VARARGS, NULL},
	 { (char *)"ios_base_iword", _wrap_ios_base_iword, METH_VARARGS, NULL},
	 { (char *)"ios_base_pword", _wrap_ios_base_pword, METH_VARARGS, NULL},
	 { (char *)"delete_ios_base", _wrap_delete_ios_base, METH_VARARGS, NULL},
	 { (char *)"ios_base_swigregister", ios_base_swigregister, METH_VARARGS, NULL},
	 { (char *)"ios_rdstate", _wrap_ios_rdstate, METH_VARARGS, NULL},
	 { (char *)"ios_clear", _wrap_ios_clear, METH_VARARGS, NULL},
	 { (char *)"ios_setstate", _wrap_ios_setstate, METH_VARARGS, NULL},
	 { (char *)"ios_good", _wrap_ios_good, METH_VARARGS, NULL},
	 { (char *)"ios_eof", _wrap_ios_eof, METH_VARARGS, NULL},
	 { (char *)"ios_fail", _wrap_ios_fail, METH_VARARGS, NULL},
	 { (char *)"ios_bad", _wrap_ios_bad, METH_VARARGS, NULL},
	 { (char *)"ios_exceptions", _wrap_ios_exceptions, METH_VARARGS, NULL},
	 { (char *)"new_ios", _wrap_new_ios, METH_VARARGS, NULL},
	 { (char *)"delete_ios", _wrap_delete_ios, METH_VARARGS, NULL},
	 { (char *)"ios_tie", _wrap_ios_tie, METH_VARARGS, NULL},
	 { (char *)"ios_rdbuf", _wrap_ios_rdbuf, METH_VARARGS, NULL},
	 { (char *)"ios_copyfmt", _wrap_ios_copyfmt, METH_VARARGS, NULL},
	 { (char *)"ios_fill", _wrap_ios_fill, METH_VARARGS, NULL},
	 { (char *)"ios_imbue", _wrap_ios_imbue, METH_VARARGS, NULL},
	 { (char *)"ios_narrow", _wrap_ios_narrow, METH_VARARGS, NULL},
	 { (char *)"ios_widen", _wrap_ios_widen, METH_VARARGS, NULL},
	 { (char *)"ios_swigregister", ios_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ostream", _wrap_new_ostream, METH_VARARGS, NULL},
	 { (char *)"delete_ostream", _wrap_delete_ostream, METH_VARARGS, NULL},
	 { (char *)"ostream___lshift__", _wrap_ostream___lshift__, METH_VARARGS, NULL},
	 { (char *)"ostream_put", _wrap_ostream_put, METH_VARARGS, NULL},
	 { (char *)"ostream_write", _wrap_ostream_write, METH_VARARGS, NULL},
	 { (char *)"ostream_flush", _wrap_ostream_flush, METH_VARARGS, NULL},
	 { (char *)"ostream_tellp", _wrap_ostream_tellp, METH_VARARGS, NULL},
	 { (char *)"ostream_seekp", _wrap_ostream_seekp, METH_VARARGS, NULL},
	 { (char *)"ostream_swigregister", ostream_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_istream", _wrap_new_istream, METH_VARARGS, NULL},
	 { (char *)"delete_istream", _wrap_delete_istream, METH_VARARGS, NULL},
	 { (char *)"istream___rshift__", _wrap_istream___rshift__, METH_VARARGS, NULL},
	 { (char *)"istream_gcount", _wrap_istream_gcount, METH_VARARGS, NULL},
	 { (char *)"istream_get", _wrap_istream_get, METH_VARARGS, NULL},
	 { (char *)"istream_getline", _wrap_istream_getline, METH_VARARGS, NULL},
	 { (char *)"istream_ignore", _wrap_istream_ignore, METH_VARARGS, NULL},
	 { (char *)"istream_peek", _wrap_istream_peek, METH_VARARGS, NULL},
	 { (char *)"istream_read", _wrap_istream_read, METH_VARARGS, NULL},
	 { (char *)"istream_readsome", _wrap_istream_readsome, METH_VARARGS, NULL},
	 { (char *)"istream_putback", _wrap_istream_putback, METH_VARARGS, NULL},
	 { (char *)"istream_unget", _wrap_istream_unget, METH_VARARGS, NULL},
	 { (char *)"istream_sync", _wrap_istream_sync, METH_VARARGS, NULL},
	 { (char *)"istream_tellg", _wrap_istream_tellg, METH_VARARGS, NULL},
	 { (char *)"istream_seekg", _wrap_istream_seekg, METH_VARARGS, NULL},
	 { (char *)"istream_swigregister", istream_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_iostream", _wrap_new_iostream, METH_VARARGS, NULL},
	 { (char *)"delete_iostream", _wrap_delete_iostream, METH_VARARGS, NULL},
	 { (char *)"iostream_swigregister", iostream_swigregister, METH_VARARGS, NULL},
	 { (char *)"endl_cb_ptr_swigconstant", endl_cb_ptr_swigconstant, METH_VARARGS, NULL},
	 { (char *)"endl", _wrap_endl, METH_VARARGS, (char *)"swig_ptr: endl_cb_ptr"},
	 { (char *)"ends_cb_ptr_swigconstant", ends_cb_ptr_swigconstant, METH_VARARGS, NULL},
	 { (char *)"ends", _wrap_ends, METH_VARARGS, (char *)"swig_ptr: ends_cb_ptr"},
	 { (char *)"flush_cb_ptr_swigconstant", flush_cb_ptr_swigconstant, METH_VARARGS, NULL},
	 { (char *)"flush", _wrap_flush, METH_VARARGS, (char *)"swig_ptr: flush_cb_ptr"},
	 { (char *)"delete_streambuf", _wrap_delete_streambuf, METH_VARARGS, NULL},
	 { (char *)"streambuf_pubimbue", _wrap_streambuf_pubimbue, METH_VARARGS, NULL},
	 { (char *)"streambuf_getloc", _wrap_streambuf_getloc, METH_VARARGS, NULL},
	 { (char *)"streambuf_pubsetbuf", _wrap_streambuf_pubsetbuf, METH_VARARGS, NULL},
	 { (char *)"streambuf_pubseekoff", _wrap_streambuf_pubseekoff, METH_VARARGS, NULL},
	 { (char *)"streambuf_pubseekpos", _wrap_streambuf_pubseekpos, METH_VARARGS, NULL},
	 { (char *)"streambuf_pubsync", _wrap_streambuf_pubsync, METH_VARARGS, NULL},
	 { (char *)"streambuf_in_avail", _wrap_streambuf_in_avail, METH_VARARGS, NULL},
	 { (char *)"streambuf_snextc", _wrap_streambuf_snextc, METH_VARARGS, NULL},
	 { (char *)"streambuf_sbumpc", _wrap_streambuf_sbumpc, METH_VARARGS, NULL},
	 { (char *)"streambuf_sgetc", _wrap_streambuf_sgetc, METH_VARARGS, NULL},
	 { (char *)"streambuf_sgetn", _wrap_streambuf_sgetn, METH_VARARGS, NULL},
	 { (char *)"streambuf_sputbackc", _wrap_streambuf_sputbackc, METH_VARARGS, NULL},
	 { (char *)"streambuf_sungetc", _wrap_streambuf_sungetc, METH_VARARGS, NULL},
	 { (char *)"streambuf_sputc", _wrap_streambuf_sputc, METH_VARARGS, NULL},
	 { (char *)"streambuf_sputn", _wrap_streambuf_sputn, METH_VARARGS, NULL},
	 { (char *)"streambuf_swigregister", streambuf_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_istringstream", _wrap_new_istringstream, METH_VARARGS, NULL},
	 { (char *)"delete_istringstream", _wrap_delete_istringstream, METH_VARARGS, NULL},
	 { (char *)"istringstream_rdbuf", _wrap_istringstream_rdbuf, METH_VARARGS, NULL},
	 { (char *)"istringstream_str", _wrap_istringstream_str, METH_VARARGS, NULL},
	 { (char *)"istringstream_swigregister", istringstream_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ostringstream", _wrap_new_ostringstream, METH_VARARGS, NULL},
	 { (char *)"delete_ostringstream", _wrap_delete_ostringstream, METH_VARARGS, NULL},
	 { (char *)"ostringstream_rdbuf", _wrap_ostringstream_rdbuf, METH_VARARGS, NULL},
	 { (char *)"ostringstream_str", _wrap_ostringstream_str, METH_VARARGS, NULL},
	 { (char *)"ostringstream_swigregister", ostringstream_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_stringstream", _wrap_new_stringstream, METH_VARARGS, NULL},
	 { (char *)"delete_stringstream", _wrap_delete_stringstream, METH_VARARGS, NULL},
	 { (char *)"stringstream_rdbuf", _wrap_stringstream_rdbuf, METH_VARARGS, NULL},
	 { (char *)"stringstream_str", _wrap_stringstream_str, METH_VARARGS, NULL},
	 { (char *)"stringstream_swigregister", stringstream_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PairIntInt", _wrap_new_PairIntInt, METH_VARARGS, NULL},
	 { (char *)"PairIntInt_first_set", _wrap_PairIntInt_first_set, METH_VARARGS, NULL},
	 { (char *)"PairIntInt_first_get", _wrap_PairIntInt_first_get, METH_VARARGS, NULL},
	 { (char *)"PairIntInt_second_set", _wrap_PairIntInt_second_set, METH_VARARGS, NULL},
	 { (char *)"PairIntInt_second_get", _wrap_PairIntInt_second_get, METH_VARARGS, NULL},
	 { (char *)"delete_PairIntInt", _wrap_delete_PairIntInt, METH_VARARGS, NULL},
	 { (char *)"PairIntInt_swigregister", PairIntInt_swigregister, METH_VARARGS, NULL},
	 { (char *)"MapIntInt_iterator", _wrap_MapIntInt_iterator, METH_VARARGS, NULL},
	 { (char *)"MapIntInt___nonzero__", _wrap_MapIntInt___nonzero__, METH_VARARGS, NULL},
	 { (char *)"MapIntInt___bool__", _wrap_MapIntInt___bool__, METH_VARARGS, NULL},
	 { (char *)"MapIntInt___len__", _wrap_MapIntInt___len__, METH_VARARGS, NULL},
	 { (char *)"MapIntInt___getitem__", _wrap_MapIntInt___getitem__, METH_VARARGS, NULL},
	 { (char *)"MapIntInt___delitem__", _wrap_MapIntInt___delitem__, METH_VARARGS, NULL},
	 { (char *)"MapIntInt_has_key", _wrap_MapIntInt_has_key, METH_VARARGS, NULL},
	 { (char *)"MapIntInt_keys", _wrap_MapIntInt_keys, METH_VARARGS, NULL},
	 { (char *)"MapIntInt_values", _wrap_MapIntInt_values, METH_VARARGS, NULL},
	 { (char *)"MapIntInt_items", _wrap_MapIntInt_items, METH_VARARGS, NULL},
	 { (char *)"MapIntInt___contains__", _wrap_MapIntInt___contains__, METH_VARARGS, NULL},
	 { (char *)"MapIntInt_key_iterator", _wrap_MapIntInt_key_iterator, METH_VARARGS, NULL},
	 { (char *)"MapIntInt_value_iterator", _wrap_MapIntInt_value_iterator, METH_VARARGS, NULL},
	 { (char *)"MapIntInt___setitem__", _wrap_MapIntInt___setitem__, METH_VARARGS, NULL},
	 { (char *)"MapIntInt_asdict", _wrap_MapIntInt_asdict, METH_VARARGS, NULL},
	 { (char *)"new_MapIntInt", _wrap_new_MapIntInt, METH_VARARGS, NULL},
	 { (char *)"MapIntInt_empty", _wrap_MapIntInt_empty, METH_VARARGS, NULL},
	 { (char *)"MapIntInt_size", _wrap_MapIntInt_size, METH_VARARGS, NULL},
	 { (char *)"MapIntInt_swap", _wrap_MapIntInt_swap, METH_VARARGS, NULL},
	 { (char *)"MapIntInt_begin", _wrap_MapIntInt_begin, METH_VARARGS, NULL},
	 { (char *)"MapIntInt_end", _wrap_MapIntInt_end, METH_VARARGS, NULL},
	 { (char *)"MapIntInt_rbegin", _wrap_MapIntInt_rbegin, METH_VARARGS, NULL},
	 { (char *)"MapIntInt_rend", _wrap_MapIntInt_rend, METH_VARARGS, NULL},
	 { (char *)"MapIntInt_clear", _wrap_MapIntInt_clear, METH_VARARGS, NULL},
	 { (char *)"MapIntInt_get_allocator", _wrap_MapIntInt_get_allocator, METH_VARARGS, NULL},
	 { (char *)"MapIntInt_count", _wrap_MapIntInt_count, METH_VARARGS, NULL},
	 { (char *)"MapIntInt_erase", _wrap_MapIntInt_erase, METH_VARARGS, NULL},
	 { (char *)"MapIntInt_find", _wrap_MapIntInt_find, METH_VARARGS, NULL},
	 { (char *)"MapIntInt_lower_bound", _wrap_MapIntInt_lower_bound, METH_VARARGS, NULL},
	 { (char *)"MapIntInt_upper_bound", _wrap_MapIntInt_upper_bound, METH_VARARGS, NULL},
	 { (char *)"delete_MapIntInt", _wrap_delete_MapIntInt, METH_VARARGS, NULL},
	 { (char *)"MapIntInt_swigregister", MapIntInt_swigregister, METH_VARARGS, NULL},
	 { (char *)"MapStringString_iterator", _wrap_MapStringString_iterator, METH_VARARGS, NULL},
	 { (char *)"MapStringString___nonzero__", _wrap_MapStringString___nonzero__, METH_VARARGS, NULL},
	 { (char *)"MapStringString___bool__", _wrap_MapStringString___bool__, METH_VARARGS, NULL},
	 { (char *)"MapStringString___len__", _wrap_MapStringString___len__, METH_VARARGS, NULL},
	 { (char *)"MapStringString___getitem__", _wrap_MapStringString___getitem__, METH_VARARGS, NULL},
	 { (char *)"MapStringString___delitem__", _wrap_MapStringString___delitem__, METH_VARARGS, NULL},
	 { (char *)"MapStringString_has_key", _wrap_MapStringString_has_key, METH_VARARGS, NULL},
	 { (char *)"MapStringString_keys", _wrap_MapStringString_keys, METH_VARARGS, NULL},
	 { (char *)"MapStringString_values", _wrap_MapStringString_values, METH_VARARGS, NULL},
	 { (char *)"MapStringString_items", _wrap_MapStringString_items, METH_VARARGS, NULL},
	 { (char *)"MapStringString___contains__", _wrap_MapStringString___contains__, METH_VARARGS, NULL},
	 { (char *)"MapStringString_key_iterator", _wrap_MapStringString_key_iterator, METH_VARARGS, NULL},
	 { (char *)"MapStringString_value_iterator", _wrap_MapStringString_value_iterator, METH_VARARGS, NULL},
	 { (char *)"MapStringString___setitem__", _wrap_MapStringString___setitem__, METH_VARARGS, NULL},
	 { (char *)"MapStringString_asdict", _wrap_MapStringString_asdict, METH_VARARGS, NULL},
	 { (char *)"new_MapStringString", _wrap_new_MapStringString, METH_VARARGS, NULL},
	 { (char *)"MapStringString_empty", _wrap_MapStringString_empty, METH_VARARGS, NULL},
	 { (char *)"MapStringString_size", _wrap_MapStringString_size, METH_VARARGS, NULL},
	 { (char *)"MapStringString_swap", _wrap_MapStringString_swap, METH_VARARGS, NULL},
	 { (char *)"MapStringString_begin", _wrap_MapStringString_begin, METH_VARARGS, NULL},
	 { (char *)"MapStringString_end", _wrap_MapStringString_end, METH_VARARGS, NULL},
	 { (char *)"MapStringString_rbegin", _wrap_MapStringString_rbegin, METH_VARARGS, NULL},
	 { (char *)"MapStringString_rend", _wrap_MapStringString_rend, METH_VARARGS, NULL},
	 { (char *)"MapStringString_clear", _wrap_MapStringString_clear, METH_VARARGS, NULL},
	 { (char *)"MapStringString_get_allocator", _wrap_MapStringString_get_allocator, METH_VARARGS, NULL},
	 { (char *)"MapStringString_count", _wrap_MapStringString_count, METH_VARARGS, NULL},
	 { (char *)"MapStringString_erase", _wrap_MapStringString_erase, METH_VARARGS, NULL},
	 { (char *)"MapStringString_find", _wrap_MapStringString_find, METH_VARARGS, NULL},
	 { (char *)"MapStringString_lower_bound", _wrap_MapStringString_lower_bound, METH_VARARGS, NULL},
	 { (char *)"MapStringString_upper_bound", _wrap_MapStringString_upper_bound, METH_VARARGS, NULL},
	 { (char *)"delete_MapStringString", _wrap_delete_MapStringString, METH_VARARGS, NULL},
	 { (char *)"MapStringString_swigregister", MapStringString_swigregister, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt_iterator", _wrap_MapDoublePairIntInt_iterator, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt___nonzero__", _wrap_MapDoublePairIntInt___nonzero__, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt___bool__", _wrap_MapDoublePairIntInt___bool__, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt___len__", _wrap_MapDoublePairIntInt___len__, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt___getitem__", _wrap_MapDoublePairIntInt___getitem__, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt___delitem__", _wrap_MapDoublePairIntInt___delitem__, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt_has_key", _wrap_MapDoublePairIntInt_has_key, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt_keys", _wrap_MapDoublePairIntInt_keys, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt_values", _wrap_MapDoublePairIntInt_values, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt_items", _wrap_MapDoublePairIntInt_items, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt___contains__", _wrap_MapDoublePairIntInt___contains__, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt_key_iterator", _wrap_MapDoublePairIntInt_key_iterator, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt_value_iterator", _wrap_MapDoublePairIntInt_value_iterator, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt___setitem__", _wrap_MapDoublePairIntInt___setitem__, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt_asdict", _wrap_MapDoublePairIntInt_asdict, METH_VARARGS, NULL},
	 { (char *)"new_MapDoublePairIntInt", _wrap_new_MapDoublePairIntInt, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt_empty", _wrap_MapDoublePairIntInt_empty, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt_size", _wrap_MapDoublePairIntInt_size, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt_swap", _wrap_MapDoublePairIntInt_swap, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt_begin", _wrap_MapDoublePairIntInt_begin, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt_end", _wrap_MapDoublePairIntInt_end, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt_rbegin", _wrap_MapDoublePairIntInt_rbegin, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt_rend", _wrap_MapDoublePairIntInt_rend, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt_clear", _wrap_MapDoublePairIntInt_clear, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt_get_allocator", _wrap_MapDoublePairIntInt_get_allocator, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt_count", _wrap_MapDoublePairIntInt_count, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt_erase", _wrap_MapDoublePairIntInt_erase, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt_find", _wrap_MapDoublePairIntInt_find, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt_lower_bound", _wrap_MapDoublePairIntInt_lower_bound, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt_upper_bound", _wrap_MapDoublePairIntInt_upper_bound, METH_VARARGS, NULL},
	 { (char *)"delete_MapDoublePairIntInt", _wrap_delete_MapDoublePairIntInt, METH_VARARGS, NULL},
	 { (char *)"MapDoublePairIntInt_swigregister", MapDoublePairIntInt_swigregister, METH_VARARGS, NULL},
	 { (char *)"VectorBool_iterator", _wrap_VectorBool_iterator, METH_VARARGS, NULL},
	 { (char *)"VectorBool___nonzero__", _wrap_VectorBool___nonzero__, METH_VARARGS, NULL},
	 { (char *)"VectorBool___bool__", _wrap_VectorBool___bool__, METH_VARARGS, NULL},
	 { (char *)"VectorBool___len__", _wrap_VectorBool___len__, METH_VARARGS, NULL},
	 { (char *)"VectorBool___getslice__", _wrap_VectorBool___getslice__, METH_VARARGS, NULL},
	 { (char *)"VectorBool___setslice__", _wrap_VectorBool___setslice__, METH_VARARGS, NULL},
	 { (char *)"VectorBool___delslice__", _wrap_VectorBool___delslice__, METH_VARARGS, NULL},
	 { (char *)"VectorBool___delitem__", _wrap_VectorBool___delitem__, METH_VARARGS, NULL},
	 { (char *)"VectorBool___getitem__", _wrap_VectorBool___getitem__, METH_VARARGS, NULL},
	 { (char *)"VectorBool___setitem__", _wrap_VectorBool___setitem__, METH_VARARGS, NULL},
	 { (char *)"VectorBool_pop", _wrap_VectorBool_pop, METH_VARARGS, NULL},
	 { (char *)"VectorBool_append", _wrap_VectorBool_append, METH_VARARGS, NULL},
	 { (char *)"VectorBool_empty", _wrap_VectorBool_empty, METH_VARARGS, NULL},
	 { (char *)"VectorBool_size", _wrap_VectorBool_size, METH_VARARGS, NULL},
	 { (char *)"VectorBool_swap", _wrap_VectorBool_swap, METH_VARARGS, NULL},
	 { (char *)"VectorBool_begin", _wrap_VectorBool_begin, METH_VARARGS, NULL},
	 { (char *)"VectorBool_end", _wrap_VectorBool_end, METH_VARARGS, NULL},
	 { (char *)"VectorBool_rbegin", _wrap_VectorBool_rbegin, METH_VARARGS, NULL},
	 { (char *)"VectorBool_rend", _wrap_VectorBool_rend, METH_VARARGS, NULL},
	 { (char *)"VectorBool_clear", _wrap_VectorBool_clear, METH_VARARGS, NULL},
	 { (char *)"VectorBool_get_allocator", _wrap_VectorBool_get_allocator, METH_VARARGS, NULL},
	 { (char *)"VectorBool_pop_back", _wrap_VectorBool_pop_back, METH_VARARGS, NULL},
	 { (char *)"VectorBool_erase", _wrap_VectorBool_erase, METH_VARARGS, NULL},
	 { (char *)"new_VectorBool", _wrap_new_VectorBool, METH_VARARGS, NULL},
	 { (char *)"VectorBool_push_back", _wrap_VectorBool_push_back, METH_VARARGS, NULL},
	 { (char *)"VectorBool_front", _wrap_VectorBool_front, METH_VARARGS, NULL},
	 { (char *)"VectorBool_back", _wrap_VectorBool_back, METH_VARARGS, NULL},
	 { (char *)"VectorBool_assign", _wrap_VectorBool_assign, METH_VARARGS, NULL},
	 { (char *)"VectorBool_resize", _wrap_VectorBool_resize, METH_VARARGS, NULL},
	 { (char *)"VectorBool_insert", _wrap_VectorBool_insert, METH_VARARGS, NULL},
	 { (char *)"VectorBool_reserve", _wrap_VectorBool_reserve, METH_VARARGS, NULL},
	 { (char *)"VectorBool_capacity", _wrap_VectorBool_capacity, METH_VARARGS, NULL},
	 { (char *)"delete_VectorBool", _wrap_delete_VectorBool, METH_VARARGS, NULL},
	 { (char *)"VectorBool_swigregister", VectorBool_swigregister, METH_VARARGS, NULL},
	 { (char *)"VectorComplex_iterator", _wrap_VectorComplex_iterator, METH_VARARGS, NULL},
	 { (char *)"VectorComplex___nonzero__", _wrap_VectorComplex___nonzero__, METH_VARARGS, NULL},
	 { (char *)"VectorComplex___bool__", _wrap_VectorComplex___bool__, METH_VARARGS, NULL},
	 { (char *)"VectorComplex___len__", _wrap_VectorComplex___len__, METH_VARARGS, NULL},
	 { (char *)"VectorComplex___getslice__", _wrap_VectorComplex___getslice__, METH_VARARGS, NULL},
	 { (char *)"VectorComplex___setslice__", _wrap_VectorComplex___setslice__, METH_VARARGS, NULL},
	 { (char *)"VectorComplex___delslice__", _wrap_VectorComplex___delslice__, METH_VARARGS, NULL},
	 { (char *)"VectorComplex___delitem__", _wrap_VectorComplex___delitem__, METH_VARARGS, NULL},
	 { (char *)"VectorComplex___getitem__", _wrap_VectorComplex___getitem__, METH_VARARGS, NULL},
	 { (char *)"VectorComplex___setitem__", _wrap_VectorComplex___setitem__, METH_VARARGS, NULL},
	 { (char *)"VectorComplex_pop", _wrap_VectorComplex_pop, METH_VARARGS, NULL},
	 { (char *)"VectorComplex_append", _wrap_VectorComplex_append, METH_VARARGS, NULL},
	 { (char *)"VectorComplex_empty", _wrap_VectorComplex_empty, METH_VARARGS, NULL},
	 { (char *)"VectorComplex_size", _wrap_VectorComplex_size, METH_VARARGS, NULL},
	 { (char *)"VectorComplex_swap", _wrap_VectorComplex_swap, METH_VARARGS, NULL},
	 { (char *)"VectorComplex_begin", _wrap_VectorComplex_begin, METH_VARARGS, NULL},
	 { (char *)"VectorComplex_end", _wrap_VectorComplex_end, METH_VARARGS, NULL},
	 { (char *)"VectorComplex_rbegin", _wrap_VectorComplex_rbegin, METH_VARARGS, NULL},
	 { (char *)"VectorComplex_rend", _wrap_VectorComplex_rend, METH_VARARGS, NULL},
	 { (char *)"VectorComplex_clear", _wrap_VectorComplex_clear, METH_VARARGS, NULL},
	 { (char *)"VectorComplex_get_allocator", _wrap_VectorComplex_get_allocator, METH_VARARGS, NULL},
	 { (char *)"VectorComplex_pop_back", _wrap_VectorComplex_pop_back, METH_VARARGS, NULL},
	 { (char *)"VectorComplex_erase", _wrap_VectorComplex_erase, METH_VARARGS, NULL},
	 { (char *)"new_VectorComplex", _wrap_new_VectorComplex, METH_VARARGS, NULL},
	 { (char *)"VectorComplex_push_back", _wrap_VectorComplex_push_back, METH_VARARGS, NULL},
	 { (char *)"VectorComplex_front", _wrap_VectorComplex_front, METH_VARARGS, NULL},
	 { (char *)"VectorComplex_back", _wrap_VectorComplex_back, METH_VARARGS, NULL},
	 { (char *)"VectorComplex_assign", _wrap_VectorComplex_assign, METH_VARARGS, NULL},
	 { (char *)"VectorComplex_resize", _wrap_VectorComplex_resize, METH_VARARGS, NULL},
	 { (char *)"VectorComplex_insert", _wrap_VectorComplex_insert, METH_VARARGS, NULL},
	 { (char *)"VectorComplex_reserve", _wrap_VectorComplex_reserve, METH_VARARGS, NULL},
	 { (char *)"VectorComplex_capacity", _wrap_VectorComplex_capacity, METH_VARARGS, NULL},
	 { (char *)"delete_VectorComplex", _wrap_delete_VectorComplex, METH_VARARGS, NULL},
	 { (char *)"VectorComplex_swigregister", VectorComplex_swigregister, METH_VARARGS, NULL},
	 { (char *)"VectorDouble_iterator", _wrap_VectorDouble_iterator, METH_VARARGS, NULL},
	 { (char *)"VectorDouble___nonzero__", _wrap_VectorDouble___nonzero__, METH_VARARGS, NULL},
	 { (char *)"VectorDouble___bool__", _wrap_VectorDouble___bool__, METH_VARARGS, NULL},
	 { (char *)"VectorDouble___len__", _wrap_VectorDouble___len__, METH_VARARGS, NULL},
	 { (char *)"VectorDouble___getslice__", _wrap_VectorDouble___getslice__, METH_VARARGS, NULL},
	 { (char *)"VectorDouble___setslice__", _wrap_VectorDouble___setslice__, METH_VARARGS, NULL},
	 { (char *)"VectorDouble___delslice__", _wrap_VectorDouble___delslice__, METH_VARARGS, NULL},
	 { (char *)"VectorDouble___delitem__", _wrap_VectorDouble___delitem__, METH_VARARGS, NULL},
	 { (char *)"VectorDouble___getitem__", _wrap_VectorDouble___getitem__, METH_VARARGS, NULL},
	 { (char *)"VectorDouble___setitem__", _wrap_VectorDouble___setitem__, METH_VARARGS, NULL},
	 { (char *)"VectorDouble_pop", _wrap_VectorDouble_pop, METH_VARARGS, NULL},
	 { (char *)"VectorDouble_append", _wrap_VectorDouble_append, METH_VARARGS, NULL},
	 { (char *)"VectorDouble_empty", _wrap_VectorDouble_empty, METH_VARARGS, NULL},
	 { (char *)"VectorDouble_size", _wrap_VectorDouble_size, METH_VARARGS, NULL},
	 { (char *)"VectorDouble_swap", _wrap_VectorDouble_swap, METH_VARARGS, NULL},
	 { (char *)"VectorDouble_begin", _wrap_VectorDouble_begin, METH_VARARGS, NULL},
	 { (char *)"VectorDouble_end", _wrap_VectorDouble_end, METH_VARARGS, NULL},
	 { (char *)"VectorDouble_rbegin", _wrap_VectorDouble_rbegin, METH_VARARGS, NULL},
	 { (char *)"VectorDouble_rend", _wrap_VectorDouble_rend, METH_VARARGS, NULL},
	 { (char *)"VectorDouble_clear", _wrap_VectorDouble_clear, METH_VARARGS, NULL},
	 { (char *)"VectorDouble_get_allocator", _wrap_VectorDouble_get_allocator, METH_VARARGS, NULL},
	 { (char *)"VectorDouble_pop_back", _wrap_VectorDouble_pop_back, METH_VARARGS, NULL},
	 { (char *)"VectorDouble_erase", _wrap_VectorDouble_erase, METH_VARARGS, NULL},
	 { (char *)"new_VectorDouble", _wrap_new_VectorDouble, METH_VARARGS, NULL},
	 { (char *)"VectorDouble_push_back", _wrap_VectorDouble_push_back, METH_VARARGS, NULL},
	 { (char *)"VectorDouble_front", _wrap_VectorDouble_front, METH_VARARGS, NULL},
	 { (char *)"VectorDouble_back", _wrap_VectorDouble_back, METH_VARARGS, NULL},
	 { (char *)"VectorDouble_assign", _wrap_VectorDouble_assign, METH_VARARGS, NULL},
	 { (char *)"VectorDouble_resize", _wrap_VectorDouble_resize, METH_VARARGS, NULL},
	 { (char *)"VectorDouble_insert", _wrap_VectorDouble_insert, METH_VARARGS, NULL},
	 { (char *)"VectorDouble_reserve", _wrap_VectorDouble_reserve, METH_VARARGS, NULL},
	 { (char *)"VectorDouble_capacity", _wrap_VectorDouble_capacity, METH_VARARGS, NULL},
	 { (char *)"delete_VectorDouble", _wrap_delete_VectorDouble, METH_VARARGS, NULL},
	 { (char *)"VectorDouble_swigregister", VectorDouble_swigregister, METH_VARARGS, NULL},
	 { (char *)"VectorInt_iterator", _wrap_VectorInt_iterator, METH_VARARGS, NULL},
	 { (char *)"VectorInt___nonzero__", _wrap_VectorInt___nonzero__, METH_VARARGS, NULL},
	 { (char *)"VectorInt___bool__", _wrap_VectorInt___bool__, METH_VARARGS, NULL},
	 { (char *)"VectorInt___len__", _wrap_VectorInt___len__, METH_VARARGS, NULL},
	 { (char *)"VectorInt___getslice__", _wrap_VectorInt___getslice__, METH_VARARGS, NULL},
	 { (char *)"VectorInt___setslice__", _wrap_VectorInt___setslice__, METH_VARARGS, NULL},
	 { (char *)"VectorInt___delslice__", _wrap_VectorInt___delslice__, METH_VARARGS, NULL},
	 { (char *)"VectorInt___delitem__", _wrap_VectorInt___delitem__, METH_VARARGS, NULL},
	 { (char *)"VectorInt___getitem__", _wrap_VectorInt___getitem__, METH_VARARGS, NULL},
	 { (char *)"VectorInt___setitem__", _wrap_VectorInt___setitem__, METH_VARARGS, NULL},
	 { (char *)"VectorInt_pop", _wrap_VectorInt_pop, METH_VARARGS, NULL},
	 { (char *)"VectorInt_append", _wrap_VectorInt_append, METH_VARARGS, NULL},
	 { (char *)"VectorInt_empty", _wrap_VectorInt_empty, METH_VARARGS, NULL},
	 { (char *)"VectorInt_size", _wrap_VectorInt_size, METH_VARARGS, NULL},
	 { (char *)"VectorInt_swap", _wrap_VectorInt_swap, METH_VARARGS, NULL},
	 { (char *)"VectorInt_begin", _wrap_VectorInt_begin, METH_VARARGS, NULL},
	 { (char *)"VectorInt_end", _wrap_VectorInt_end, METH_VARARGS, NULL},
	 { (char *)"VectorInt_rbegin", _wrap_VectorInt_rbegin, METH_VARARGS, NULL},
	 { (char *)"VectorInt_rend", _wrap_VectorInt_rend, METH_VARARGS, NULL},
	 { (char *)"VectorInt_clear", _wrap_VectorInt_clear, METH_VARARGS, NULL},
	 { (char *)"VectorInt_get_allocator", _wrap_VectorInt_get_allocator, METH_VARARGS, NULL},
	 { (char *)"VectorInt_pop_back", _wrap_VectorInt_pop_back, METH_VARARGS, NULL},
	 { (char *)"VectorInt_erase", _wrap_VectorInt_erase, METH_VARARGS, NULL},
	 { (char *)"new_VectorInt", _wrap_new_VectorInt, METH_VARARGS, NULL},
	 { (char *)"VectorInt_push_back", _wrap_VectorInt_push_back, METH_VARARGS, NULL},
	 { (char *)"VectorInt_front", _wrap_VectorInt_front, METH_VARARGS, NULL},
	 { (char *)"VectorInt_back", _wrap_VectorInt_back, METH_VARARGS, NULL},
	 { (char *)"VectorInt_assign", _wrap_VectorInt_assign, METH_VARARGS, NULL},
	 { (char *)"VectorInt_resize", _wrap_VectorInt_resize, METH_VARARGS, NULL},
	 { (char *)"VectorInt_insert", _wrap_VectorInt_insert, METH_VARARGS, NULL},
	 { (char *)"VectorInt_reserve", _wrap_VectorInt_reserve, METH_VARARGS, NULL},
	 { (char *)"VectorInt_capacity", _wrap_VectorInt_capacity, METH_VARARGS, NULL},
	 { (char *)"delete_VectorInt", _wrap_delete_VectorInt, METH_VARARGS, NULL},
	 { (char *)"VectorInt_swigregister", VectorInt_swigregister, METH_VARARGS, NULL},
	 { (char *)"VectorString_iterator", _wrap_VectorString_iterator, METH_VARARGS, NULL},
	 { (char *)"VectorString___nonzero__", _wrap_VectorString___nonzero__, METH_VARARGS, NULL},
	 { (char *)"VectorString___bool__", _wrap_VectorString___bool__, METH_VARARGS, NULL},
	 { (char *)"VectorString___len__", _wrap_VectorString___len__, METH_VARARGS, NULL},
	 { (char *)"VectorString___getslice__", _wrap_VectorString___getslice__, METH_VARARGS, NULL},
	 { (char *)"VectorString___setslice__", _wrap_VectorString___setslice__, METH_VARARGS, NULL},
	 { (char *)"VectorString___delslice__", _wrap_VectorString___delslice__, METH_VARARGS, NULL},
	 { (char *)"VectorString___delitem__", _wrap_VectorString___delitem__, METH_VARARGS, NULL},
	 { (char *)"VectorString___getitem__", _wrap_VectorString___getitem__, METH_VARARGS, NULL},
	 { (char *)"VectorString___setitem__", _wrap_VectorString___setitem__, METH_VARARGS, NULL},
	 { (char *)"VectorString_pop", _wrap_VectorString_pop, METH_VARARGS, NULL},
	 { (char *)"VectorString_append", _wrap_VectorString_append, METH_VARARGS, NULL},
	 { (char *)"VectorString_empty", _wrap_VectorString_empty, METH_VARARGS, NULL},
	 { (char *)"VectorString_size", _wrap_VectorString_size, METH_VARARGS, NULL},
	 { (char *)"VectorString_swap", _wrap_VectorString_swap, METH_VARARGS, NULL},
	 { (char *)"VectorString_begin", _wrap_VectorString_begin, METH_VARARGS, NULL},
	 { (char *)"VectorString_end", _wrap_VectorString_end, METH_VARARGS, NULL},
	 { (char *)"VectorString_rbegin", _wrap_VectorString_rbegin, METH_VARARGS, NULL},
	 { (char *)"VectorString_rend", _wrap_VectorString_rend, METH_VARARGS, NULL},
	 { (char *)"VectorString_clear", _wrap_VectorString_clear, METH_VARARGS, NULL},
	 { (char *)"VectorString_get_allocator", _wrap_VectorString_get_allocator, METH_VARARGS, NULL},
	 { (char *)"VectorString_pop_back", _wrap_VectorString_pop_back, METH_VARARGS, NULL},
	 { (char *)"VectorString_erase", _wrap_VectorString_erase, METH_VARARGS, NULL},
	 { (char *)"new_VectorString", _wrap_new_VectorString, METH_VARARGS, NULL},
	 { (char *)"VectorString_push_back", _wrap_VectorString_push_back, METH_VARARGS, NULL},
	 { (char *)"VectorString_front", _wrap_VectorString_front, METH_VARARGS, NULL},
	 { (char *)"VectorString_back", _wrap_VectorString_back, METH_VARARGS, NULL},
	 { (char *)"VectorString_assign", _wrap_VectorString_assign, METH_VARARGS, NULL},
	 { (char *)"VectorString_resize", _wrap_VectorString_resize, METH_VARARGS, NULL},
	 { (char *)"VectorString_insert", _wrap_VectorString_insert, METH_VARARGS, NULL},
	 { (char *)"VectorString_reserve", _wrap_VectorString_reserve, METH_VARARGS, NULL},
	 { (char *)"VectorString_capacity", _wrap_VectorString_capacity, METH_VARARGS, NULL},
	 { (char *)"delete_VectorString", _wrap_delete_VectorString, METH_VARARGS, NULL},
	 { (char *)"VectorString_swigregister", VectorString_swigregister, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt_iterator", _wrap_VectorPairIntInt_iterator, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt___nonzero__", _wrap_VectorPairIntInt___nonzero__, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt___bool__", _wrap_VectorPairIntInt___bool__, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt___len__", _wrap_VectorPairIntInt___len__, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt___getslice__", _wrap_VectorPairIntInt___getslice__, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt___setslice__", _wrap_VectorPairIntInt___setslice__, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt___delslice__", _wrap_VectorPairIntInt___delslice__, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt___delitem__", _wrap_VectorPairIntInt___delitem__, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt___getitem__", _wrap_VectorPairIntInt___getitem__, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt___setitem__", _wrap_VectorPairIntInt___setitem__, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt_pop", _wrap_VectorPairIntInt_pop, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt_append", _wrap_VectorPairIntInt_append, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt_empty", _wrap_VectorPairIntInt_empty, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt_size", _wrap_VectorPairIntInt_size, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt_swap", _wrap_VectorPairIntInt_swap, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt_begin", _wrap_VectorPairIntInt_begin, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt_end", _wrap_VectorPairIntInt_end, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt_rbegin", _wrap_VectorPairIntInt_rbegin, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt_rend", _wrap_VectorPairIntInt_rend, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt_clear", _wrap_VectorPairIntInt_clear, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt_get_allocator", _wrap_VectorPairIntInt_get_allocator, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt_pop_back", _wrap_VectorPairIntInt_pop_back, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt_erase", _wrap_VectorPairIntInt_erase, METH_VARARGS, NULL},
	 { (char *)"new_VectorPairIntInt", _wrap_new_VectorPairIntInt, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt_push_back", _wrap_VectorPairIntInt_push_back, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt_front", _wrap_VectorPairIntInt_front, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt_back", _wrap_VectorPairIntInt_back, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt_assign", _wrap_VectorPairIntInt_assign, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt_resize", _wrap_VectorPairIntInt_resize, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt_insert", _wrap_VectorPairIntInt_insert, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt_reserve", _wrap_VectorPairIntInt_reserve, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt_capacity", _wrap_VectorPairIntInt_capacity, METH_VARARGS, NULL},
	 { (char *)"delete_VectorPairIntInt", _wrap_delete_VectorPairIntInt, METH_VARARGS, NULL},
	 { (char *)"VectorPairIntInt_swigregister", VectorPairIntInt_swigregister, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt_iterator", _wrap_VectorVectorInt_iterator, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt___nonzero__", _wrap_VectorVectorInt___nonzero__, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt___bool__", _wrap_VectorVectorInt___bool__, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt___len__", _wrap_VectorVectorInt___len__, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt___getslice__", _wrap_VectorVectorInt___getslice__, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt___setslice__", _wrap_VectorVectorInt___setslice__, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt___delslice__", _wrap_VectorVectorInt___delslice__, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt___delitem__", _wrap_VectorVectorInt___delitem__, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt___getitem__", _wrap_VectorVectorInt___getitem__, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt___setitem__", _wrap_VectorVectorInt___setitem__, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt_pop", _wrap_VectorVectorInt_pop, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt_append", _wrap_VectorVectorInt_append, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt_empty", _wrap_VectorVectorInt_empty, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt_size", _wrap_VectorVectorInt_size, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt_swap", _wrap_VectorVectorInt_swap, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt_begin", _wrap_VectorVectorInt_begin, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt_end", _wrap_VectorVectorInt_end, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt_rbegin", _wrap_VectorVectorInt_rbegin, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt_rend", _wrap_VectorVectorInt_rend, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt_clear", _wrap_VectorVectorInt_clear, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt_get_allocator", _wrap_VectorVectorInt_get_allocator, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt_pop_back", _wrap_VectorVectorInt_pop_back, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt_erase", _wrap_VectorVectorInt_erase, METH_VARARGS, NULL},
	 { (char *)"new_VectorVectorInt", _wrap_new_VectorVectorInt, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt_push_back", _wrap_VectorVectorInt_push_back, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt_front", _wrap_VectorVectorInt_front, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt_back", _wrap_VectorVectorInt_back, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt_assign", _wrap_VectorVectorInt_assign, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt_resize", _wrap_VectorVectorInt_resize, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt_insert", _wrap_VectorVectorInt_insert, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt_reserve", _wrap_VectorVectorInt_reserve, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt_capacity", _wrap_VectorVectorInt_capacity, METH_VARARGS, NULL},
	 { (char *)"delete_VectorVectorInt", _wrap_delete_VectorVectorInt, METH_VARARGS, NULL},
	 { (char *)"VectorVectorInt_swigregister", VectorVectorInt_swigregister, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex_iterator", _wrap_VectorVectorComplex_iterator, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex___nonzero__", _wrap_VectorVectorComplex___nonzero__, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex___bool__", _wrap_VectorVectorComplex___bool__, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex___len__", _wrap_VectorVectorComplex___len__, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex___getslice__", _wrap_VectorVectorComplex___getslice__, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex___setslice__", _wrap_VectorVectorComplex___setslice__, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex___delslice__", _wrap_VectorVectorComplex___delslice__, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex___delitem__", _wrap_VectorVectorComplex___delitem__, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex___getitem__", _wrap_VectorVectorComplex___getitem__, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex___setitem__", _wrap_VectorVectorComplex___setitem__, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex_pop", _wrap_VectorVectorComplex_pop, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex_append", _wrap_VectorVectorComplex_append, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex_empty", _wrap_VectorVectorComplex_empty, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex_size", _wrap_VectorVectorComplex_size, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex_swap", _wrap_VectorVectorComplex_swap, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex_begin", _wrap_VectorVectorComplex_begin, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex_end", _wrap_VectorVectorComplex_end, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex_rbegin", _wrap_VectorVectorComplex_rbegin, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex_rend", _wrap_VectorVectorComplex_rend, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex_clear", _wrap_VectorVectorComplex_clear, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex_get_allocator", _wrap_VectorVectorComplex_get_allocator, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex_pop_back", _wrap_VectorVectorComplex_pop_back, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex_erase", _wrap_VectorVectorComplex_erase, METH_VARARGS, NULL},
	 { (char *)"new_VectorVectorComplex", _wrap_new_VectorVectorComplex, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex_push_back", _wrap_VectorVectorComplex_push_back, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex_front", _wrap_VectorVectorComplex_front, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex_back", _wrap_VectorVectorComplex_back, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex_assign", _wrap_VectorVectorComplex_assign, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex_resize", _wrap_VectorVectorComplex_resize, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex_insert", _wrap_VectorVectorComplex_insert, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex_reserve", _wrap_VectorVectorComplex_reserve, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex_capacity", _wrap_VectorVectorComplex_capacity, METH_VARARGS, NULL},
	 { (char *)"delete_VectorVectorComplex", _wrap_delete_VectorVectorComplex, METH_VARARGS, NULL},
	 { (char *)"VectorVectorComplex_swigregister", VectorVectorComplex_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_RndmEngine", _wrap_delete_RndmEngine, METH_VARARGS, NULL},
	 { (char *)"RndmEngine_flat", _wrap_RndmEngine_flat, METH_VARARGS, NULL},
	 { (char *)"new_RndmEngine", _wrap_new_RndmEngine, METH_VARARGS, NULL},
	 { (char *)"disown_RndmEngine", _wrap_disown_RndmEngine, METH_VARARGS, NULL},
	 { (char *)"RndmEngine_swigregister", RndmEngine_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Rndm", _wrap_new_Rndm, METH_VARARGS, NULL},
	 { (char *)"Rndm_rndmEnginePtr", _wrap_Rndm_rndmEnginePtr, METH_VARARGS, NULL},
	 { (char *)"Rndm_init", _wrap_Rndm_init, METH_VARARGS, NULL},
	 { (char *)"Rndm_flat", _wrap_Rndm_flat, METH_VARARGS, NULL},
	 { (char *)"Rndm_exp", _wrap_Rndm_exp, METH_VARARGS, NULL},
	 { (char *)"Rndm_xexp", _wrap_Rndm_xexp, METH_VARARGS, NULL},
	 { (char *)"Rndm_gauss", _wrap_Rndm_gauss, METH_VARARGS, NULL},
	 { (char *)"Rndm_gauss2", _wrap_Rndm_gauss2, METH_VARARGS, NULL},
	 { (char *)"Rndm_pick", _wrap_Rndm_pick, METH_VARARGS, NULL},
	 { (char *)"Rndm_dumpState", _wrap_Rndm_dumpState, METH_VARARGS, NULL},
	 { (char *)"Rndm_readState", _wrap_Rndm_readState, METH_VARARGS, NULL},
	 { (char *)"delete_Rndm", _wrap_delete_Rndm, METH_VARARGS, NULL},
	 { (char *)"Rndm_swigregister", Rndm_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Vec4", _wrap_new_Vec4, METH_VARARGS, NULL},
	 { (char *)"Vec4_reset", _wrap_Vec4_reset, METH_VARARGS, NULL},
	 { (char *)"Vec4_p", _wrap_Vec4_p, METH_VARARGS, NULL},
	 { (char *)"Vec4_px", _wrap_Vec4_px, METH_VARARGS, NULL},
	 { (char *)"Vec4_py", _wrap_Vec4_py, METH_VARARGS, NULL},
	 { (char *)"Vec4_pz", _wrap_Vec4_pz, METH_VARARGS, NULL},
	 { (char *)"Vec4_e", _wrap_Vec4_e, METH_VARARGS, NULL},
	 { (char *)"Vec4_mCalc", _wrap_Vec4_mCalc, METH_VARARGS, NULL},
	 { (char *)"Vec4_m2Calc", _wrap_Vec4_m2Calc, METH_VARARGS, NULL},
	 { (char *)"Vec4_pT", _wrap_Vec4_pT, METH_VARARGS, NULL},
	 { (char *)"Vec4_pT2", _wrap_Vec4_pT2, METH_VARARGS, NULL},
	 { (char *)"Vec4_pAbs", _wrap_Vec4_pAbs, METH_VARARGS, NULL},
	 { (char *)"Vec4_pAbs2", _wrap_Vec4_pAbs2, METH_VARARGS, NULL},
	 { (char *)"Vec4_eT", _wrap_Vec4_eT, METH_VARARGS, NULL},
	 { (char *)"Vec4_eT2", _wrap_Vec4_eT2, METH_VARARGS, NULL},
	 { (char *)"Vec4_theta", _wrap_Vec4_theta, METH_VARARGS, NULL},
	 { (char *)"Vec4_phi", _wrap_Vec4_phi, METH_VARARGS, NULL},
	 { (char *)"Vec4_thetaXZ", _wrap_Vec4_thetaXZ, METH_VARARGS, NULL},
	 { (char *)"Vec4_pPos", _wrap_Vec4_pPos, METH_VARARGS, NULL},
	 { (char *)"Vec4_pNeg", _wrap_Vec4_pNeg, METH_VARARGS, NULL},
	 { (char *)"Vec4_rap", _wrap_Vec4_rap, METH_VARARGS, NULL},
	 { (char *)"Vec4_eta", _wrap_Vec4_eta, METH_VARARGS, NULL},
	 { (char *)"Vec4_rescale3", _wrap_Vec4_rescale3, METH_VARARGS, NULL},
	 { (char *)"Vec4_rescale4", _wrap_Vec4_rescale4, METH_VARARGS, NULL},
	 { (char *)"Vec4_flip3", _wrap_Vec4_flip3, METH_VARARGS, NULL},
	 { (char *)"Vec4_flip4", _wrap_Vec4_flip4, METH_VARARGS, NULL},
	 { (char *)"Vec4_rot", _wrap_Vec4_rot, METH_VARARGS, NULL},
	 { (char *)"Vec4_rotaxis", _wrap_Vec4_rotaxis, METH_VARARGS, NULL},
	 { (char *)"Vec4_bst", _wrap_Vec4_bst, METH_VARARGS, NULL},
	 { (char *)"Vec4_bstback", _wrap_Vec4_bstback, METH_VARARGS, NULL},
	 { (char *)"Vec4_rotbst", _wrap_Vec4_rotbst, METH_VARARGS, NULL},
	 { (char *)"Vec4___neg__", _wrap_Vec4___neg__, METH_VARARGS, NULL},
	 { (char *)"Vec4___iadd__", _wrap_Vec4___iadd__, METH_VARARGS, NULL},
	 { (char *)"Vec4___isub__", _wrap_Vec4___isub__, METH_VARARGS, NULL},
	 { (char *)"Vec4___imul__", _wrap_Vec4___imul__, METH_VARARGS, NULL},
	 { (char *)"Vec4___idiv__", _wrap_Vec4___idiv__, METH_VARARGS, NULL},
	 { (char *)"Vec4___add__", _wrap_Vec4___add__, METH_VARARGS, NULL},
	 { (char *)"Vec4___sub__", _wrap_Vec4___sub__, METH_VARARGS, NULL},
	 { (char *)"Vec4___div__", _wrap_Vec4___div__, METH_VARARGS, NULL},
	 { (char *)"Vec4___mul__", _wrap_Vec4___mul__, METH_VARARGS, NULL},
	 { (char *)"Vec4___str__", _wrap_Vec4___str__, METH_VARARGS, NULL},
	 { (char *)"Vec4___getitem__", _wrap_Vec4___getitem__, METH_VARARGS, NULL},
	 { (char *)"Vec4___rmul__", _wrap_Vec4___rmul__, METH_VARARGS, NULL},
	 { (char *)"delete_Vec4", _wrap_delete_Vec4, METH_VARARGS, NULL},
	 { (char *)"Vec4_swigregister", Vec4_swigregister, METH_VARARGS, NULL},
	 { (char *)"dot3", _wrap_dot3, METH_VARARGS, NULL},
	 { (char *)"cross3", _wrap_cross3, METH_VARARGS, NULL},
	 { (char *)"cross4", _wrap_cross4, METH_VARARGS, NULL},
	 { (char *)"theta", _wrap_theta, METH_VARARGS, NULL},
	 { (char *)"costheta", _wrap_costheta, METH_VARARGS, NULL},
	 { (char *)"phi", _wrap_phi, METH_VARARGS, NULL},
	 { (char *)"cosphi", _wrap_cosphi, METH_VARARGS, NULL},
	 { (char *)"RRapPhi", _wrap_RRapPhi, METH_VARARGS, NULL},
	 { (char *)"REtaPhi", _wrap_REtaPhi, METH_VARARGS, NULL},
	 { (char *)"pShift", _wrap_pShift, METH_VARARGS, NULL},
	 { (char *)"getTwoPerpendicular", _wrap_getTwoPerpendicular, METH_VARARGS, NULL},
	 { (char *)"new_RotBstMatrix", _wrap_new_RotBstMatrix, METH_VARARGS, NULL},
	 { (char *)"RotBstMatrix_rot", _wrap_RotBstMatrix_rot, METH_VARARGS, NULL},
	 { (char *)"RotBstMatrix_bstback", _wrap_RotBstMatrix_bstback, METH_VARARGS, NULL},
	 { (char *)"RotBstMatrix_bst", _wrap_RotBstMatrix_bst, METH_VARARGS, NULL},
	 { (char *)"RotBstMatrix_toCMframe", _wrap_RotBstMatrix_toCMframe, METH_VARARGS, NULL},
	 { (char *)"RotBstMatrix_fromCMframe", _wrap_RotBstMatrix_fromCMframe, METH_VARARGS, NULL},
	 { (char *)"RotBstMatrix_rotbst", _wrap_RotBstMatrix_rotbst, METH_VARARGS, NULL},
	 { (char *)"RotBstMatrix_invert", _wrap_RotBstMatrix_invert, METH_VARARGS, NULL},
	 { (char *)"RotBstMatrix_reset", _wrap_RotBstMatrix_reset, METH_VARARGS, NULL},
	 { (char *)"RotBstMatrix_value", _wrap_RotBstMatrix_value, METH_VARARGS, NULL},
	 { (char *)"RotBstMatrix_deviation", _wrap_RotBstMatrix_deviation, METH_VARARGS, NULL},
	 { (char *)"RotBstMatrix___str__", _wrap_RotBstMatrix___str__, METH_VARARGS, NULL},
	 { (char *)"delete_RotBstMatrix", _wrap_delete_RotBstMatrix, METH_VARARGS, NULL},
	 { (char *)"RotBstMatrix_swigregister", RotBstMatrix_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Hist", _wrap_new_Hist, METH_VARARGS, NULL},
	 { (char *)"Hist_book", _wrap_Hist_book, METH_VARARGS, NULL},
	 { (char *)"Hist_title", _wrap_Hist_title, METH_VARARGS, NULL},
	 { (char *)"Hist_null", _wrap_Hist_null, METH_VARARGS, NULL},
	 { (char *)"Hist_fill", _wrap_Hist_fill, METH_VARARGS, NULL},
	 { (char *)"Hist_table", _wrap_Hist_table, METH_VARARGS, NULL},
	 { (char *)"Hist_rivetTable", _wrap_Hist_rivetTable, METH_VARARGS, NULL},
	 { (char *)"Hist_pyplotTable", _wrap_Hist_pyplotTable, METH_VARARGS, NULL},
	 { (char *)"Hist_getTitle", _wrap_Hist_getTitle, METH_VARARGS, NULL},
	 { (char *)"Hist_getBinNumber", _wrap_Hist_getBinNumber, METH_VARARGS, NULL},
	 { (char *)"Hist_getLinX", _wrap_Hist_getLinX, METH_VARARGS, NULL},
	 { (char *)"Hist_getBinContent", _wrap_Hist_getBinContent, METH_VARARGS, NULL},
	 { (char *)"Hist_getEntries", _wrap_Hist_getEntries, METH_VARARGS, NULL},
	 { (char *)"Hist_sameSize", _wrap_Hist_sameSize, METH_VARARGS, NULL},
	 { (char *)"Hist_takeLog", _wrap_Hist_takeLog, METH_VARARGS, NULL},
	 { (char *)"Hist_takeSqrt", _wrap_Hist_takeSqrt, METH_VARARGS, NULL},
	 { (char *)"Hist_smallestAbsValue", _wrap_Hist_smallestAbsValue, METH_VARARGS, NULL},
	 { (char *)"Hist___iadd__", _wrap_Hist___iadd__, METH_VARARGS, NULL},
	 { (char *)"Hist___isub__", _wrap_Hist___isub__, METH_VARARGS, NULL},
	 { (char *)"Hist___imul__", _wrap_Hist___imul__, METH_VARARGS, NULL},
	 { (char *)"Hist___idiv__", _wrap_Hist___idiv__, METH_VARARGS, NULL},
	 { (char *)"Hist___add__", _wrap_Hist___add__, METH_VARARGS, NULL},
	 { (char *)"Hist___sub__", _wrap_Hist___sub__, METH_VARARGS, NULL},
	 { (char *)"Hist___mul__", _wrap_Hist___mul__, METH_VARARGS, NULL},
	 { (char *)"Hist___div__", _wrap_Hist___div__, METH_VARARGS, NULL},
	 { (char *)"Hist___str__", _wrap_Hist___str__, METH_VARARGS, NULL},
	 { (char *)"Hist___radd__", _wrap_Hist___radd__, METH_VARARGS, NULL},
	 { (char *)"Hist___rsub__", _wrap_Hist___rsub__, METH_VARARGS, NULL},
	 { (char *)"Hist___rmul__", _wrap_Hist___rmul__, METH_VARARGS, NULL},
	 { (char *)"Hist___rdiv__", _wrap_Hist___rdiv__, METH_VARARGS, NULL},
	 { (char *)"delete_Hist", _wrap_delete_Hist, METH_VARARGS, NULL},
	 { (char *)"Hist_swigregister", Hist_swigregister, METH_VARARGS, NULL},
	 { (char *)"table", _wrap_table, METH_VARARGS, NULL},
	 { (char *)"__div__", _wrap___div__, METH_VARARGS, NULL},
	 { (char *)"new_HistPlot", _wrap_new_HistPlot, METH_VARARGS, NULL},
	 { (char *)"delete_HistPlot", _wrap_delete_HistPlot, METH_VARARGS, NULL},
	 { (char *)"HistPlot_frame", _wrap_HistPlot_frame, METH_VARARGS, NULL},
	 { (char *)"HistPlot_add", _wrap_HistPlot_add, METH_VARARGS, NULL},
	 { (char *)"HistPlot_plot", _wrap_HistPlot_plot, METH_VARARGS, NULL},
	 { (char *)"HistPlot_plotFrame", _wrap_HistPlot_plotFrame, METH_VARARGS, NULL},
	 { (char *)"HistPlot_swigregister", HistPlot_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_XMLTag", _wrap_delete_XMLTag, METH_VARARGS, NULL},
	 { (char *)"XMLTag_name_set", _wrap_XMLTag_name_set, METH_VARARGS, NULL},
	 { (char *)"XMLTag_name_get", _wrap_XMLTag_name_get, METH_VARARGS, NULL},
	 { (char *)"XMLTag_attr_set", _wrap_XMLTag_attr_set, METH_VARARGS, NULL},
	 { (char *)"XMLTag_attr_get", _wrap_XMLTag_attr_get, METH_VARARGS, NULL},
	 { (char *)"XMLTag_tags_set", _wrap_XMLTag_tags_set, METH_VARARGS, NULL},
	 { (char *)"XMLTag_tags_get", _wrap_XMLTag_tags_get, METH_VARARGS, NULL},
	 { (char *)"XMLTag_contents_set", _wrap_XMLTag_contents_set, METH_VARARGS, NULL},
	 { (char *)"XMLTag_contents_get", _wrap_XMLTag_contents_get, METH_VARARGS, NULL},
	 { (char *)"XMLTag_getattr", _wrap_XMLTag_getattr, METH_VARARGS, NULL},
	 { (char *)"XMLTag_findXMLTags", _wrap_XMLTag_findXMLTags, METH_VARARGS, NULL},
	 { (char *)"XMLTag___str__", _wrap_XMLTag___str__, METH_VARARGS, NULL},
	 { (char *)"new_XMLTag", _wrap_new_XMLTag, METH_VARARGS, NULL},
	 { (char *)"XMLTag_swigregister", XMLTag_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LHAweights", _wrap_new_LHAweights, METH_VARARGS, NULL},
	 { (char *)"LHAweights_clear", _wrap_LHAweights_clear, METH_VARARGS, NULL},
	 { (char *)"LHAweights_weights_set", _wrap_LHAweights_weights_set, METH_VARARGS, NULL},
	 { (char *)"LHAweights_weights_get", _wrap_LHAweights_weights_get, METH_VARARGS, NULL},
	 { (char *)"LHAweights_attributes_set", _wrap_LHAweights_attributes_set, METH_VARARGS, NULL},
	 { (char *)"LHAweights_attributes_get", _wrap_LHAweights_attributes_get, METH_VARARGS, NULL},
	 { (char *)"LHAweights_contents_set", _wrap_LHAweights_contents_set, METH_VARARGS, NULL},
	 { (char *)"LHAweights_contents_get", _wrap_LHAweights_contents_get, METH_VARARGS, NULL},
	 { (char *)"LHAweights_size", _wrap_LHAweights_size, METH_VARARGS, NULL},
	 { (char *)"LHAweights___str__", _wrap_LHAweights___str__, METH_VARARGS, NULL},
	 { (char *)"delete_LHAweights", _wrap_delete_LHAweights, METH_VARARGS, NULL},
	 { (char *)"LHAweights_swigregister", LHAweights_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LHAscales", _wrap_new_LHAscales, METH_VARARGS, NULL},
	 { (char *)"LHAscales_clear", _wrap_LHAscales_clear, METH_VARARGS, NULL},
	 { (char *)"LHAscales_muf_set", _wrap_LHAscales_muf_set, METH_VARARGS, NULL},
	 { (char *)"LHAscales_muf_get", _wrap_LHAscales_muf_get, METH_VARARGS, NULL},
	 { (char *)"LHAscales_mur_set", _wrap_LHAscales_mur_set, METH_VARARGS, NULL},
	 { (char *)"LHAscales_mur_get", _wrap_LHAscales_mur_get, METH_VARARGS, NULL},
	 { (char *)"LHAscales_mups_set", _wrap_LHAscales_mups_set, METH_VARARGS, NULL},
	 { (char *)"LHAscales_mups_get", _wrap_LHAscales_mups_get, METH_VARARGS, NULL},
	 { (char *)"LHAscales_attributes_set", _wrap_LHAscales_attributes_set, METH_VARARGS, NULL},
	 { (char *)"LHAscales_attributes_get", _wrap_LHAscales_attributes_get, METH_VARARGS, NULL},
	 { (char *)"LHAscales_SCALUP_set", _wrap_LHAscales_SCALUP_set, METH_VARARGS, NULL},
	 { (char *)"LHAscales_SCALUP_get", _wrap_LHAscales_SCALUP_get, METH_VARARGS, NULL},
	 { (char *)"LHAscales_contents_set", _wrap_LHAscales_contents_set, METH_VARARGS, NULL},
	 { (char *)"LHAscales_contents_get", _wrap_LHAscales_contents_get, METH_VARARGS, NULL},
	 { (char *)"LHAscales___str__", _wrap_LHAscales___str__, METH_VARARGS, NULL},
	 { (char *)"delete_LHAscales", _wrap_delete_LHAscales, METH_VARARGS, NULL},
	 { (char *)"LHAscales_swigregister", LHAscales_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LHAgenerator", _wrap_new_LHAgenerator, METH_VARARGS, NULL},
	 { (char *)"LHAgenerator_clear", _wrap_LHAgenerator_clear, METH_VARARGS, NULL},
	 { (char *)"LHAgenerator_name_set", _wrap_LHAgenerator_name_set, METH_VARARGS, NULL},
	 { (char *)"LHAgenerator_name_get", _wrap_LHAgenerator_name_get, METH_VARARGS, NULL},
	 { (char *)"LHAgenerator_version_set", _wrap_LHAgenerator_version_set, METH_VARARGS, NULL},
	 { (char *)"LHAgenerator_version_get", _wrap_LHAgenerator_version_get, METH_VARARGS, NULL},
	 { (char *)"LHAgenerator_attributes_set", _wrap_LHAgenerator_attributes_set, METH_VARARGS, NULL},
	 { (char *)"LHAgenerator_attributes_get", _wrap_LHAgenerator_attributes_get, METH_VARARGS, NULL},
	 { (char *)"LHAgenerator_contents_set", _wrap_LHAgenerator_contents_set, METH_VARARGS, NULL},
	 { (char *)"LHAgenerator_contents_get", _wrap_LHAgenerator_contents_get, METH_VARARGS, NULL},
	 { (char *)"LHAgenerator___str__", _wrap_LHAgenerator___str__, METH_VARARGS, NULL},
	 { (char *)"delete_LHAgenerator", _wrap_delete_LHAgenerator, METH_VARARGS, NULL},
	 { (char *)"LHAgenerator_swigregister", LHAgenerator_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LHAwgt", _wrap_new_LHAwgt, METH_VARARGS, NULL},
	 { (char *)"LHAwgt_clear", _wrap_LHAwgt_clear, METH_VARARGS, NULL},
	 { (char *)"LHAwgt_id_set", _wrap_LHAwgt_id_set, METH_VARARGS, NULL},
	 { (char *)"LHAwgt_id_get", _wrap_LHAwgt_id_get, METH_VARARGS, NULL},
	 { (char *)"LHAwgt_attributes_set", _wrap_LHAwgt_attributes_set, METH_VARARGS, NULL},
	 { (char *)"LHAwgt_attributes_get", _wrap_LHAwgt_attributes_get, METH_VARARGS, NULL},
	 { (char *)"LHAwgt_contents_set", _wrap_LHAwgt_contents_set, METH_VARARGS, NULL},
	 { (char *)"LHAwgt_contents_get", _wrap_LHAwgt_contents_get, METH_VARARGS, NULL},
	 { (char *)"LHAwgt___str__", _wrap_LHAwgt___str__, METH_VARARGS, NULL},
	 { (char *)"delete_LHAwgt", _wrap_delete_LHAwgt, METH_VARARGS, NULL},
	 { (char *)"LHAwgt_swigregister", LHAwgt_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LHAweight", _wrap_new_LHAweight, METH_VARARGS, NULL},
	 { (char *)"LHAweight_clear", _wrap_LHAweight_clear, METH_VARARGS, NULL},
	 { (char *)"LHAweight_id_set", _wrap_LHAweight_id_set, METH_VARARGS, NULL},
	 { (char *)"LHAweight_id_get", _wrap_LHAweight_id_get, METH_VARARGS, NULL},
	 { (char *)"LHAweight_attributes_set", _wrap_LHAweight_attributes_set, METH_VARARGS, NULL},
	 { (char *)"LHAweight_attributes_get", _wrap_LHAweight_attributes_get, METH_VARARGS, NULL},
	 { (char *)"LHAweight_contents_set", _wrap_LHAweight_contents_set, METH_VARARGS, NULL},
	 { (char *)"LHAweight_contents_get", _wrap_LHAweight_contents_get, METH_VARARGS, NULL},
	 { (char *)"LHAweight___str__", _wrap_LHAweight___str__, METH_VARARGS, NULL},
	 { (char *)"delete_LHAweight", _wrap_delete_LHAweight, METH_VARARGS, NULL},
	 { (char *)"LHAweight_swigregister", LHAweight_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LHAweightgroup", _wrap_new_LHAweightgroup, METH_VARARGS, NULL},
	 { (char *)"LHAweightgroup_clear", _wrap_LHAweightgroup_clear, METH_VARARGS, NULL},
	 { (char *)"LHAweightgroup_contents_set", _wrap_LHAweightgroup_contents_set, METH_VARARGS, NULL},
	 { (char *)"LHAweightgroup_contents_get", _wrap_LHAweightgroup_contents_get, METH_VARARGS, NULL},
	 { (char *)"LHAweightgroup_name_set", _wrap_LHAweightgroup_name_set, METH_VARARGS, NULL},
	 { (char *)"LHAweightgroup_name_get", _wrap_LHAweightgroup_name_get, METH_VARARGS, NULL},
	 { (char *)"LHAweightgroup_weights_set", _wrap_LHAweightgroup_weights_set, METH_VARARGS, NULL},
	 { (char *)"LHAweightgroup_weights_get", _wrap_LHAweightgroup_weights_get, METH_VARARGS, NULL},
	 { (char *)"LHAweightgroup_weightsKeys_set", _wrap_LHAweightgroup_weightsKeys_set, METH_VARARGS, NULL},
	 { (char *)"LHAweightgroup_weightsKeys_get", _wrap_LHAweightgroup_weightsKeys_get, METH_VARARGS, NULL},
	 { (char *)"LHAweightgroup_attributes_set", _wrap_LHAweightgroup_attributes_set, METH_VARARGS, NULL},
	 { (char *)"LHAweightgroup_attributes_get", _wrap_LHAweightgroup_attributes_get, METH_VARARGS, NULL},
	 { (char *)"LHAweightgroup_size", _wrap_LHAweightgroup_size, METH_VARARGS, NULL},
	 { (char *)"LHAweightgroup___str__", _wrap_LHAweightgroup___str__, METH_VARARGS, NULL},
	 { (char *)"delete_LHAweightgroup", _wrap_delete_LHAweightgroup, METH_VARARGS, NULL},
	 { (char *)"LHAweightgroup_swigregister", LHAweightgroup_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LHArwgt", _wrap_new_LHArwgt, METH_VARARGS, NULL},
	 { (char *)"LHArwgt_clear", _wrap_LHArwgt_clear, METH_VARARGS, NULL},
	 { (char *)"LHArwgt_contents_set", _wrap_LHArwgt_contents_set, METH_VARARGS, NULL},
	 { (char *)"LHArwgt_contents_get", _wrap_LHArwgt_contents_get, METH_VARARGS, NULL},
	 { (char *)"LHArwgt_wgts_set", _wrap_LHArwgt_wgts_set, METH_VARARGS, NULL},
	 { (char *)"LHArwgt_wgts_get", _wrap_LHArwgt_wgts_get, METH_VARARGS, NULL},
	 { (char *)"LHArwgt_wgtsKeys_set", _wrap_LHArwgt_wgtsKeys_set, METH_VARARGS, NULL},
	 { (char *)"LHArwgt_wgtsKeys_get", _wrap_LHArwgt_wgtsKeys_get, METH_VARARGS, NULL},
	 { (char *)"LHArwgt_attributes_set", _wrap_LHArwgt_attributes_set, METH_VARARGS, NULL},
	 { (char *)"LHArwgt_attributes_get", _wrap_LHArwgt_attributes_get, METH_VARARGS, NULL},
	 { (char *)"LHArwgt_size", _wrap_LHArwgt_size, METH_VARARGS, NULL},
	 { (char *)"LHArwgt___str__", _wrap_LHArwgt___str__, METH_VARARGS, NULL},
	 { (char *)"delete_LHArwgt", _wrap_delete_LHArwgt, METH_VARARGS, NULL},
	 { (char *)"LHArwgt_swigregister", LHArwgt_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LHAinitrwgt", _wrap_new_LHAinitrwgt, METH_VARARGS, NULL},
	 { (char *)"LHAinitrwgt_clear", _wrap_LHAinitrwgt_clear, METH_VARARGS, NULL},
	 { (char *)"LHAinitrwgt_contents_set", _wrap_LHAinitrwgt_contents_set, METH_VARARGS, NULL},
	 { (char *)"LHAinitrwgt_contents_get", _wrap_LHAinitrwgt_contents_get, METH_VARARGS, NULL},
	 { (char *)"LHAinitrwgt_weights_set", _wrap_LHAinitrwgt_weights_set, METH_VARARGS, NULL},
	 { (char *)"LHAinitrwgt_weights_get", _wrap_LHAinitrwgt_weights_get, METH_VARARGS, NULL},
	 { (char *)"LHAinitrwgt_weightsKeys_set", _wrap_LHAinitrwgt_weightsKeys_set, METH_VARARGS, NULL},
	 { (char *)"LHAinitrwgt_weightsKeys_get", _wrap_LHAinitrwgt_weightsKeys_get, METH_VARARGS, NULL},
	 { (char *)"LHAinitrwgt_weightgroups_set", _wrap_LHAinitrwgt_weightgroups_set, METH_VARARGS, NULL},
	 { (char *)"LHAinitrwgt_weightgroups_get", _wrap_LHAinitrwgt_weightgroups_get, METH_VARARGS, NULL},
	 { (char *)"LHAinitrwgt_weightgroupsKeys_set", _wrap_LHAinitrwgt_weightgroupsKeys_set, METH_VARARGS, NULL},
	 { (char *)"LHAinitrwgt_weightgroupsKeys_get", _wrap_LHAinitrwgt_weightgroupsKeys_get, METH_VARARGS, NULL},
	 { (char *)"LHAinitrwgt_attributes_set", _wrap_LHAinitrwgt_attributes_set, METH_VARARGS, NULL},
	 { (char *)"LHAinitrwgt_attributes_get", _wrap_LHAinitrwgt_attributes_get, METH_VARARGS, NULL},
	 { (char *)"LHAinitrwgt_size", _wrap_LHAinitrwgt_size, METH_VARARGS, NULL},
	 { (char *)"LHAinitrwgt_sizeWeightGroups", _wrap_LHAinitrwgt_sizeWeightGroups, METH_VARARGS, NULL},
	 { (char *)"LHAinitrwgt___str__", _wrap_LHAinitrwgt___str__, METH_VARARGS, NULL},
	 { (char *)"delete_LHAinitrwgt", _wrap_delete_LHAinitrwgt, METH_VARARGS, NULL},
	 { (char *)"LHAinitrwgt_swigregister", LHAinitrwgt_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HEPRUP", _wrap_new_HEPRUP, METH_VARARGS, NULL},
	 { (char *)"delete_HEPRUP", _wrap_delete_HEPRUP, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_resize", _wrap_HEPRUP_resize, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_clear", _wrap_HEPRUP_clear, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_IDBMUP_set", _wrap_HEPRUP_IDBMUP_set, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_IDBMUP_get", _wrap_HEPRUP_IDBMUP_get, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_EBMUP_set", _wrap_HEPRUP_EBMUP_set, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_EBMUP_get", _wrap_HEPRUP_EBMUP_get, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_PDFGUP_set", _wrap_HEPRUP_PDFGUP_set, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_PDFGUP_get", _wrap_HEPRUP_PDFGUP_get, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_PDFSUP_set", _wrap_HEPRUP_PDFSUP_set, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_PDFSUP_get", _wrap_HEPRUP_PDFSUP_get, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_IDWTUP_set", _wrap_HEPRUP_IDWTUP_set, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_IDWTUP_get", _wrap_HEPRUP_IDWTUP_get, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_NPRUP_set", _wrap_HEPRUP_NPRUP_set, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_NPRUP_get", _wrap_HEPRUP_NPRUP_get, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_XSECUP_set", _wrap_HEPRUP_XSECUP_set, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_XSECUP_get", _wrap_HEPRUP_XSECUP_get, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_XERRUP_set", _wrap_HEPRUP_XERRUP_set, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_XERRUP_get", _wrap_HEPRUP_XERRUP_get, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_XMAXUP_set", _wrap_HEPRUP_XMAXUP_set, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_XMAXUP_get", _wrap_HEPRUP_XMAXUP_get, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_LPRUP_set", _wrap_HEPRUP_LPRUP_set, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_LPRUP_get", _wrap_HEPRUP_LPRUP_get, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_initrwgt_set", _wrap_HEPRUP_initrwgt_set, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_initrwgt_get", _wrap_HEPRUP_initrwgt_get, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_generators_set", _wrap_HEPRUP_generators_set, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_generators_get", _wrap_HEPRUP_generators_get, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_weightgroups_set", _wrap_HEPRUP_weightgroups_set, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_weightgroups_get", _wrap_HEPRUP_weightgroups_get, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_weights_set", _wrap_HEPRUP_weights_set, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_weights_get", _wrap_HEPRUP_weights_get, METH_VARARGS, NULL},
	 { (char *)"HEPRUP_swigregister", HEPRUP_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HEPEUP", _wrap_new_HEPEUP, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_setEvent", _wrap_HEPEUP_setEvent, METH_VARARGS, NULL},
	 { (char *)"delete_HEPEUP", _wrap_delete_HEPEUP, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_reset", _wrap_HEPEUP_reset, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_clear", _wrap_HEPEUP_clear, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_weight", _wrap_HEPEUP_weight, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_resize", _wrap_HEPEUP_resize, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_NUP_set", _wrap_HEPEUP_NUP_set, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_NUP_get", _wrap_HEPEUP_NUP_get, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_IDPRUP_set", _wrap_HEPEUP_IDPRUP_set, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_IDPRUP_get", _wrap_HEPEUP_IDPRUP_get, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_XWGTUP_set", _wrap_HEPEUP_XWGTUP_set, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_XWGTUP_get", _wrap_HEPEUP_XWGTUP_get, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_XPDWUP_set", _wrap_HEPEUP_XPDWUP_set, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_XPDWUP_get", _wrap_HEPEUP_XPDWUP_get, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_SCALUP_set", _wrap_HEPEUP_SCALUP_set, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_SCALUP_get", _wrap_HEPEUP_SCALUP_get, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_AQEDUP_set", _wrap_HEPEUP_AQEDUP_set, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_AQEDUP_get", _wrap_HEPEUP_AQEDUP_get, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_AQCDUP_set", _wrap_HEPEUP_AQCDUP_set, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_AQCDUP_get", _wrap_HEPEUP_AQCDUP_get, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_IDUP_set", _wrap_HEPEUP_IDUP_set, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_IDUP_get", _wrap_HEPEUP_IDUP_get, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_ISTUP_set", _wrap_HEPEUP_ISTUP_set, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_ISTUP_get", _wrap_HEPEUP_ISTUP_get, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_MOTHUP_set", _wrap_HEPEUP_MOTHUP_set, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_MOTHUP_get", _wrap_HEPEUP_MOTHUP_get, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_ICOLUP_set", _wrap_HEPEUP_ICOLUP_set, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_ICOLUP_get", _wrap_HEPEUP_ICOLUP_get, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_PUP_set", _wrap_HEPEUP_PUP_set, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_PUP_get", _wrap_HEPEUP_PUP_get, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_VTIMUP_set", _wrap_HEPEUP_VTIMUP_set, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_VTIMUP_get", _wrap_HEPEUP_VTIMUP_get, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_SPINUP_set", _wrap_HEPEUP_SPINUP_set, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_SPINUP_get", _wrap_HEPEUP_SPINUP_get, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_heprup_set", _wrap_HEPEUP_heprup_set, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_heprup_get", _wrap_HEPEUP_heprup_get, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_weights_detailed_set", _wrap_HEPEUP_weights_detailed_set, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_weights_detailed_get", _wrap_HEPEUP_weights_detailed_get, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_weights_compressed_set", _wrap_HEPEUP_weights_compressed_set, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_weights_compressed_get", _wrap_HEPEUP_weights_compressed_get, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_scalesSave_set", _wrap_HEPEUP_scalesSave_set, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_scalesSave_get", _wrap_HEPEUP_scalesSave_get, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_weightsSave_set", _wrap_HEPEUP_weightsSave_set, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_weightsSave_get", _wrap_HEPEUP_weightsSave_get, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_rwgtSave_set", _wrap_HEPEUP_rwgtSave_set, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_rwgtSave_get", _wrap_HEPEUP_rwgtSave_get, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_attributes_set", _wrap_HEPEUP_attributes_set, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_attributes_get", _wrap_HEPEUP_attributes_get, METH_VARARGS, NULL},
	 { (char *)"HEPEUP_swigregister", HEPEUP_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Reader", _wrap_new_Reader, METH_VARARGS, NULL},
	 { (char *)"delete_Reader", _wrap_delete_Reader, METH_VARARGS, NULL},
	 { (char *)"Reader_setup", _wrap_Reader_setup, METH_VARARGS, NULL},
	 { (char *)"Reader_readEvent", _wrap_Reader_readEvent, METH_VARARGS, NULL},
	 { (char *)"Reader_clearEvent", _wrap_Reader_clearEvent, METH_VARARGS, NULL},
	 { (char *)"Reader_isGood_set", _wrap_Reader_isGood_set, METH_VARARGS, NULL},
	 { (char *)"Reader_isGood_get", _wrap_Reader_isGood_get, METH_VARARGS, NULL},
	 { (char *)"Reader_version_set", _wrap_Reader_version_set, METH_VARARGS, NULL},
	 { (char *)"Reader_version_get", _wrap_Reader_version_get, METH_VARARGS, NULL},
	 { (char *)"Reader_outsideBlock_set", _wrap_Reader_outsideBlock_set, METH_VARARGS, NULL},
	 { (char *)"Reader_outsideBlock_get", _wrap_Reader_outsideBlock_get, METH_VARARGS, NULL},
	 { (char *)"Reader_headerBlock_set", _wrap_Reader_headerBlock_set, METH_VARARGS, NULL},
	 { (char *)"Reader_headerBlock_get", _wrap_Reader_headerBlock_get, METH_VARARGS, NULL},
	 { (char *)"Reader_headerComments_set", _wrap_Reader_headerComments_set, METH_VARARGS, NULL},
	 { (char *)"Reader_headerComments_get", _wrap_Reader_headerComments_get, METH_VARARGS, NULL},
	 { (char *)"Reader_heprup_set", _wrap_Reader_heprup_set, METH_VARARGS, NULL},
	 { (char *)"Reader_heprup_get", _wrap_Reader_heprup_get, METH_VARARGS, NULL},
	 { (char *)"Reader_initComments_set", _wrap_Reader_initComments_set, METH_VARARGS, NULL},
	 { (char *)"Reader_initComments_get", _wrap_Reader_initComments_get, METH_VARARGS, NULL},
	 { (char *)"Reader_hepeup_set", _wrap_Reader_hepeup_set, METH_VARARGS, NULL},
	 { (char *)"Reader_hepeup_get", _wrap_Reader_hepeup_get, METH_VARARGS, NULL},
	 { (char *)"Reader_eventComments_set", _wrap_Reader_eventComments_set, METH_VARARGS, NULL},
	 { (char *)"Reader_eventComments_get", _wrap_Reader_eventComments_get, METH_VARARGS, NULL},
	 { (char *)"Reader_weights_detailed_vec_set", _wrap_Reader_weights_detailed_vec_set, METH_VARARGS, NULL},
	 { (char *)"Reader_weights_detailed_vec_get", _wrap_Reader_weights_detailed_vec_get, METH_VARARGS, NULL},
	 { (char *)"Reader_swigregister", Reader_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Writer", _wrap_new_Writer, METH_VARARGS, NULL},
	 { (char *)"delete_Writer", _wrap_delete_Writer, METH_VARARGS, NULL},
	 { (char *)"Writer_headerBlock", _wrap_Writer_headerBlock, METH_VARARGS, NULL},
	 { (char *)"Writer_initComments", _wrap_Writer_initComments, METH_VARARGS, NULL},
	 { (char *)"Writer_eventComments", _wrap_Writer_eventComments, METH_VARARGS, NULL},
	 { (char *)"Writer_init", _wrap_Writer_init, METH_VARARGS, NULL},
	 { (char *)"Writer_writeEvent", _wrap_Writer_writeEvent, METH_VARARGS, NULL},
	 { (char *)"Writer_getEventString", _wrap_Writer_getEventString, METH_VARARGS, NULL},
	 { (char *)"Writer_heprup_set", _wrap_Writer_heprup_set, METH_VARARGS, NULL},
	 { (char *)"Writer_heprup_get", _wrap_Writer_heprup_get, METH_VARARGS, NULL},
	 { (char *)"Writer_hepeup_set", _wrap_Writer_hepeup_set, METH_VARARGS, NULL},
	 { (char *)"Writer_hepeup_get", _wrap_Writer_hepeup_get, METH_VARARGS, NULL},
	 { (char *)"Writer_version_set", _wrap_Writer_version_set, METH_VARARGS, NULL},
	 { (char *)"Writer_version_get", _wrap_Writer_version_get, METH_VARARGS, NULL},
	 { (char *)"Writer_swigregister", Writer_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PartonSystem", _wrap_new_PartonSystem, METH_VARARGS, NULL},
	 { (char *)"PartonSystem_iInA_set", _wrap_PartonSystem_iInA_set, METH_VARARGS, NULL},
	 { (char *)"PartonSystem_iInA_get", _wrap_PartonSystem_iInA_get, METH_VARARGS, NULL},
	 { (char *)"PartonSystem_iInB_set", _wrap_PartonSystem_iInB_set, METH_VARARGS, NULL},
	 { (char *)"PartonSystem_iInB_get", _wrap_PartonSystem_iInB_get, METH_VARARGS, NULL},
	 { (char *)"PartonSystem_iOut_set", _wrap_PartonSystem_iOut_set, METH_VARARGS, NULL},
	 { (char *)"PartonSystem_iOut_get", _wrap_PartonSystem_iOut_get, METH_VARARGS, NULL},
	 { (char *)"PartonSystem_sHat_set", _wrap_PartonSystem_sHat_set, METH_VARARGS, NULL},
	 { (char *)"PartonSystem_sHat_get", _wrap_PartonSystem_sHat_get, METH_VARARGS, NULL},
	 { (char *)"PartonSystem_pTHat_set", _wrap_PartonSystem_pTHat_set, METH_VARARGS, NULL},
	 { (char *)"PartonSystem_pTHat_get", _wrap_PartonSystem_pTHat_get, METH_VARARGS, NULL},
	 { (char *)"delete_PartonSystem", _wrap_delete_PartonSystem, METH_VARARGS, NULL},
	 { (char *)"PartonSystem_swigregister", PartonSystem_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PartonSystems", _wrap_new_PartonSystems, METH_VARARGS, NULL},
	 { (char *)"PartonSystems_clear", _wrap_PartonSystems_clear, METH_VARARGS, NULL},
	 { (char *)"PartonSystems_addSys", _wrap_PartonSystems_addSys, METH_VARARGS, NULL},
	 { (char *)"PartonSystems_sizeSys", _wrap_PartonSystems_sizeSys, METH_VARARGS, NULL},
	 { (char *)"PartonSystems_setInA", _wrap_PartonSystems_setInA, METH_VARARGS, NULL},
	 { (char *)"PartonSystems_setInB", _wrap_PartonSystems_setInB, METH_VARARGS, NULL},
	 { (char *)"PartonSystems_addOut", _wrap_PartonSystems_addOut, METH_VARARGS, NULL},
	 { (char *)"PartonSystems_popBackOut", _wrap_PartonSystems_popBackOut, METH_VARARGS, NULL},
	 { (char *)"PartonSystems_setOut", _wrap_PartonSystems_setOut, METH_VARARGS, NULL},
	 { (char *)"PartonSystems_replace", _wrap_PartonSystems_replace, METH_VARARGS, NULL},
	 { (char *)"PartonSystems_setSHat", _wrap_PartonSystems_setSHat, METH_VARARGS, NULL},
	 { (char *)"PartonSystems_setPTHat", _wrap_PartonSystems_setPTHat, METH_VARARGS, NULL},
	 { (char *)"PartonSystems_setSizeSys", _wrap_PartonSystems_setSizeSys, METH_VARARGS, NULL},
	 { (char *)"PartonSystems_hasInAB", _wrap_PartonSystems_hasInAB, METH_VARARGS, NULL},
	 { (char *)"PartonSystems_getInA", _wrap_PartonSystems_getInA, METH_VARARGS, NULL},
	 { (char *)"PartonSystems_getInB", _wrap_PartonSystems_getInB, METH_VARARGS, NULL},
	 { (char *)"PartonSystems_sizeOut", _wrap_PartonSystems_sizeOut, METH_VARARGS, NULL},
	 { (char *)"PartonSystems_getOut", _wrap_PartonSystems_getOut, METH_VARARGS, NULL},
	 { (char *)"PartonSystems_sizeAll", _wrap_PartonSystems_sizeAll, METH_VARARGS, NULL},
	 { (char *)"PartonSystems_getAll", _wrap_PartonSystems_getAll, METH_VARARGS, NULL},
	 { (char *)"PartonSystems_getSHat", _wrap_PartonSystems_getSHat, METH_VARARGS, NULL},
	 { (char *)"PartonSystems_getPTHat", _wrap_PartonSystems_getPTHat, METH_VARARGS, NULL},
	 { (char *)"PartonSystems_getSystemOf", _wrap_PartonSystems_getSystemOf, METH_VARARGS, NULL},
	 { (char *)"PartonSystems_getIndexOfOut", _wrap_PartonSystems_getIndexOfOut, METH_VARARGS, NULL},
	 { (char *)"PartonSystems_popBack", _wrap_PartonSystems_popBack, METH_VARARGS, NULL},
	 { (char *)"PartonSystems___str__", _wrap_PartonSystems___str__, METH_VARARGS, NULL},
	 { (char *)"delete_PartonSystems", _wrap_delete_PartonSystems, METH_VARARGS, NULL},
	 { (char *)"PartonSystems_swigregister", PartonSystems_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ProgressLog", _wrap_new_ProgressLog, METH_VARARGS, NULL},
	 { (char *)"ProgressLog___call__", _wrap_ProgressLog___call__, METH_VARARGS, NULL},
	 { (char *)"ProgressLog_tick", _wrap_ProgressLog_tick, METH_VARARGS, NULL},
	 { (char *)"ProgressLog_fclock", _wrap_ProgressLog_fclock, METH_VARARGS, NULL},
	 { (char *)"ProgressLog_statusTime", _wrap_ProgressLog_statusTime, METH_VARARGS, NULL},
	 { (char *)"ProgressLog_init", _wrap_ProgressLog_init, METH_VARARGS, NULL},
	 { (char *)"delete_ProgressLog", _wrap_delete_ProgressLog, METH_VARARGS, NULL},
	 { (char *)"ProgressLog_swigregister", ProgressLog_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DummyForStreams", _wrap_new_DummyForStreams, METH_VARARGS, NULL},
	 { (char *)"DummyForStreams_xtox", _wrap_DummyForStreams_xtox, METH_VARARGS, NULL},
	 { (char *)"delete_DummyForStreams", _wrap_delete_DummyForStreams, METH_VARARGS, NULL},
	 { (char *)"DummyForStreams_swigregister", DummyForStreams_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LHgenericBlock", _wrap_new_LHgenericBlock, METH_VARARGS, NULL},
	 { (char *)"delete_LHgenericBlock", _wrap_delete_LHgenericBlock, METH_VARARGS, NULL},
	 { (char *)"LHgenericBlock_swigregister", LHgenericBlock_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LHdecayChannel", _wrap_new_LHdecayChannel, METH_VARARGS, NULL},
	 { (char *)"LHdecayChannel_setChannel", _wrap_LHdecayChannel_setChannel, METH_VARARGS, NULL},
	 { (char *)"LHdecayChannel_setBrat", _wrap_LHdecayChannel_setBrat, METH_VARARGS, NULL},
	 { (char *)"LHdecayChannel_setIdDa", _wrap_LHdecayChannel_setIdDa, METH_VARARGS, NULL},
	 { (char *)"LHdecayChannel_getBrat", _wrap_LHdecayChannel_getBrat, METH_VARARGS, NULL},
	 { (char *)"LHdecayChannel_getNDa", _wrap_LHdecayChannel_getNDa, METH_VARARGS, NULL},
	 { (char *)"LHdecayChannel_getIdDa", _wrap_LHdecayChannel_getIdDa, METH_VARARGS, NULL},
	 { (char *)"LHdecayChannel_getComment", _wrap_LHdecayChannel_getComment, METH_VARARGS, NULL},
	 { (char *)"delete_LHdecayChannel", _wrap_delete_LHdecayChannel, METH_VARARGS, NULL},
	 { (char *)"LHdecayChannel_swigregister", LHdecayChannel_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LHdecayTable", _wrap_new_LHdecayTable, METH_VARARGS, NULL},
	 { (char *)"LHdecayTable_getId", _wrap_LHdecayTable_getId, METH_VARARGS, NULL},
	 { (char *)"LHdecayTable_getWidth", _wrap_LHdecayTable_getWidth, METH_VARARGS, NULL},
	 { (char *)"LHdecayTable_setId", _wrap_LHdecayTable_setId, METH_VARARGS, NULL},
	 { (char *)"LHdecayTable_setWidth", _wrap_LHdecayTable_setWidth, METH_VARARGS, NULL},
	 { (char *)"LHdecayTable_reset", _wrap_LHdecayTable_reset, METH_VARARGS, NULL},
	 { (char *)"LHdecayTable_addChannel", _wrap_LHdecayTable_addChannel, METH_VARARGS, NULL},
	 { (char *)"LHdecayTable_size", _wrap_LHdecayTable_size, METH_VARARGS, NULL},
	 { (char *)"LHdecayTable_getBrat", _wrap_LHdecayTable_getBrat, METH_VARARGS, NULL},
	 { (char *)"LHdecayTable_getIdDa", _wrap_LHdecayTable_getIdDa, METH_VARARGS, NULL},
	 { (char *)"LHdecayTable_getChannel", _wrap_LHdecayTable_getChannel, METH_VARARGS, NULL},
	 { (char *)"delete_LHdecayTable", _wrap_delete_LHdecayTable, METH_VARARGS, NULL},
	 { (char *)"LHdecayTable_swigregister", LHdecayTable_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SusyLesHouches", _wrap_new_SusyLesHouches, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_readFile", _wrap_SusyLesHouches_readFile, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_listHeader", _wrap_SusyLesHouches_listHeader, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_listFooter", _wrap_SusyLesHouches_listFooter, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_listSpectrum", _wrap_SusyLesHouches_listSpectrum, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_checkSpectrum", _wrap_SusyLesHouches_checkSpectrum, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_slhaFile_set", _wrap_SusyLesHouches_slhaFile_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_slhaFile_get", _wrap_SusyLesHouches_slhaFile_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_modsel_set", _wrap_SusyLesHouches_modsel_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_modsel_get", _wrap_SusyLesHouches_modsel_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_modsel21_set", _wrap_SusyLesHouches_modsel21_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_modsel21_get", _wrap_SusyLesHouches_modsel21_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_modsel12_set", _wrap_SusyLesHouches_modsel12_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_modsel12_get", _wrap_SusyLesHouches_modsel12_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_minpar_set", _wrap_SusyLesHouches_minpar_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_minpar_get", _wrap_SusyLesHouches_minpar_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_extpar_set", _wrap_SusyLesHouches_extpar_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_extpar_get", _wrap_SusyLesHouches_extpar_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_sminputs_set", _wrap_SusyLesHouches_sminputs_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_sminputs_get", _wrap_SusyLesHouches_sminputs_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_spinfo_set", _wrap_SusyLesHouches_spinfo_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_spinfo_get", _wrap_SusyLesHouches_spinfo_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_spinfo3_set", _wrap_SusyLesHouches_spinfo3_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_spinfo3_get", _wrap_SusyLesHouches_spinfo3_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_spinfo4_set", _wrap_SusyLesHouches_spinfo4_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_spinfo4_get", _wrap_SusyLesHouches_spinfo4_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_dcinfo_set", _wrap_SusyLesHouches_dcinfo_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_dcinfo_get", _wrap_SusyLesHouches_dcinfo_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_dcinfo3_set", _wrap_SusyLesHouches_dcinfo3_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_dcinfo3_get", _wrap_SusyLesHouches_dcinfo3_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_dcinfo4_set", _wrap_SusyLesHouches_dcinfo4_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_dcinfo4_get", _wrap_SusyLesHouches_dcinfo4_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_mass_set", _wrap_SusyLesHouches_mass_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_mass_get", _wrap_SusyLesHouches_mass_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_nmix_set", _wrap_SusyLesHouches_nmix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_nmix_get", _wrap_SusyLesHouches_nmix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_umix_set", _wrap_SusyLesHouches_umix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_umix_get", _wrap_SusyLesHouches_umix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_vmix_set", _wrap_SusyLesHouches_vmix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_vmix_get", _wrap_SusyLesHouches_vmix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_stopmix_set", _wrap_SusyLesHouches_stopmix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_stopmix_get", _wrap_SusyLesHouches_stopmix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_sbotmix_set", _wrap_SusyLesHouches_sbotmix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_sbotmix_get", _wrap_SusyLesHouches_sbotmix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_staumix_set", _wrap_SusyLesHouches_staumix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_staumix_get", _wrap_SusyLesHouches_staumix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_alpha_set", _wrap_SusyLesHouches_alpha_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_alpha_get", _wrap_SusyLesHouches_alpha_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_hmix_set", _wrap_SusyLesHouches_hmix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_hmix_get", _wrap_SusyLesHouches_hmix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_gauge_set", _wrap_SusyLesHouches_gauge_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_gauge_get", _wrap_SusyLesHouches_gauge_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_msoft_set", _wrap_SusyLesHouches_msoft_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_msoft_get", _wrap_SusyLesHouches_msoft_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_au_set", _wrap_SusyLesHouches_au_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_au_get", _wrap_SusyLesHouches_au_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_ad_set", _wrap_SusyLesHouches_ad_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_ad_get", _wrap_SusyLesHouches_ad_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_ae_set", _wrap_SusyLesHouches_ae_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_ae_get", _wrap_SusyLesHouches_ae_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_yu_set", _wrap_SusyLesHouches_yu_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_yu_get", _wrap_SusyLesHouches_yu_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_yd_set", _wrap_SusyLesHouches_yd_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_yd_get", _wrap_SusyLesHouches_yd_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_ye_set", _wrap_SusyLesHouches_ye_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_ye_get", _wrap_SusyLesHouches_ye_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_decays_set", _wrap_SusyLesHouches_decays_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_decays_get", _wrap_SusyLesHouches_decays_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_decayIndices_set", _wrap_SusyLesHouches_decayIndices_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_decayIndices_get", _wrap_SusyLesHouches_decayIndices_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_qnumbers_set", _wrap_SusyLesHouches_qnumbers_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_qnumbers_get", _wrap_SusyLesHouches_qnumbers_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_qnumbersName_set", _wrap_SusyLesHouches_qnumbersName_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_qnumbersName_get", _wrap_SusyLesHouches_qnumbersName_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_qnumbersAntiName_set", _wrap_SusyLesHouches_qnumbersAntiName_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_qnumbersAntiName_get", _wrap_SusyLesHouches_qnumbersAntiName_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_qextpar_set", _wrap_SusyLesHouches_qextpar_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_qextpar_get", _wrap_SusyLesHouches_qextpar_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_vckmin_set", _wrap_SusyLesHouches_vckmin_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_vckmin_get", _wrap_SusyLesHouches_vckmin_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_upmnsin_set", _wrap_SusyLesHouches_upmnsin_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_upmnsin_get", _wrap_SusyLesHouches_upmnsin_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_msq2in_set", _wrap_SusyLesHouches_msq2in_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_msq2in_get", _wrap_SusyLesHouches_msq2in_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_msu2in_set", _wrap_SusyLesHouches_msu2in_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_msu2in_get", _wrap_SusyLesHouches_msu2in_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_msd2in_set", _wrap_SusyLesHouches_msd2in_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_msd2in_get", _wrap_SusyLesHouches_msd2in_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_msl2in_set", _wrap_SusyLesHouches_msl2in_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_msl2in_get", _wrap_SusyLesHouches_msl2in_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_mse2in_set", _wrap_SusyLesHouches_mse2in_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_mse2in_get", _wrap_SusyLesHouches_mse2in_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_tuin_set", _wrap_SusyLesHouches_tuin_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_tuin_get", _wrap_SusyLesHouches_tuin_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_tdin_set", _wrap_SusyLesHouches_tdin_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_tdin_get", _wrap_SusyLesHouches_tdin_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_tein_set", _wrap_SusyLesHouches_tein_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_tein_get", _wrap_SusyLesHouches_tein_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_vckm_set", _wrap_SusyLesHouches_vckm_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_vckm_get", _wrap_SusyLesHouches_vckm_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_upmns_set", _wrap_SusyLesHouches_upmns_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_upmns_get", _wrap_SusyLesHouches_upmns_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_msq2_set", _wrap_SusyLesHouches_msq2_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_msq2_get", _wrap_SusyLesHouches_msq2_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_msu2_set", _wrap_SusyLesHouches_msu2_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_msu2_get", _wrap_SusyLesHouches_msu2_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_msd2_set", _wrap_SusyLesHouches_msd2_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_msd2_get", _wrap_SusyLesHouches_msd2_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_msl2_set", _wrap_SusyLesHouches_msl2_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_msl2_get", _wrap_SusyLesHouches_msl2_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_mse2_set", _wrap_SusyLesHouches_mse2_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_mse2_get", _wrap_SusyLesHouches_mse2_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_tu_set", _wrap_SusyLesHouches_tu_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_tu_get", _wrap_SusyLesHouches_tu_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_td_set", _wrap_SusyLesHouches_td_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_td_get", _wrap_SusyLesHouches_td_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_te_set", _wrap_SusyLesHouches_te_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_te_get", _wrap_SusyLesHouches_te_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_usqmix_set", _wrap_SusyLesHouches_usqmix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_usqmix_get", _wrap_SusyLesHouches_usqmix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_dsqmix_set", _wrap_SusyLesHouches_dsqmix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_dsqmix_get", _wrap_SusyLesHouches_dsqmix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_selmix_set", _wrap_SusyLesHouches_selmix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_selmix_get", _wrap_SusyLesHouches_selmix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_snumix_set", _wrap_SusyLesHouches_snumix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_snumix_get", _wrap_SusyLesHouches_snumix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_snsmix_set", _wrap_SusyLesHouches_snsmix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_snsmix_get", _wrap_SusyLesHouches_snsmix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_snamix_set", _wrap_SusyLesHouches_snamix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_snamix_get", _wrap_SusyLesHouches_snamix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvlamllein_set", _wrap_SusyLesHouches_rvlamllein_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvlamllein_get", _wrap_SusyLesHouches_rvlamllein_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvlamlqdin_set", _wrap_SusyLesHouches_rvlamlqdin_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvlamlqdin_get", _wrap_SusyLesHouches_rvlamlqdin_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvlamuddin_set", _wrap_SusyLesHouches_rvlamuddin_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvlamuddin_get", _wrap_SusyLesHouches_rvlamuddin_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvtllein_set", _wrap_SusyLesHouches_rvtllein_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvtllein_get", _wrap_SusyLesHouches_rvtllein_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvtlqdin_set", _wrap_SusyLesHouches_rvtlqdin_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvtlqdin_get", _wrap_SusyLesHouches_rvtlqdin_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvtuddin_set", _wrap_SusyLesHouches_rvtuddin_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvtuddin_get", _wrap_SusyLesHouches_rvtuddin_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvkappain_set", _wrap_SusyLesHouches_rvkappain_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvkappain_get", _wrap_SusyLesHouches_rvkappain_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvdin_set", _wrap_SusyLesHouches_rvdin_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvdin_get", _wrap_SusyLesHouches_rvdin_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvm2lh1in_set", _wrap_SusyLesHouches_rvm2lh1in_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvm2lh1in_get", _wrap_SusyLesHouches_rvm2lh1in_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvsnvevin_set", _wrap_SusyLesHouches_rvsnvevin_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvsnvevin_get", _wrap_SusyLesHouches_rvsnvevin_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvlamlle_set", _wrap_SusyLesHouches_rvlamlle_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvlamlle_get", _wrap_SusyLesHouches_rvlamlle_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvlamlqd_set", _wrap_SusyLesHouches_rvlamlqd_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvlamlqd_get", _wrap_SusyLesHouches_rvlamlqd_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvlamudd_set", _wrap_SusyLesHouches_rvlamudd_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvlamudd_get", _wrap_SusyLesHouches_rvlamudd_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvtlle_set", _wrap_SusyLesHouches_rvtlle_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvtlle_get", _wrap_SusyLesHouches_rvtlle_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvtlqd_set", _wrap_SusyLesHouches_rvtlqd_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvtlqd_get", _wrap_SusyLesHouches_rvtlqd_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvtudd_set", _wrap_SusyLesHouches_rvtudd_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvtudd_get", _wrap_SusyLesHouches_rvtudd_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvkappa_set", _wrap_SusyLesHouches_rvkappa_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvkappa_get", _wrap_SusyLesHouches_rvkappa_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvd_set", _wrap_SusyLesHouches_rvd_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvd_get", _wrap_SusyLesHouches_rvd_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvm2lh1_set", _wrap_SusyLesHouches_rvm2lh1_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvm2lh1_get", _wrap_SusyLesHouches_rvm2lh1_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvsnvev_set", _wrap_SusyLesHouches_rvsnvev_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvsnvev_get", _wrap_SusyLesHouches_rvsnvev_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvnmix_set", _wrap_SusyLesHouches_rvnmix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvnmix_get", _wrap_SusyLesHouches_rvnmix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvumix_set", _wrap_SusyLesHouches_rvumix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvumix_get", _wrap_SusyLesHouches_rvumix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvvmix_set", _wrap_SusyLesHouches_rvvmix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvvmix_get", _wrap_SusyLesHouches_rvvmix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvhmix_set", _wrap_SusyLesHouches_rvhmix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvhmix_get", _wrap_SusyLesHouches_rvhmix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvamix_set", _wrap_SusyLesHouches_rvamix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvamix_get", _wrap_SusyLesHouches_rvamix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvlmix_set", _wrap_SusyLesHouches_rvlmix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_rvlmix_get", _wrap_SusyLesHouches_rvlmix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imminpar_set", _wrap_SusyLesHouches_imminpar_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imminpar_get", _wrap_SusyLesHouches_imminpar_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imextpar_set", _wrap_SusyLesHouches_imextpar_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imextpar_get", _wrap_SusyLesHouches_imextpar_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_cvhmix_set", _wrap_SusyLesHouches_cvhmix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_cvhmix_get", _wrap_SusyLesHouches_cvhmix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imcvhmix_set", _wrap_SusyLesHouches_imcvhmix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imcvhmix_get", _wrap_SusyLesHouches_imcvhmix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imau_set", _wrap_SusyLesHouches_imau_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imau_get", _wrap_SusyLesHouches_imau_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imad_set", _wrap_SusyLesHouches_imad_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imad_get", _wrap_SusyLesHouches_imad_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imae_set", _wrap_SusyLesHouches_imae_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imae_get", _wrap_SusyLesHouches_imae_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imhmix_set", _wrap_SusyLesHouches_imhmix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imhmix_get", _wrap_SusyLesHouches_imhmix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_immsoft_set", _wrap_SusyLesHouches_immsoft_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_immsoft_get", _wrap_SusyLesHouches_immsoft_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_immsq2in_set", _wrap_SusyLesHouches_immsq2in_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_immsq2in_get", _wrap_SusyLesHouches_immsq2in_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_immsu2in_set", _wrap_SusyLesHouches_immsu2in_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_immsu2in_get", _wrap_SusyLesHouches_immsu2in_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_immsd2in_set", _wrap_SusyLesHouches_immsd2in_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_immsd2in_get", _wrap_SusyLesHouches_immsd2in_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_immsl2in_set", _wrap_SusyLesHouches_immsl2in_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_immsl2in_get", _wrap_SusyLesHouches_immsl2in_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_immse2in_set", _wrap_SusyLesHouches_immse2in_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_immse2in_get", _wrap_SusyLesHouches_immse2in_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imtuin_set", _wrap_SusyLesHouches_imtuin_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imtuin_get", _wrap_SusyLesHouches_imtuin_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imtdin_set", _wrap_SusyLesHouches_imtdin_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imtdin_get", _wrap_SusyLesHouches_imtdin_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imtein_set", _wrap_SusyLesHouches_imtein_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imtein_get", _wrap_SusyLesHouches_imtein_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imvckm_set", _wrap_SusyLesHouches_imvckm_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imvckm_get", _wrap_SusyLesHouches_imvckm_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imupmns_set", _wrap_SusyLesHouches_imupmns_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imupmns_get", _wrap_SusyLesHouches_imupmns_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_immsq2_set", _wrap_SusyLesHouches_immsq2_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_immsq2_get", _wrap_SusyLesHouches_immsq2_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_immsu2_set", _wrap_SusyLesHouches_immsu2_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_immsu2_get", _wrap_SusyLesHouches_immsu2_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_immsd2_set", _wrap_SusyLesHouches_immsd2_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_immsd2_get", _wrap_SusyLesHouches_immsd2_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_immsl2_set", _wrap_SusyLesHouches_immsl2_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_immsl2_get", _wrap_SusyLesHouches_immsl2_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_immse2_set", _wrap_SusyLesHouches_immse2_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_immse2_get", _wrap_SusyLesHouches_immse2_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imtu_set", _wrap_SusyLesHouches_imtu_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imtu_get", _wrap_SusyLesHouches_imtu_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imtd_set", _wrap_SusyLesHouches_imtd_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imtd_get", _wrap_SusyLesHouches_imtd_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imte_set", _wrap_SusyLesHouches_imte_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imte_get", _wrap_SusyLesHouches_imte_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imusqmix_set", _wrap_SusyLesHouches_imusqmix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imusqmix_get", _wrap_SusyLesHouches_imusqmix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imdsqmix_set", _wrap_SusyLesHouches_imdsqmix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imdsqmix_get", _wrap_SusyLesHouches_imdsqmix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imselmix_set", _wrap_SusyLesHouches_imselmix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imselmix_get", _wrap_SusyLesHouches_imselmix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imsnumix_set", _wrap_SusyLesHouches_imsnumix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imsnumix_get", _wrap_SusyLesHouches_imsnumix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imnmix_set", _wrap_SusyLesHouches_imnmix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imnmix_get", _wrap_SusyLesHouches_imnmix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imumix_set", _wrap_SusyLesHouches_imumix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imumix_get", _wrap_SusyLesHouches_imumix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imvmix_set", _wrap_SusyLesHouches_imvmix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imvmix_get", _wrap_SusyLesHouches_imvmix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_nmssmrun_set", _wrap_SusyLesHouches_nmssmrun_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_nmssmrun_get", _wrap_SusyLesHouches_nmssmrun_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_nmhmix_set", _wrap_SusyLesHouches_nmhmix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_nmhmix_get", _wrap_SusyLesHouches_nmhmix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_nmamix_set", _wrap_SusyLesHouches_nmamix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_nmamix_get", _wrap_SusyLesHouches_nmamix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_nmnmix_set", _wrap_SusyLesHouches_nmnmix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_nmnmix_get", _wrap_SusyLesHouches_nmnmix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imnmnmix_set", _wrap_SusyLesHouches_imnmnmix_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_imnmnmix_get", _wrap_SusyLesHouches_imnmnmix_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_genericBlocks_set", _wrap_SusyLesHouches_genericBlocks_set, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_genericBlocks_get", _wrap_SusyLesHouches_genericBlocks_get, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_verbose", _wrap_SusyLesHouches_verbose, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_message", _wrap_SusyLesHouches_message, METH_VARARGS, NULL},
	 { (char *)"delete_SusyLesHouches", _wrap_delete_SusyLesHouches, METH_VARARGS, NULL},
	 { (char *)"SusyLesHouches_swigregister", SusyLesHouches_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_WeakShowerMEs", _wrap_new_WeakShowerMEs, METH_VARARGS, NULL},
	 { (char *)"WeakShowerMEs_getMEqg2qg", _wrap_WeakShowerMEs_getMEqg2qg, METH_VARARGS, NULL},
	 { (char *)"WeakShowerMEs_getMEqq2qq", _wrap_WeakShowerMEs_getMEqq2qq, METH_VARARGS, NULL},
	 { (char *)"WeakShowerMEs_getMEgg2gg", _wrap_WeakShowerMEs_getMEgg2gg, METH_VARARGS, NULL},
	 { (char *)"WeakShowerMEs_getMEgg2qqbar", _wrap_WeakShowerMEs_getMEgg2qqbar, METH_VARARGS, NULL},
	 { (char *)"WeakShowerMEs_getMEqqbar2gg", _wrap_WeakShowerMEs_getMEqqbar2gg, METH_VARARGS, NULL},
	 { (char *)"WeakShowerMEs_getMEqqbar2qqbar", _wrap_WeakShowerMEs_getMEqqbar2qqbar, METH_VARARGS, NULL},
	 { (char *)"WeakShowerMEs_getMEqg2qgZ", _wrap_WeakShowerMEs_getMEqg2qgZ, METH_VARARGS, NULL},
	 { (char *)"WeakShowerMEs_getMEqq2qqZ", _wrap_WeakShowerMEs_getMEqq2qqZ, METH_VARARGS, NULL},
	 { (char *)"delete_WeakShowerMEs", _wrap_delete_WeakShowerMEs, METH_VARARGS, NULL},
	 { (char *)"WeakShowerMEs_swigregister", WeakShowerMEs_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Info", _wrap_new_Info, METH_VARARGS, NULL},
	 { (char *)"Info_idA", _wrap_Info_idA, METH_VARARGS, NULL},
	 { (char *)"Info_idB", _wrap_Info_idB, METH_VARARGS, NULL},
	 { (char *)"Info_pzA", _wrap_Info_pzA, METH_VARARGS, NULL},
	 { (char *)"Info_pzB", _wrap_Info_pzB, METH_VARARGS, NULL},
	 { (char *)"Info_eA", _wrap_Info_eA, METH_VARARGS, NULL},
	 { (char *)"Info_eB", _wrap_Info_eB, METH_VARARGS, NULL},
	 { (char *)"Info_mA", _wrap_Info_mA, METH_VARARGS, NULL},
	 { (char *)"Info_mB", _wrap_Info_mB, METH_VARARGS, NULL},
	 { (char *)"Info_eCM", _wrap_Info_eCM, METH_VARARGS, NULL},
	 { (char *)"Info_s", _wrap_Info_s, METH_VARARGS, NULL},
	 { (char *)"Info_tooLowPTmin", _wrap_Info_tooLowPTmin, METH_VARARGS, NULL},
	 { (char *)"Info_name", _wrap_Info_name, METH_VARARGS, NULL},
	 { (char *)"Info_code", _wrap_Info_code, METH_VARARGS, NULL},
	 { (char *)"Info_nFinal", _wrap_Info_nFinal, METH_VARARGS, NULL},
	 { (char *)"Info_isResolved", _wrap_Info_isResolved, METH_VARARGS, NULL},
	 { (char *)"Info_isDiffractiveA", _wrap_Info_isDiffractiveA, METH_VARARGS, NULL},
	 { (char *)"Info_isDiffractiveB", _wrap_Info_isDiffractiveB, METH_VARARGS, NULL},
	 { (char *)"Info_isDiffractiveC", _wrap_Info_isDiffractiveC, METH_VARARGS, NULL},
	 { (char *)"Info_isNonDiffractive", _wrap_Info_isNonDiffractive, METH_VARARGS, NULL},
	 { (char *)"Info_isMinBias", _wrap_Info_isMinBias, METH_VARARGS, NULL},
	 { (char *)"Info_isLHA", _wrap_Info_isLHA, METH_VARARGS, NULL},
	 { (char *)"Info_atEndOfFile", _wrap_Info_atEndOfFile, METH_VARARGS, NULL},
	 { (char *)"Info_hasSub", _wrap_Info_hasSub, METH_VARARGS, NULL},
	 { (char *)"Info_nameSub", _wrap_Info_nameSub, METH_VARARGS, NULL},
	 { (char *)"Info_codeSub", _wrap_Info_codeSub, METH_VARARGS, NULL},
	 { (char *)"Info_nFinalSub", _wrap_Info_nFinalSub, METH_VARARGS, NULL},
	 { (char *)"Info_id1", _wrap_Info_id1, METH_VARARGS, NULL},
	 { (char *)"Info_id2", _wrap_Info_id2, METH_VARARGS, NULL},
	 { (char *)"Info_x1", _wrap_Info_x1, METH_VARARGS, NULL},
	 { (char *)"Info_x2", _wrap_Info_x2, METH_VARARGS, NULL},
	 { (char *)"Info_y", _wrap_Info_y, METH_VARARGS, NULL},
	 { (char *)"Info_tau", _wrap_Info_tau, METH_VARARGS, NULL},
	 { (char *)"Info_id1pdf", _wrap_Info_id1pdf, METH_VARARGS, NULL},
	 { (char *)"Info_id2pdf", _wrap_Info_id2pdf, METH_VARARGS, NULL},
	 { (char *)"Info_x1pdf", _wrap_Info_x1pdf, METH_VARARGS, NULL},
	 { (char *)"Info_x2pdf", _wrap_Info_x2pdf, METH_VARARGS, NULL},
	 { (char *)"Info_pdf1", _wrap_Info_pdf1, METH_VARARGS, NULL},
	 { (char *)"Info_pdf2", _wrap_Info_pdf2, METH_VARARGS, NULL},
	 { (char *)"Info_QFac", _wrap_Info_QFac, METH_VARARGS, NULL},
	 { (char *)"Info_Q2Fac", _wrap_Info_Q2Fac, METH_VARARGS, NULL},
	 { (char *)"Info_isValence1", _wrap_Info_isValence1, METH_VARARGS, NULL},
	 { (char *)"Info_isValence2", _wrap_Info_isValence2, METH_VARARGS, NULL},
	 { (char *)"Info_alphaS", _wrap_Info_alphaS, METH_VARARGS, NULL},
	 { (char *)"Info_alphaEM", _wrap_Info_alphaEM, METH_VARARGS, NULL},
	 { (char *)"Info_QRen", _wrap_Info_QRen, METH_VARARGS, NULL},
	 { (char *)"Info_Q2Ren", _wrap_Info_Q2Ren, METH_VARARGS, NULL},
	 { (char *)"Info_scalup", _wrap_Info_scalup, METH_VARARGS, NULL},
	 { (char *)"Info_xGammaA", _wrap_Info_xGammaA, METH_VARARGS, NULL},
	 { (char *)"Info_xGammaB", _wrap_Info_xGammaB, METH_VARARGS, NULL},
	 { (char *)"Info_Q2GammaA", _wrap_Info_Q2GammaA, METH_VARARGS, NULL},
	 { (char *)"Info_Q2GammaB", _wrap_Info_Q2GammaB, METH_VARARGS, NULL},
	 { (char *)"Info_eCMsub", _wrap_Info_eCMsub, METH_VARARGS, NULL},
	 { (char *)"Info_thetaScatLepA", _wrap_Info_thetaScatLepA, METH_VARARGS, NULL},
	 { (char *)"Info_thetaScatLepB", _wrap_Info_thetaScatLepB, METH_VARARGS, NULL},
	 { (char *)"Info_sHatNew", _wrap_Info_sHatNew, METH_VARARGS, NULL},
	 { (char *)"Info_photonMode", _wrap_Info_photonMode, METH_VARARGS, NULL},
	 { (char *)"Info_isVMDstateA", _wrap_Info_isVMDstateA, METH_VARARGS, NULL},
	 { (char *)"Info_isVMDstateB", _wrap_Info_isVMDstateB, METH_VARARGS, NULL},
	 { (char *)"Info_idVMDA", _wrap_Info_idVMDA, METH_VARARGS, NULL},
	 { (char *)"Info_idVMDB", _wrap_Info_idVMDB, METH_VARARGS, NULL},
	 { (char *)"Info_mVMDA", _wrap_Info_mVMDA, METH_VARARGS, NULL},
	 { (char *)"Info_mVMDB", _wrap_Info_mVMDB, METH_VARARGS, NULL},
	 { (char *)"Info_scaleVMDA", _wrap_Info_scaleVMDA, METH_VARARGS, NULL},
	 { (char *)"Info_scaleVMDB", _wrap_Info_scaleVMDB, METH_VARARGS, NULL},
	 { (char *)"Info_mHat", _wrap_Info_mHat, METH_VARARGS, NULL},
	 { (char *)"Info_sHat", _wrap_Info_sHat, METH_VARARGS, NULL},
	 { (char *)"Info_tHat", _wrap_Info_tHat, METH_VARARGS, NULL},
	 { (char *)"Info_uHat", _wrap_Info_uHat, METH_VARARGS, NULL},
	 { (char *)"Info_pTHat", _wrap_Info_pTHat, METH_VARARGS, NULL},
	 { (char *)"Info_pT2Hat", _wrap_Info_pT2Hat, METH_VARARGS, NULL},
	 { (char *)"Info_m3Hat", _wrap_Info_m3Hat, METH_VARARGS, NULL},
	 { (char *)"Info_m4Hat", _wrap_Info_m4Hat, METH_VARARGS, NULL},
	 { (char *)"Info_thetaHat", _wrap_Info_thetaHat, METH_VARARGS, NULL},
	 { (char *)"Info_phiHat", _wrap_Info_phiHat, METH_VARARGS, NULL},
	 { (char *)"Info_weight", _wrap_Info_weight, METH_VARARGS, NULL},
	 { (char *)"Info_weightSum", _wrap_Info_weightSum, METH_VARARGS, NULL},
	 { (char *)"Info_lhaStrategy", _wrap_Info_lhaStrategy, METH_VARARGS, NULL},
	 { (char *)"Info_nWeights", _wrap_Info_nWeights, METH_VARARGS, NULL},
	 { (char *)"Info_weightLabel", _wrap_Info_weightLabel, METH_VARARGS, NULL},
	 { (char *)"Info_initUncertainties", _wrap_Info_initUncertainties, METH_VARARGS, NULL},
	 { (char *)"Info_nVariationGroups", _wrap_Info_nVariationGroups, METH_VARARGS, NULL},
	 { (char *)"Info_getGroupName", _wrap_Info_getGroupName, METH_VARARGS, NULL},
	 { (char *)"Info_getGroupWeight", _wrap_Info_getGroupWeight, METH_VARARGS, NULL},
	 { (char *)"Info_getInitialName", _wrap_Info_getInitialName, METH_VARARGS, NULL},
	 { (char *)"Info_varPDFplus_set", _wrap_Info_varPDFplus_set, METH_VARARGS, NULL},
	 { (char *)"Info_varPDFplus_get", _wrap_Info_varPDFplus_get, METH_VARARGS, NULL},
	 { (char *)"Info_varPDFminus_set", _wrap_Info_varPDFminus_set, METH_VARARGS, NULL},
	 { (char *)"Info_varPDFminus_get", _wrap_Info_varPDFminus_get, METH_VARARGS, NULL},
	 { (char *)"Info_varPDFmember_set", _wrap_Info_varPDFmember_set, METH_VARARGS, NULL},
	 { (char *)"Info_varPDFmember_get", _wrap_Info_varPDFmember_get, METH_VARARGS, NULL},
	 { (char *)"Info_nISR", _wrap_Info_nISR, METH_VARARGS, NULL},
	 { (char *)"Info_nFSRinProc", _wrap_Info_nFSRinProc, METH_VARARGS, NULL},
	 { (char *)"Info_nFSRinRes", _wrap_Info_nFSRinRes, METH_VARARGS, NULL},
	 { (char *)"Info_pTmaxMPI", _wrap_Info_pTmaxMPI, METH_VARARGS, NULL},
	 { (char *)"Info_pTmaxISR", _wrap_Info_pTmaxISR, METH_VARARGS, NULL},
	 { (char *)"Info_pTmaxFSR", _wrap_Info_pTmaxFSR, METH_VARARGS, NULL},
	 { (char *)"Info_pTnow", _wrap_Info_pTnow, METH_VARARGS, NULL},
	 { (char *)"Info_a0MPI", _wrap_Info_a0MPI, METH_VARARGS, NULL},
	 { (char *)"Info_bMPI", _wrap_Info_bMPI, METH_VARARGS, NULL},
	 { (char *)"Info_enhanceMPI", _wrap_Info_enhanceMPI, METH_VARARGS, NULL},
	 { (char *)"Info_enhanceMPIavg", _wrap_Info_enhanceMPIavg, METH_VARARGS, NULL},
	 { (char *)"Info_eMPI", _wrap_Info_eMPI, METH_VARARGS, NULL},
	 { (char *)"Info_bMPIold", _wrap_Info_bMPIold, METH_VARARGS, NULL},
	 { (char *)"Info_enhanceMPIold", _wrap_Info_enhanceMPIold, METH_VARARGS, NULL},
	 { (char *)"Info_enhanceMPIoldavg", _wrap_Info_enhanceMPIoldavg, METH_VARARGS, NULL},
	 { (char *)"Info_nMPI", _wrap_Info_nMPI, METH_VARARGS, NULL},
	 { (char *)"Info_codeMPI", _wrap_Info_codeMPI, METH_VARARGS, NULL},
	 { (char *)"Info_pTMPI", _wrap_Info_pTMPI, METH_VARARGS, NULL},
	 { (char *)"Info_iAMPI", _wrap_Info_iAMPI, METH_VARARGS, NULL},
	 { (char *)"Info_iBMPI", _wrap_Info_iBMPI, METH_VARARGS, NULL},
	 { (char *)"Info_codesHard", _wrap_Info_codesHard, METH_VARARGS, NULL},
	 { (char *)"Info_nameProc", _wrap_Info_nameProc, METH_VARARGS, NULL},
	 { (char *)"Info_nTried", _wrap_Info_nTried, METH_VARARGS, NULL},
	 { (char *)"Info_nSelected", _wrap_Info_nSelected, METH_VARARGS, NULL},
	 { (char *)"Info_nAccepted", _wrap_Info_nAccepted, METH_VARARGS, NULL},
	 { (char *)"Info_sigmaGen", _wrap_Info_sigmaGen, METH_VARARGS, NULL},
	 { (char *)"Info_sigmaErr", _wrap_Info_sigmaErr, METH_VARARGS, NULL},
	 { (char *)"Info_getCounter", _wrap_Info_getCounter, METH_VARARGS, NULL},
	 { (char *)"Info_setCounter", _wrap_Info_setCounter, METH_VARARGS, NULL},
	 { (char *)"Info_addCounter", _wrap_Info_addCounter, METH_VARARGS, NULL},
	 { (char *)"Info_errorReset", _wrap_Info_errorReset, METH_VARARGS, NULL},
	 { (char *)"Info_errorMsg", _wrap_Info_errorMsg, METH_VARARGS, NULL},
	 { (char *)"Info_errorTotalNumber", _wrap_Info_errorTotalNumber, METH_VARARGS, NULL},
	 { (char *)"Info_errorStatistics", _wrap_Info_errorStatistics, METH_VARARGS, NULL},
	 { (char *)"Info_setTooLowPTmin", _wrap_Info_setTooLowPTmin, METH_VARARGS, NULL},
	 { (char *)"Info_setValence", _wrap_Info_setValence, METH_VARARGS, NULL},
	 { (char *)"Info_hasHistory", _wrap_Info_hasHistory, METH_VARARGS, NULL},
	 { (char *)"Info_zNowISR", _wrap_Info_zNowISR, METH_VARARGS, NULL},
	 { (char *)"Info_pT2NowISR", _wrap_Info_pT2NowISR, METH_VARARGS, NULL},
	 { (char *)"Info_updateWeight", _wrap_Info_updateWeight, METH_VARARGS, NULL},
	 { (char *)"Info_getWeightCKKWL", _wrap_Info_getWeightCKKWL, METH_VARARGS, NULL},
	 { (char *)"Info_setWeightCKKWL", _wrap_Info_setWeightCKKWL, METH_VARARGS, NULL},
	 { (char *)"Info_mergingWeight", _wrap_Info_mergingWeight, METH_VARARGS, NULL},
	 { (char *)"Info_mergingWeightNLO", _wrap_Info_mergingWeightNLO, METH_VARARGS, NULL},
	 { (char *)"Info_getWeightFIRST", _wrap_Info_getWeightFIRST, METH_VARARGS, NULL},
	 { (char *)"Info_setWeightFIRST", _wrap_Info_setWeightFIRST, METH_VARARGS, NULL},
	 { (char *)"Info_header", _wrap_Info_header, METH_VARARGS, NULL},
	 { (char *)"Info_headerKeys", _wrap_Info_headerKeys, METH_VARARGS, NULL},
	 { (char *)"Info_nProcessesLHEF", _wrap_Info_nProcessesLHEF, METH_VARARGS, NULL},
	 { (char *)"Info_sigmaLHEF", _wrap_Info_sigmaLHEF, METH_VARARGS, NULL},
	 { (char *)"Info_LHEFversionSave_set", _wrap_Info_LHEFversionSave_set, METH_VARARGS, NULL},
	 { (char *)"Info_LHEFversionSave_get", _wrap_Info_LHEFversionSave_get, METH_VARARGS, NULL},
	 { (char *)"Info_sigmaLHEFSave_set", _wrap_Info_sigmaLHEFSave_set, METH_VARARGS, NULL},
	 { (char *)"Info_sigmaLHEFSave_get", _wrap_Info_sigmaLHEFSave_get, METH_VARARGS, NULL},
	 { (char *)"Info_initrwgt_set", _wrap_Info_initrwgt_set, METH_VARARGS, NULL},
	 { (char *)"Info_initrwgt_get", _wrap_Info_initrwgt_get, METH_VARARGS, NULL},
	 { (char *)"Info_generators_set", _wrap_Info_generators_set, METH_VARARGS, NULL},
	 { (char *)"Info_generators_get", _wrap_Info_generators_get, METH_VARARGS, NULL},
	 { (char *)"Info_weightgroups_set", _wrap_Info_weightgroups_set, METH_VARARGS, NULL},
	 { (char *)"Info_weightgroups_get", _wrap_Info_weightgroups_get, METH_VARARGS, NULL},
	 { (char *)"Info_init_weights_set", _wrap_Info_init_weights_set, METH_VARARGS, NULL},
	 { (char *)"Info_init_weights_get", _wrap_Info_init_weights_get, METH_VARARGS, NULL},
	 { (char *)"Info_eventAttributes_set", _wrap_Info_eventAttributes_set, METH_VARARGS, NULL},
	 { (char *)"Info_eventAttributes_get", _wrap_Info_eventAttributes_get, METH_VARARGS, NULL},
	 { (char *)"Info_weights_detailed_set", _wrap_Info_weights_detailed_set, METH_VARARGS, NULL},
	 { (char *)"Info_weights_detailed_get", _wrap_Info_weights_detailed_get, METH_VARARGS, NULL},
	 { (char *)"Info_weights_compressed_set", _wrap_Info_weights_compressed_set, METH_VARARGS, NULL},
	 { (char *)"Info_weights_compressed_get", _wrap_Info_weights_compressed_get, METH_VARARGS, NULL},
	 { (char *)"Info_scales_set", _wrap_Info_scales_set, METH_VARARGS, NULL},
	 { (char *)"Info_scales_get", _wrap_Info_scales_get, METH_VARARGS, NULL},
	 { (char *)"Info_weights_set", _wrap_Info_weights_set, METH_VARARGS, NULL},
	 { (char *)"Info_weights_get", _wrap_Info_weights_get, METH_VARARGS, NULL},
	 { (char *)"Info_rwgt_set", _wrap_Info_rwgt_set, METH_VARARGS, NULL},
	 { (char *)"Info_rwgt_get", _wrap_Info_rwgt_get, METH_VARARGS, NULL},
	 { (char *)"Info_eventWeightLHEF_set", _wrap_Info_eventWeightLHEF_set, METH_VARARGS, NULL},
	 { (char *)"Info_eventWeightLHEF_get", _wrap_Info_eventWeightLHEF_get, METH_VARARGS, NULL},
	 { (char *)"Info_setLHEF3InitInfo", _wrap_Info_setLHEF3InitInfo, METH_VARARGS, NULL},
	 { (char *)"Info_setLHEF3EventInfo", _wrap_Info_setLHEF3EventInfo, METH_VARARGS, NULL},
	 { (char *)"Info_getEventAttribute", _wrap_Info_getEventAttribute, METH_VARARGS, NULL},
	 { (char *)"Info_LHEFversion", _wrap_Info_LHEFversion, METH_VARARGS, NULL},
	 { (char *)"Info_getInitrwgtSize", _wrap_Info_getInitrwgtSize, METH_VARARGS, NULL},
	 { (char *)"Info_getGeneratorSize", _wrap_Info_getGeneratorSize, METH_VARARGS, NULL},
	 { (char *)"Info_getGeneratorValue", _wrap_Info_getGeneratorValue, METH_VARARGS, NULL},
	 { (char *)"Info_getGeneratorAttribute", _wrap_Info_getGeneratorAttribute, METH_VARARGS, NULL},
	 { (char *)"Info_getWeightsDetailedSize", _wrap_Info_getWeightsDetailedSize, METH_VARARGS, NULL},
	 { (char *)"Info_getWeightsDetailedValue", _wrap_Info_getWeightsDetailedValue, METH_VARARGS, NULL},
	 { (char *)"Info_getWeightsDetailedAttribute", _wrap_Info_getWeightsDetailedAttribute, METH_VARARGS, NULL},
	 { (char *)"Info_getWeightsCompressedSize", _wrap_Info_getWeightsCompressedSize, METH_VARARGS, NULL},
	 { (char *)"Info_getWeightsCompressedValue", _wrap_Info_getWeightsCompressedValue, METH_VARARGS, NULL},
	 { (char *)"Info_getWeightsCompressedAttribute", _wrap_Info_getWeightsCompressedAttribute, METH_VARARGS, NULL},
	 { (char *)"Info_getScalesValue", _wrap_Info_getScalesValue, METH_VARARGS, NULL},
	 { (char *)"Info_getScalesAttribute", _wrap_Info_getScalesAttribute, METH_VARARGS, NULL},
	 { (char *)"Info_getHeaderBlock", _wrap_Info_getHeaderBlock, METH_VARARGS, NULL},
	 { (char *)"Info_getEventComments", _wrap_Info_getEventComments, METH_VARARGS, NULL},
	 { (char *)"Info_setHeader", _wrap_Info_setHeader, METH_VARARGS, NULL},
	 { (char *)"Info_setAbortPartonLevel", _wrap_Info_setAbortPartonLevel, METH_VARARGS, NULL},
	 { (char *)"Info_getAbortPartonLevel", _wrap_Info_getAbortPartonLevel, METH_VARARGS, NULL},
	 { (char *)"Info_hasUnresolvedBeams", _wrap_Info_hasUnresolvedBeams, METH_VARARGS, NULL},
	 { (char *)"Info_hasPomPsystem", _wrap_Info_hasPomPsystem, METH_VARARGS, NULL},
	 { (char *)"Info_isHardDiffractive", _wrap_Info_isHardDiffractive, METH_VARARGS, NULL},
	 { (char *)"Info_isHardDiffractiveA", _wrap_Info_isHardDiffractiveA, METH_VARARGS, NULL},
	 { (char *)"Info_isHardDiffractiveB", _wrap_Info_isHardDiffractiveB, METH_VARARGS, NULL},
	 { (char *)"Info_xPomeronA", _wrap_Info_xPomeronA, METH_VARARGS, NULL},
	 { (char *)"Info_xPomeronB", _wrap_Info_xPomeronB, METH_VARARGS, NULL},
	 { (char *)"Info_tPomeronA", _wrap_Info_tPomeronA, METH_VARARGS, NULL},
	 { (char *)"Info_tPomeronB", _wrap_Info_tPomeronB, METH_VARARGS, NULL},
	 { (char *)"Info_getWeakModes", _wrap_Info_getWeakModes, METH_VARARGS, NULL},
	 { (char *)"Info_getWeakDipoles", _wrap_Info_getWeakDipoles, METH_VARARGS, NULL},
	 { (char *)"Info_getWeakMomenta", _wrap_Info_getWeakMomenta, METH_VARARGS, NULL},
	 { (char *)"Info_getWeak2to2lines", _wrap_Info_getWeak2to2lines, METH_VARARGS, NULL},
	 { (char *)"Info_setWeakModes", _wrap_Info_setWeakModes, METH_VARARGS, NULL},
	 { (char *)"Info_setWeakDipoles", _wrap_Info_setWeakDipoles, METH_VARARGS, NULL},
	 { (char *)"Info_setWeakMomenta", _wrap_Info_setWeakMomenta, METH_VARARGS, NULL},
	 { (char *)"Info_setWeak2to2lines", _wrap_Info_setWeak2to2lines, METH_VARARGS, NULL},
	 { (char *)"Info_hiinfo_set", _wrap_Info_hiinfo_set, METH_VARARGS, NULL},
	 { (char *)"Info_hiinfo_get", _wrap_Info_hiinfo_get, METH_VARARGS, NULL},
	 { (char *)"Info___str__", _wrap_Info___str__, METH_VARARGS, NULL},
	 { (char *)"delete_Info", _wrap_delete_Info, METH_VARARGS, NULL},
	 { (char *)"Info_swigregister", Info_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Flag", _wrap_new_Flag, METH_VARARGS, NULL},
	 { (char *)"Flag_name_set", _wrap_Flag_name_set, METH_VARARGS, NULL},
	 { (char *)"Flag_name_get", _wrap_Flag_name_get, METH_VARARGS, NULL},
	 { (char *)"Flag_valNow_set", _wrap_Flag_valNow_set, METH_VARARGS, NULL},
	 { (char *)"Flag_valNow_get", _wrap_Flag_valNow_get, METH_VARARGS, NULL},
	 { (char *)"Flag_valDefault_set", _wrap_Flag_valDefault_set, METH_VARARGS, NULL},
	 { (char *)"Flag_valDefault_get", _wrap_Flag_valDefault_get, METH_VARARGS, NULL},
	 { (char *)"delete_Flag", _wrap_delete_Flag, METH_VARARGS, NULL},
	 { (char *)"Flag_swigregister", Flag_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Mode", _wrap_new_Mode, METH_VARARGS, NULL},
	 { (char *)"Mode_name_set", _wrap_Mode_name_set, METH_VARARGS, NULL},
	 { (char *)"Mode_name_get", _wrap_Mode_name_get, METH_VARARGS, NULL},
	 { (char *)"Mode_valNow_set", _wrap_Mode_valNow_set, METH_VARARGS, NULL},
	 { (char *)"Mode_valNow_get", _wrap_Mode_valNow_get, METH_VARARGS, NULL},
	 { (char *)"Mode_valDefault_set", _wrap_Mode_valDefault_set, METH_VARARGS, NULL},
	 { (char *)"Mode_valDefault_get", _wrap_Mode_valDefault_get, METH_VARARGS, NULL},
	 { (char *)"Mode_hasMin_set", _wrap_Mode_hasMin_set, METH_VARARGS, NULL},
	 { (char *)"Mode_hasMin_get", _wrap_Mode_hasMin_get, METH_VARARGS, NULL},
	 { (char *)"Mode_hasMax_set", _wrap_Mode_hasMax_set, METH_VARARGS, NULL},
	 { (char *)"Mode_hasMax_get", _wrap_Mode_hasMax_get, METH_VARARGS, NULL},
	 { (char *)"Mode_valMin_set", _wrap_Mode_valMin_set, METH_VARARGS, NULL},
	 { (char *)"Mode_valMin_get", _wrap_Mode_valMin_get, METH_VARARGS, NULL},
	 { (char *)"Mode_valMax_set", _wrap_Mode_valMax_set, METH_VARARGS, NULL},
	 { (char *)"Mode_valMax_get", _wrap_Mode_valMax_get, METH_VARARGS, NULL},
	 { (char *)"Mode_optOnly_set", _wrap_Mode_optOnly_set, METH_VARARGS, NULL},
	 { (char *)"Mode_optOnly_get", _wrap_Mode_optOnly_get, METH_VARARGS, NULL},
	 { (char *)"delete_Mode", _wrap_delete_Mode, METH_VARARGS, NULL},
	 { (char *)"Mode_swigregister", Mode_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Parm", _wrap_new_Parm, METH_VARARGS, NULL},
	 { (char *)"Parm_name_set", _wrap_Parm_name_set, METH_VARARGS, NULL},
	 { (char *)"Parm_name_get", _wrap_Parm_name_get, METH_VARARGS, NULL},
	 { (char *)"Parm_valNow_set", _wrap_Parm_valNow_set, METH_VARARGS, NULL},
	 { (char *)"Parm_valNow_get", _wrap_Parm_valNow_get, METH_VARARGS, NULL},
	 { (char *)"Parm_valDefault_set", _wrap_Parm_valDefault_set, METH_VARARGS, NULL},
	 { (char *)"Parm_valDefault_get", _wrap_Parm_valDefault_get, METH_VARARGS, NULL},
	 { (char *)"Parm_hasMin_set", _wrap_Parm_hasMin_set, METH_VARARGS, NULL},
	 { (char *)"Parm_hasMin_get", _wrap_Parm_hasMin_get, METH_VARARGS, NULL},
	 { (char *)"Parm_hasMax_set", _wrap_Parm_hasMax_set, METH_VARARGS, NULL},
	 { (char *)"Parm_hasMax_get", _wrap_Parm_hasMax_get, METH_VARARGS, NULL},
	 { (char *)"Parm_valMin_set", _wrap_Parm_valMin_set, METH_VARARGS, NULL},
	 { (char *)"Parm_valMin_get", _wrap_Parm_valMin_get, METH_VARARGS, NULL},
	 { (char *)"Parm_valMax_set", _wrap_Parm_valMax_set, METH_VARARGS, NULL},
	 { (char *)"Parm_valMax_get", _wrap_Parm_valMax_get, METH_VARARGS, NULL},
	 { (char *)"delete_Parm", _wrap_delete_Parm, METH_VARARGS, NULL},
	 { (char *)"Parm_swigregister", Parm_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Word", _wrap_new_Word, METH_VARARGS, NULL},
	 { (char *)"Word_name_set", _wrap_Word_name_set, METH_VARARGS, NULL},
	 { (char *)"Word_name_get", _wrap_Word_name_get, METH_VARARGS, NULL},
	 { (char *)"Word_valNow_set", _wrap_Word_valNow_set, METH_VARARGS, NULL},
	 { (char *)"Word_valNow_get", _wrap_Word_valNow_get, METH_VARARGS, NULL},
	 { (char *)"Word_valDefault_set", _wrap_Word_valDefault_set, METH_VARARGS, NULL},
	 { (char *)"Word_valDefault_get", _wrap_Word_valDefault_get, METH_VARARGS, NULL},
	 { (char *)"delete_Word", _wrap_delete_Word, METH_VARARGS, NULL},
	 { (char *)"Word_swigregister", Word_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FVec", _wrap_new_FVec, METH_VARARGS, NULL},
	 { (char *)"FVec_name_set", _wrap_FVec_name_set, METH_VARARGS, NULL},
	 { (char *)"FVec_name_get", _wrap_FVec_name_get, METH_VARARGS, NULL},
	 { (char *)"FVec_valNow_set", _wrap_FVec_valNow_set, METH_VARARGS, NULL},
	 { (char *)"FVec_valNow_get", _wrap_FVec_valNow_get, METH_VARARGS, NULL},
	 { (char *)"FVec_valDefault_set", _wrap_FVec_valDefault_set, METH_VARARGS, NULL},
	 { (char *)"FVec_valDefault_get", _wrap_FVec_valDefault_get, METH_VARARGS, NULL},
	 { (char *)"delete_FVec", _wrap_delete_FVec, METH_VARARGS, NULL},
	 { (char *)"FVec_swigregister", FVec_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MVec", _wrap_new_MVec, METH_VARARGS, NULL},
	 { (char *)"MVec_name_set", _wrap_MVec_name_set, METH_VARARGS, NULL},
	 { (char *)"MVec_name_get", _wrap_MVec_name_get, METH_VARARGS, NULL},
	 { (char *)"MVec_valNow_set", _wrap_MVec_valNow_set, METH_VARARGS, NULL},
	 { (char *)"MVec_valNow_get", _wrap_MVec_valNow_get, METH_VARARGS, NULL},
	 { (char *)"MVec_valDefault_set", _wrap_MVec_valDefault_set, METH_VARARGS, NULL},
	 { (char *)"MVec_valDefault_get", _wrap_MVec_valDefault_get, METH_VARARGS, NULL},
	 { (char *)"MVec_hasMin_set", _wrap_MVec_hasMin_set, METH_VARARGS, NULL},
	 { (char *)"MVec_hasMin_get", _wrap_MVec_hasMin_get, METH_VARARGS, NULL},
	 { (char *)"MVec_hasMax_set", _wrap_MVec_hasMax_set, METH_VARARGS, NULL},
	 { (char *)"MVec_hasMax_get", _wrap_MVec_hasMax_get, METH_VARARGS, NULL},
	 { (char *)"MVec_valMin_set", _wrap_MVec_valMin_set, METH_VARARGS, NULL},
	 { (char *)"MVec_valMin_get", _wrap_MVec_valMin_get, METH_VARARGS, NULL},
	 { (char *)"MVec_valMax_set", _wrap_MVec_valMax_set, METH_VARARGS, NULL},
	 { (char *)"MVec_valMax_get", _wrap_MVec_valMax_get, METH_VARARGS, NULL},
	 { (char *)"delete_MVec", _wrap_delete_MVec, METH_VARARGS, NULL},
	 { (char *)"MVec_swigregister", MVec_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PVec", _wrap_new_PVec, METH_VARARGS, NULL},
	 { (char *)"PVec_name_set", _wrap_PVec_name_set, METH_VARARGS, NULL},
	 { (char *)"PVec_name_get", _wrap_PVec_name_get, METH_VARARGS, NULL},
	 { (char *)"PVec_valNow_set", _wrap_PVec_valNow_set, METH_VARARGS, NULL},
	 { (char *)"PVec_valNow_get", _wrap_PVec_valNow_get, METH_VARARGS, NULL},
	 { (char *)"PVec_valDefault_set", _wrap_PVec_valDefault_set, METH_VARARGS, NULL},
	 { (char *)"PVec_valDefault_get", _wrap_PVec_valDefault_get, METH_VARARGS, NULL},
	 { (char *)"PVec_hasMin_set", _wrap_PVec_hasMin_set, METH_VARARGS, NULL},
	 { (char *)"PVec_hasMin_get", _wrap_PVec_hasMin_get, METH_VARARGS, NULL},
	 { (char *)"PVec_hasMax_set", _wrap_PVec_hasMax_set, METH_VARARGS, NULL},
	 { (char *)"PVec_hasMax_get", _wrap_PVec_hasMax_get, METH_VARARGS, NULL},
	 { (char *)"PVec_valMin_set", _wrap_PVec_valMin_set, METH_VARARGS, NULL},
	 { (char *)"PVec_valMin_get", _wrap_PVec_valMin_get, METH_VARARGS, NULL},
	 { (char *)"PVec_valMax_set", _wrap_PVec_valMax_set, METH_VARARGS, NULL},
	 { (char *)"PVec_valMax_get", _wrap_PVec_valMax_get, METH_VARARGS, NULL},
	 { (char *)"delete_PVec", _wrap_delete_PVec, METH_VARARGS, NULL},
	 { (char *)"PVec_swigregister", PVec_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_WVec", _wrap_new_WVec, METH_VARARGS, NULL},
	 { (char *)"WVec_name_set", _wrap_WVec_name_set, METH_VARARGS, NULL},
	 { (char *)"WVec_name_get", _wrap_WVec_name_get, METH_VARARGS, NULL},
	 { (char *)"WVec_valNow_set", _wrap_WVec_valNow_set, METH_VARARGS, NULL},
	 { (char *)"WVec_valNow_get", _wrap_WVec_valNow_get, METH_VARARGS, NULL},
	 { (char *)"WVec_valDefault_set", _wrap_WVec_valDefault_set, METH_VARARGS, NULL},
	 { (char *)"WVec_valDefault_get", _wrap_WVec_valDefault_get, METH_VARARGS, NULL},
	 { (char *)"delete_WVec", _wrap_delete_WVec, METH_VARARGS, NULL},
	 { (char *)"WVec_swigregister", WVec_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Settings", _wrap_new_Settings, METH_VARARGS, NULL},
	 { (char *)"Settings_initPtr", _wrap_Settings_initPtr, METH_VARARGS, NULL},
	 { (char *)"Settings_init", _wrap_Settings_init, METH_VARARGS, NULL},
	 { (char *)"Settings_reInit", _wrap_Settings_reInit, METH_VARARGS, NULL},
	 { (char *)"Settings_readString", _wrap_Settings_readString, METH_VARARGS, NULL},
	 { (char *)"Settings_writeFile", _wrap_Settings_writeFile, METH_VARARGS, NULL},
	 { (char *)"Settings_writeFileXML", _wrap_Settings_writeFileXML, METH_VARARGS, NULL},
	 { (char *)"Settings_listAll", _wrap_Settings_listAll, METH_VARARGS, NULL},
	 { (char *)"Settings_listChanged", _wrap_Settings_listChanged, METH_VARARGS, NULL},
	 { (char *)"Settings_output", _wrap_Settings_output, METH_VARARGS, NULL},
	 { (char *)"Settings_getReadHistory", _wrap_Settings_getReadHistory, METH_VARARGS, NULL},
	 { (char *)"Settings_resetAll", _wrap_Settings_resetAll, METH_VARARGS, NULL},
	 { (char *)"Settings_isFlag", _wrap_Settings_isFlag, METH_VARARGS, NULL},
	 { (char *)"Settings_isMode", _wrap_Settings_isMode, METH_VARARGS, NULL},
	 { (char *)"Settings_isParm", _wrap_Settings_isParm, METH_VARARGS, NULL},
	 { (char *)"Settings_isWord", _wrap_Settings_isWord, METH_VARARGS, NULL},
	 { (char *)"Settings_isFVec", _wrap_Settings_isFVec, METH_VARARGS, NULL},
	 { (char *)"Settings_isMVec", _wrap_Settings_isMVec, METH_VARARGS, NULL},
	 { (char *)"Settings_isPVec", _wrap_Settings_isPVec, METH_VARARGS, NULL},
	 { (char *)"Settings_isWVec", _wrap_Settings_isWVec, METH_VARARGS, NULL},
	 { (char *)"Settings_addFlag", _wrap_Settings_addFlag, METH_VARARGS, NULL},
	 { (char *)"Settings_addMode", _wrap_Settings_addMode, METH_VARARGS, NULL},
	 { (char *)"Settings_addParm", _wrap_Settings_addParm, METH_VARARGS, NULL},
	 { (char *)"Settings_addWord", _wrap_Settings_addWord, METH_VARARGS, NULL},
	 { (char *)"Settings_addFVec", _wrap_Settings_addFVec, METH_VARARGS, NULL},
	 { (char *)"Settings_addMVec", _wrap_Settings_addMVec, METH_VARARGS, NULL},
	 { (char *)"Settings_addPVec", _wrap_Settings_addPVec, METH_VARARGS, NULL},
	 { (char *)"Settings_addWVec", _wrap_Settings_addWVec, METH_VARARGS, NULL},
	 { (char *)"Settings_flagDefault", _wrap_Settings_flagDefault, METH_VARARGS, NULL},
	 { (char *)"Settings_modeDefault", _wrap_Settings_modeDefault, METH_VARARGS, NULL},
	 { (char *)"Settings_parmDefault", _wrap_Settings_parmDefault, METH_VARARGS, NULL},
	 { (char *)"Settings_wordDefault", _wrap_Settings_wordDefault, METH_VARARGS, NULL},
	 { (char *)"Settings_fvecDefault", _wrap_Settings_fvecDefault, METH_VARARGS, NULL},
	 { (char *)"Settings_mvecDefault", _wrap_Settings_mvecDefault, METH_VARARGS, NULL},
	 { (char *)"Settings_pvecDefault", _wrap_Settings_pvecDefault, METH_VARARGS, NULL},
	 { (char *)"Settings_wvecDefault", _wrap_Settings_wvecDefault, METH_VARARGS, NULL},
	 { (char *)"Settings_getFlagMap", _wrap_Settings_getFlagMap, METH_VARARGS, NULL},
	 { (char *)"Settings_getModeMap", _wrap_Settings_getModeMap, METH_VARARGS, NULL},
	 { (char *)"Settings_getParmMap", _wrap_Settings_getParmMap, METH_VARARGS, NULL},
	 { (char *)"Settings_getWordMap", _wrap_Settings_getWordMap, METH_VARARGS, NULL},
	 { (char *)"Settings_getFVecMap", _wrap_Settings_getFVecMap, METH_VARARGS, NULL},
	 { (char *)"Settings_getMVecMap", _wrap_Settings_getMVecMap, METH_VARARGS, NULL},
	 { (char *)"Settings_getPVecMap", _wrap_Settings_getPVecMap, METH_VARARGS, NULL},
	 { (char *)"Settings_getWVecMap", _wrap_Settings_getWVecMap, METH_VARARGS, NULL},
	 { (char *)"Settings_flag", _wrap_Settings_flag, METH_VARARGS, NULL},
	 { (char *)"Settings_mode", _wrap_Settings_mode, METH_VARARGS, NULL},
	 { (char *)"Settings_parm", _wrap_Settings_parm, METH_VARARGS, NULL},
	 { (char *)"Settings_word", _wrap_Settings_word, METH_VARARGS, NULL},
	 { (char *)"Settings_fvec", _wrap_Settings_fvec, METH_VARARGS, NULL},
	 { (char *)"Settings_mvec", _wrap_Settings_mvec, METH_VARARGS, NULL},
	 { (char *)"Settings_pvec", _wrap_Settings_pvec, METH_VARARGS, NULL},
	 { (char *)"Settings_wvec", _wrap_Settings_wvec, METH_VARARGS, NULL},
	 { (char *)"Settings_forceMode", _wrap_Settings_forceMode, METH_VARARGS, NULL},
	 { (char *)"Settings_forceParm", _wrap_Settings_forceParm, METH_VARARGS, NULL},
	 { (char *)"Settings_forceMVec", _wrap_Settings_forceMVec, METH_VARARGS, NULL},
	 { (char *)"Settings_forcePVec", _wrap_Settings_forcePVec, METH_VARARGS, NULL},
	 { (char *)"Settings_resetFlag", _wrap_Settings_resetFlag, METH_VARARGS, NULL},
	 { (char *)"Settings_resetMode", _wrap_Settings_resetMode, METH_VARARGS, NULL},
	 { (char *)"Settings_resetParm", _wrap_Settings_resetParm, METH_VARARGS, NULL},
	 { (char *)"Settings_resetWord", _wrap_Settings_resetWord, METH_VARARGS, NULL},
	 { (char *)"Settings_resetFVec", _wrap_Settings_resetFVec, METH_VARARGS, NULL},
	 { (char *)"Settings_resetMVec", _wrap_Settings_resetMVec, METH_VARARGS, NULL},
	 { (char *)"Settings_resetPVec", _wrap_Settings_resetPVec, METH_VARARGS, NULL},
	 { (char *)"Settings_resetWVec", _wrap_Settings_resetWVec, METH_VARARGS, NULL},
	 { (char *)"Settings_getIsInit", _wrap_Settings_getIsInit, METH_VARARGS, NULL},
	 { (char *)"Settings_readingFailed", _wrap_Settings_readingFailed, METH_VARARGS, NULL},
	 { (char *)"Settings_unfinishedInput", _wrap_Settings_unfinishedInput, METH_VARARGS, NULL},
	 { (char *)"delete_Settings", _wrap_delete_Settings, METH_VARARGS, NULL},
	 { (char *)"Settings_swigregister", Settings_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AlphaStrong", _wrap_new_AlphaStrong, METH_VARARGS, NULL},
	 { (char *)"delete_AlphaStrong", _wrap_delete_AlphaStrong, METH_VARARGS, NULL},
	 { (char *)"AlphaStrong_init", _wrap_AlphaStrong_init, METH_VARARGS, NULL},
	 { (char *)"AlphaStrong_setThresholds", _wrap_AlphaStrong_setThresholds, METH_VARARGS, NULL},
	 { (char *)"AlphaStrong_alphaS", _wrap_AlphaStrong_alphaS, METH_VARARGS, NULL},
	 { (char *)"AlphaStrong_alphaS1Ord", _wrap_AlphaStrong_alphaS1Ord, METH_VARARGS, NULL},
	 { (char *)"AlphaStrong_alphaS2OrdCorr", _wrap_AlphaStrong_alphaS2OrdCorr, METH_VARARGS, NULL},
	 { (char *)"AlphaStrong_Lambda3", _wrap_AlphaStrong_Lambda3, METH_VARARGS, NULL},
	 { (char *)"AlphaStrong_Lambda4", _wrap_AlphaStrong_Lambda4, METH_VARARGS, NULL},
	 { (char *)"AlphaStrong_Lambda5", _wrap_AlphaStrong_Lambda5, METH_VARARGS, NULL},
	 { (char *)"AlphaStrong_Lambda6", _wrap_AlphaStrong_Lambda6, METH_VARARGS, NULL},
	 { (char *)"AlphaStrong_muThres", _wrap_AlphaStrong_muThres, METH_VARARGS, NULL},
	 { (char *)"AlphaStrong_muThres2", _wrap_AlphaStrong_muThres2, METH_VARARGS, NULL},
	 { (char *)"AlphaStrong_facCMW", _wrap_AlphaStrong_facCMW, METH_VARARGS, NULL},
	 { (char *)"AlphaStrong_swigregister", AlphaStrong_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AlphaEM", _wrap_new_AlphaEM, METH_VARARGS, NULL},
	 { (char *)"AlphaEM_init", _wrap_AlphaEM_init, METH_VARARGS, NULL},
	 { (char *)"AlphaEM_alphaEM", _wrap_AlphaEM_alphaEM, METH_VARARGS, NULL},
	 { (char *)"delete_AlphaEM", _wrap_delete_AlphaEM, METH_VARARGS, NULL},
	 { (char *)"AlphaEM_swigregister", AlphaEM_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CoupSM", _wrap_new_CoupSM, METH_VARARGS, NULL},
	 { (char *)"CoupSM_init", _wrap_CoupSM_init, METH_VARARGS, NULL},
	 { (char *)"CoupSM_alphaS", _wrap_CoupSM_alphaS, METH_VARARGS, NULL},
	 { (char *)"CoupSM_alphaS1Ord", _wrap_CoupSM_alphaS1Ord, METH_VARARGS, NULL},
	 { (char *)"CoupSM_alphaS2OrdCorr", _wrap_CoupSM_alphaS2OrdCorr, METH_VARARGS, NULL},
	 { (char *)"CoupSM_Lambda3", _wrap_CoupSM_Lambda3, METH_VARARGS, NULL},
	 { (char *)"CoupSM_Lambda4", _wrap_CoupSM_Lambda4, METH_VARARGS, NULL},
	 { (char *)"CoupSM_Lambda5", _wrap_CoupSM_Lambda5, METH_VARARGS, NULL},
	 { (char *)"CoupSM_alphaEM", _wrap_CoupSM_alphaEM, METH_VARARGS, NULL},
	 { (char *)"CoupSM_sin2thetaW", _wrap_CoupSM_sin2thetaW, METH_VARARGS, NULL},
	 { (char *)"CoupSM_cos2thetaW", _wrap_CoupSM_cos2thetaW, METH_VARARGS, NULL},
	 { (char *)"CoupSM_sin2thetaWbar", _wrap_CoupSM_sin2thetaWbar, METH_VARARGS, NULL},
	 { (char *)"CoupSM_GF", _wrap_CoupSM_GF, METH_VARARGS, NULL},
	 { (char *)"CoupSM_ef", _wrap_CoupSM_ef, METH_VARARGS, NULL},
	 { (char *)"CoupSM_vf", _wrap_CoupSM_vf, METH_VARARGS, NULL},
	 { (char *)"CoupSM_af", _wrap_CoupSM_af, METH_VARARGS, NULL},
	 { (char *)"CoupSM_t3f", _wrap_CoupSM_t3f, METH_VARARGS, NULL},
	 { (char *)"CoupSM_lf", _wrap_CoupSM_lf, METH_VARARGS, NULL},
	 { (char *)"CoupSM_rf", _wrap_CoupSM_rf, METH_VARARGS, NULL},
	 { (char *)"CoupSM_ef2", _wrap_CoupSM_ef2, METH_VARARGS, NULL},
	 { (char *)"CoupSM_vf2", _wrap_CoupSM_vf2, METH_VARARGS, NULL},
	 { (char *)"CoupSM_af2", _wrap_CoupSM_af2, METH_VARARGS, NULL},
	 { (char *)"CoupSM_efvf", _wrap_CoupSM_efvf, METH_VARARGS, NULL},
	 { (char *)"CoupSM_vf2af2", _wrap_CoupSM_vf2af2, METH_VARARGS, NULL},
	 { (char *)"CoupSM_VCKMgen", _wrap_CoupSM_VCKMgen, METH_VARARGS, NULL},
	 { (char *)"CoupSM_V2CKMgen", _wrap_CoupSM_V2CKMgen, METH_VARARGS, NULL},
	 { (char *)"CoupSM_VCKMid", _wrap_CoupSM_VCKMid, METH_VARARGS, NULL},
	 { (char *)"CoupSM_V2CKMid", _wrap_CoupSM_V2CKMid, METH_VARARGS, NULL},
	 { (char *)"CoupSM_V2CKMsum", _wrap_CoupSM_V2CKMsum, METH_VARARGS, NULL},
	 { (char *)"CoupSM_V2CKMpick", _wrap_CoupSM_V2CKMpick, METH_VARARGS, NULL},
	 { (char *)"delete_CoupSM", _wrap_delete_CoupSM, METH_VARARGS, NULL},
	 { (char *)"CoupSM_swigregister", CoupSM_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Couplings", _wrap_new_Couplings, METH_VARARGS, NULL},
	 { (char *)"Couplings_isSUSY_set", _wrap_Couplings_isSUSY_set, METH_VARARGS, NULL},
	 { (char *)"Couplings_isSUSY_get", _wrap_Couplings_isSUSY_get, METH_VARARGS, NULL},
	 { (char *)"delete_Couplings", _wrap_delete_Couplings, METH_VARARGS, NULL},
	 { (char *)"Couplings_swigregister", Couplings_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CoupSUSY", _wrap_new_CoupSUSY, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_initSUSY", _wrap_CoupSUSY_initSUSY, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_isInit_set", _wrap_CoupSUSY_isInit_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_isInit_get", _wrap_CoupSUSY_isInit_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_isNMSSM_set", _wrap_CoupSUSY_isNMSSM_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_isNMSSM_get", _wrap_CoupSUSY_isNMSSM_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_isLLE_set", _wrap_CoupSUSY_isLLE_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_isLLE_get", _wrap_CoupSUSY_isLLE_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_isLQD_set", _wrap_CoupSUSY_isLQD_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_isLQD_get", _wrap_CoupSUSY_isLQD_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_isUDD_set", _wrap_CoupSUSY_isUDD_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_isUDD_get", _wrap_CoupSUSY_isUDD_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_mWpole_set", _wrap_CoupSUSY_mWpole_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_mWpole_get", _wrap_CoupSUSY_mWpole_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_wWpole_set", _wrap_CoupSUSY_wWpole_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_wWpole_get", _wrap_CoupSUSY_wWpole_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_mZpole_set", _wrap_CoupSUSY_mZpole_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_mZpole_get", _wrap_CoupSUSY_mZpole_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_wZpole_set", _wrap_CoupSUSY_wZpole_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_wZpole_get", _wrap_CoupSUSY_wZpole_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_mW_set", _wrap_CoupSUSY_mW_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_mW_get", _wrap_CoupSUSY_mW_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_mZ_set", _wrap_CoupSUSY_mZ_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_mZ_get", _wrap_CoupSUSY_mZ_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_sin2W_set", _wrap_CoupSUSY_sin2W_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_sin2W_get", _wrap_CoupSUSY_sin2W_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_sinW_set", _wrap_CoupSUSY_sinW_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_sinW_get", _wrap_CoupSUSY_sinW_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_cosW_set", _wrap_CoupSUSY_cosW_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_cosW_get", _wrap_CoupSUSY_cosW_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_tanb_set", _wrap_CoupSUSY_tanb_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_tanb_get", _wrap_CoupSUSY_tanb_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_cosb_set", _wrap_CoupSUSY_cosb_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_cosb_get", _wrap_CoupSUSY_cosb_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_sinb_set", _wrap_CoupSUSY_sinb_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_sinb_get", _wrap_CoupSUSY_sinb_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_muHiggs_set", _wrap_CoupSUSY_muHiggs_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_muHiggs_get", _wrap_CoupSUSY_muHiggs_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_alphaHiggs_set", _wrap_CoupSUSY_alphaHiggs_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_alphaHiggs_get", _wrap_CoupSUSY_alphaHiggs_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_mAHiggs_set", _wrap_CoupSUSY_mAHiggs_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_mAHiggs_get", _wrap_CoupSUSY_mAHiggs_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_LsddG_set", _wrap_CoupSUSY_LsddG_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_LsddG_get", _wrap_CoupSUSY_LsddG_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_RsddG_set", _wrap_CoupSUSY_RsddG_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_RsddG_get", _wrap_CoupSUSY_RsddG_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_LsuuG_set", _wrap_CoupSUSY_LsuuG_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_LsuuG_get", _wrap_CoupSUSY_LsuuG_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_RsuuG_set", _wrap_CoupSUSY_RsuuG_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_RsuuG_get", _wrap_CoupSUSY_RsuuG_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_getLsqqG", _wrap_CoupSUSY_getLsqqG, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_getRsqqG", _wrap_CoupSUSY_getRsqqG, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_OLpp_set", _wrap_CoupSUSY_OLpp_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_OLpp_get", _wrap_CoupSUSY_OLpp_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_ORpp_set", _wrap_CoupSUSY_ORpp_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_ORpp_get", _wrap_CoupSUSY_ORpp_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_OLp_set", _wrap_CoupSUSY_OLp_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_OLp_get", _wrap_CoupSUSY_OLp_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_ORp_set", _wrap_CoupSUSY_ORp_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_ORp_get", _wrap_CoupSUSY_ORp_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_OL_set", _wrap_CoupSUSY_OL_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_OL_get", _wrap_CoupSUSY_OL_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_OR_set", _wrap_CoupSUSY_OR_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_OR_get", _wrap_CoupSUSY_OR_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_LqqZ_set", _wrap_CoupSUSY_LqqZ_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_LqqZ_get", _wrap_CoupSUSY_LqqZ_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_RqqZ_set", _wrap_CoupSUSY_RqqZ_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_RqqZ_get", _wrap_CoupSUSY_RqqZ_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_LsdsdZ_set", _wrap_CoupSUSY_LsdsdZ_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_LsdsdZ_get", _wrap_CoupSUSY_LsdsdZ_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_RsdsdZ_set", _wrap_CoupSUSY_RsdsdZ_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_RsdsdZ_get", _wrap_CoupSUSY_RsdsdZ_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_LsusuZ_set", _wrap_CoupSUSY_LsusuZ_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_LsusuZ_get", _wrap_CoupSUSY_LsusuZ_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_RsusuZ_set", _wrap_CoupSUSY_RsusuZ_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_RsusuZ_get", _wrap_CoupSUSY_RsusuZ_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_getLsqsqZ", _wrap_CoupSUSY_getLsqsqZ, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_getRsqsqZ", _wrap_CoupSUSY_getRsqsqZ, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_LudW_set", _wrap_CoupSUSY_LudW_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_LudW_get", _wrap_CoupSUSY_LudW_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_RudW_set", _wrap_CoupSUSY_RudW_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_RudW_get", _wrap_CoupSUSY_RudW_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_LsusdW_set", _wrap_CoupSUSY_LsusdW_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_LsusdW_get", _wrap_CoupSUSY_LsusdW_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_RsusdW_set", _wrap_CoupSUSY_RsusdW_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_RsusdW_get", _wrap_CoupSUSY_RsusdW_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_getLsqqX", _wrap_CoupSUSY_getLsqqX, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_getRsqqX", _wrap_CoupSUSY_getRsqqX, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_LllZ_set", _wrap_CoupSUSY_LllZ_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_LllZ_get", _wrap_CoupSUSY_LllZ_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_RllZ_set", _wrap_CoupSUSY_RllZ_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_RllZ_get", _wrap_CoupSUSY_RllZ_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_LlvW_set", _wrap_CoupSUSY_LlvW_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_LlvW_get", _wrap_CoupSUSY_LlvW_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_RlvW_set", _wrap_CoupSUSY_RlvW_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_RlvW_get", _wrap_CoupSUSY_RlvW_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_LslslZ_set", _wrap_CoupSUSY_LslslZ_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_LslslZ_get", _wrap_CoupSUSY_LslslZ_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_RslslZ_set", _wrap_CoupSUSY_RslslZ_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_RslslZ_get", _wrap_CoupSUSY_RslslZ_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_LsvsvZ_set", _wrap_CoupSUSY_LsvsvZ_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_LsvsvZ_get", _wrap_CoupSUSY_LsvsvZ_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_RsvsvZ_set", _wrap_CoupSUSY_RsvsvZ_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_RsvsvZ_get", _wrap_CoupSUSY_RsvsvZ_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_LslsvW_set", _wrap_CoupSUSY_LslsvW_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_LslsvW_get", _wrap_CoupSUSY_LslsvW_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_RslsvW_set", _wrap_CoupSUSY_RslsvW_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_RslsvW_get", _wrap_CoupSUSY_RslsvW_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_Rusq_set", _wrap_CoupSUSY_Rusq_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_Rusq_get", _wrap_CoupSUSY_Rusq_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_Rdsq_set", _wrap_CoupSUSY_Rdsq_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_Rdsq_get", _wrap_CoupSUSY_Rdsq_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_Rsl_set", _wrap_CoupSUSY_Rsl_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_Rsl_get", _wrap_CoupSUSY_Rsl_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_Rsv_set", _wrap_CoupSUSY_Rsv_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_Rsv_get", _wrap_CoupSUSY_Rsv_get, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_idNeut", _wrap_CoupSUSY_idNeut, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_idChar", _wrap_CoupSUSY_idChar, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_idSup", _wrap_CoupSUSY_idSup, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_idSdown", _wrap_CoupSUSY_idSdown, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_idSlep", _wrap_CoupSUSY_idSlep, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_typeNeut", _wrap_CoupSUSY_typeNeut, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_typeChar", _wrap_CoupSUSY_typeChar, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_slhaPtr_set", _wrap_CoupSUSY_slhaPtr_set, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_slhaPtr_get", _wrap_CoupSUSY_slhaPtr_get, METH_VARARGS, NULL},
	 { (char *)"delete_CoupSUSY", _wrap_delete_CoupSUSY, METH_VARARGS, NULL},
	 { (char *)"CoupSUSY_swigregister", CoupSUSY_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BeamShape", _wrap_new_BeamShape, METH_VARARGS, NULL},
	 { (char *)"delete_BeamShape", _wrap_delete_BeamShape, METH_VARARGS, NULL},
	 { (char *)"BeamShape_init", _wrap_BeamShape_init, METH_VARARGS, NULL},
	 { (char *)"BeamShape_pick", _wrap_BeamShape_pick, METH_VARARGS, NULL},
	 { (char *)"BeamShape_deltaPA", _wrap_BeamShape_deltaPA, METH_VARARGS, NULL},
	 { (char *)"BeamShape_deltaPB", _wrap_BeamShape_deltaPB, METH_VARARGS, NULL},
	 { (char *)"BeamShape_vertex", _wrap_BeamShape_vertex, METH_VARARGS, NULL},
	 { (char *)"BeamShape_deltaPxA_set", _wrap_BeamShape_deltaPxA_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_deltaPxA_get", _wrap_BeamShape_deltaPxA_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_deltaPyA_set", _wrap_BeamShape_deltaPyA_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_deltaPyA_get", _wrap_BeamShape_deltaPyA_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_deltaPzA_set", _wrap_BeamShape_deltaPzA_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_deltaPzA_get", _wrap_BeamShape_deltaPzA_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_deltaPxB_set", _wrap_BeamShape_deltaPxB_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_deltaPxB_get", _wrap_BeamShape_deltaPxB_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_deltaPyB_set", _wrap_BeamShape_deltaPyB_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_deltaPyB_get", _wrap_BeamShape_deltaPyB_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_deltaPzB_set", _wrap_BeamShape_deltaPzB_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_deltaPzB_get", _wrap_BeamShape_deltaPzB_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_vertexX_set", _wrap_BeamShape_vertexX_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_vertexX_get", _wrap_BeamShape_vertexX_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_vertexY_set", _wrap_BeamShape_vertexY_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_vertexY_get", _wrap_BeamShape_vertexY_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_vertexZ_set", _wrap_BeamShape_vertexZ_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_vertexZ_get", _wrap_BeamShape_vertexZ_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_vertexT_set", _wrap_BeamShape_vertexT_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_vertexT_get", _wrap_BeamShape_vertexT_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_allowMomentumSpread_set", _wrap_BeamShape_allowMomentumSpread_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_allowMomentumSpread_get", _wrap_BeamShape_allowMomentumSpread_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_allowVertexSpread_set", _wrap_BeamShape_allowVertexSpread_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_allowVertexSpread_get", _wrap_BeamShape_allowVertexSpread_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_sigmaPxA_set", _wrap_BeamShape_sigmaPxA_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_sigmaPxA_get", _wrap_BeamShape_sigmaPxA_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_sigmaPyA_set", _wrap_BeamShape_sigmaPyA_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_sigmaPyA_get", _wrap_BeamShape_sigmaPyA_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_sigmaPzA_set", _wrap_BeamShape_sigmaPzA_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_sigmaPzA_get", _wrap_BeamShape_sigmaPzA_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_maxDevA_set", _wrap_BeamShape_maxDevA_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_maxDevA_get", _wrap_BeamShape_maxDevA_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_sigmaPxB_set", _wrap_BeamShape_sigmaPxB_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_sigmaPxB_get", _wrap_BeamShape_sigmaPxB_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_sigmaPyB_set", _wrap_BeamShape_sigmaPyB_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_sigmaPyB_get", _wrap_BeamShape_sigmaPyB_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_sigmaPzB_set", _wrap_BeamShape_sigmaPzB_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_sigmaPzB_get", _wrap_BeamShape_sigmaPzB_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_maxDevB_set", _wrap_BeamShape_maxDevB_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_maxDevB_get", _wrap_BeamShape_maxDevB_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_sigmaVertexX_set", _wrap_BeamShape_sigmaVertexX_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_sigmaVertexX_get", _wrap_BeamShape_sigmaVertexX_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_sigmaVertexY_set", _wrap_BeamShape_sigmaVertexY_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_sigmaVertexY_get", _wrap_BeamShape_sigmaVertexY_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_sigmaVertexZ_set", _wrap_BeamShape_sigmaVertexZ_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_sigmaVertexZ_get", _wrap_BeamShape_sigmaVertexZ_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_maxDevVertex_set", _wrap_BeamShape_maxDevVertex_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_maxDevVertex_get", _wrap_BeamShape_maxDevVertex_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_sigmaTime_set", _wrap_BeamShape_sigmaTime_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_sigmaTime_get", _wrap_BeamShape_sigmaTime_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_maxDevTime_set", _wrap_BeamShape_maxDevTime_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_maxDevTime_get", _wrap_BeamShape_maxDevTime_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_offsetX_set", _wrap_BeamShape_offsetX_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_offsetX_get", _wrap_BeamShape_offsetX_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_offsetY_set", _wrap_BeamShape_offsetY_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_offsetY_get", _wrap_BeamShape_offsetY_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_offsetZ_set", _wrap_BeamShape_offsetZ_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_offsetZ_get", _wrap_BeamShape_offsetZ_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_offsetT_set", _wrap_BeamShape_offsetT_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_offsetT_get", _wrap_BeamShape_offsetT_get, METH_VARARGS, NULL},
	 { (char *)"BeamShape_rndmPtr_set", _wrap_BeamShape_rndmPtr_set, METH_VARARGS, NULL},
	 { (char *)"BeamShape_rndmPtr_get", _wrap_BeamShape_rndmPtr_get, METH_VARARGS, NULL},
	 { (char *)"disown_BeamShape", _wrap_disown_BeamShape, METH_VARARGS, NULL},
	 { (char *)"BeamShape_swigregister", BeamShape_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DecayChannel", _wrap_new_DecayChannel, METH_VARARGS, NULL},
	 { (char *)"DecayChannel_rescaleBR", _wrap_DecayChannel_rescaleBR, METH_VARARGS, NULL},
	 { (char *)"DecayChannel_setHasChanged", _wrap_DecayChannel_setHasChanged, METH_VARARGS, NULL},
	 { (char *)"DecayChannel_onMode", _wrap_DecayChannel_onMode, METH_VARARGS, NULL},
	 { (char *)"DecayChannel_bRatio", _wrap_DecayChannel_bRatio, METH_VARARGS, NULL},
	 { (char *)"DecayChannel_meMode", _wrap_DecayChannel_meMode, METH_VARARGS, NULL},
	 { (char *)"DecayChannel_multiplicity", _wrap_DecayChannel_multiplicity, METH_VARARGS, NULL},
	 { (char *)"DecayChannel_product", _wrap_DecayChannel_product, METH_VARARGS, NULL},
	 { (char *)"DecayChannel_hasChanged", _wrap_DecayChannel_hasChanged, METH_VARARGS, NULL},
	 { (char *)"DecayChannel_contains", _wrap_DecayChannel_contains, METH_VARARGS, NULL},
	 { (char *)"DecayChannel_currentBR", _wrap_DecayChannel_currentBR, METH_VARARGS, NULL},
	 { (char *)"DecayChannel_onShellWidth", _wrap_DecayChannel_onShellWidth, METH_VARARGS, NULL},
	 { (char *)"DecayChannel_onShellWidthFactor", _wrap_DecayChannel_onShellWidthFactor, METH_VARARGS, NULL},
	 { (char *)"DecayChannel_openSec", _wrap_DecayChannel_openSec, METH_VARARGS, NULL},
	 { (char *)"delete_DecayChannel", _wrap_delete_DecayChannel, METH_VARARGS, NULL},
	 { (char *)"DecayChannel_swigregister", DecayChannel_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ParticleDataEntry", _wrap_new_ParticleDataEntry, METH_VARARGS, NULL},
	 { (char *)"delete_ParticleDataEntry", _wrap_delete_ParticleDataEntry, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_setDefaults", _wrap_ParticleDataEntry_setDefaults, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_initPtr", _wrap_ParticleDataEntry_initPtr, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_setAll", _wrap_ParticleDataEntry_setAll, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_setName", _wrap_ParticleDataEntry_setName, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_setAntiName", _wrap_ParticleDataEntry_setAntiName, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_setNames", _wrap_ParticleDataEntry_setNames, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_setSpinType", _wrap_ParticleDataEntry_setSpinType, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_setChargeType", _wrap_ParticleDataEntry_setChargeType, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_setColType", _wrap_ParticleDataEntry_setColType, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_setM0", _wrap_ParticleDataEntry_setM0, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_setMWidth", _wrap_ParticleDataEntry_setMWidth, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_setMMin", _wrap_ParticleDataEntry_setMMin, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_setMMax", _wrap_ParticleDataEntry_setMMax, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_setMMinNoChange", _wrap_ParticleDataEntry_setMMinNoChange, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_setMMaxNoChange", _wrap_ParticleDataEntry_setMMaxNoChange, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_setTau0", _wrap_ParticleDataEntry_setTau0, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_setIsResonance", _wrap_ParticleDataEntry_setIsResonance, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_setMayDecay", _wrap_ParticleDataEntry_setMayDecay, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_setDoExternalDecay", _wrap_ParticleDataEntry_setDoExternalDecay, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_setIsVisible", _wrap_ParticleDataEntry_setIsVisible, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_setDoForceWidth", _wrap_ParticleDataEntry_setDoForceWidth, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_setHasChanged", _wrap_ParticleDataEntry_setHasChanged, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_id", _wrap_ParticleDataEntry_id, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_hasAnti", _wrap_ParticleDataEntry_hasAnti, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_name", _wrap_ParticleDataEntry_name, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_spinType", _wrap_ParticleDataEntry_spinType, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_chargeType", _wrap_ParticleDataEntry_chargeType, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_charge", _wrap_ParticleDataEntry_charge, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_colType", _wrap_ParticleDataEntry_colType, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_m0", _wrap_ParticleDataEntry_m0, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_mWidth", _wrap_ParticleDataEntry_mWidth, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_mMin", _wrap_ParticleDataEntry_mMin, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_mMax", _wrap_ParticleDataEntry_mMax, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_m0Min", _wrap_ParticleDataEntry_m0Min, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_m0Max", _wrap_ParticleDataEntry_m0Max, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_tau0", _wrap_ParticleDataEntry_tau0, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_isResonance", _wrap_ParticleDataEntry_isResonance, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_mayDecay", _wrap_ParticleDataEntry_mayDecay, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_doExternalDecay", _wrap_ParticleDataEntry_doExternalDecay, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_isVisible", _wrap_ParticleDataEntry_isVisible, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_doForceWidth", _wrap_ParticleDataEntry_doForceWidth, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_hasChanged", _wrap_ParticleDataEntry_hasChanged, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_hasChangedMMin", _wrap_ParticleDataEntry_hasChangedMMin, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_hasChangedMMax", _wrap_ParticleDataEntry_hasChangedMMax, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_initBWmass", _wrap_ParticleDataEntry_initBWmass, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_constituentMass", _wrap_ParticleDataEntry_constituentMass, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_mSel", _wrap_ParticleDataEntry_mSel, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_mRun", _wrap_ParticleDataEntry_mRun, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_useBreitWigner", _wrap_ParticleDataEntry_useBreitWigner, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_canDecay", _wrap_ParticleDataEntry_canDecay, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_isLepton", _wrap_ParticleDataEntry_isLepton, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_isQuark", _wrap_ParticleDataEntry_isQuark, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_isGluon", _wrap_ParticleDataEntry_isGluon, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_isDiquark", _wrap_ParticleDataEntry_isDiquark, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_isParton", _wrap_ParticleDataEntry_isParton, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_isHadron", _wrap_ParticleDataEntry_isHadron, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_isMeson", _wrap_ParticleDataEntry_isMeson, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_isBaryon", _wrap_ParticleDataEntry_isBaryon, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_isOctetHadron", _wrap_ParticleDataEntry_isOctetHadron, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_heaviestQuark", _wrap_ParticleDataEntry_heaviestQuark, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_baryonNumberType", _wrap_ParticleDataEntry_baryonNumberType, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_nQuarksInCode", _wrap_ParticleDataEntry_nQuarksInCode, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_clearChannels", _wrap_ParticleDataEntry_clearChannels, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_addChannel", _wrap_ParticleDataEntry_addChannel, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_sizeChannels", _wrap_ParticleDataEntry_sizeChannels, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_channel", _wrap_ParticleDataEntry_channel, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_rescaleBR", _wrap_ParticleDataEntry_rescaleBR, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_preparePick", _wrap_ParticleDataEntry_preparePick, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_pickChannel", _wrap_ParticleDataEntry_pickChannel, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_setResonancePtr", _wrap_ParticleDataEntry_setResonancePtr, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_getResonancePtr", _wrap_ParticleDataEntry_getResonancePtr, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_resInit", _wrap_ParticleDataEntry_resInit, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_resWidth", _wrap_ParticleDataEntry_resWidth, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_resWidthOpen", _wrap_ParticleDataEntry_resWidthOpen, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_resWidthStore", _wrap_ParticleDataEntry_resWidthStore, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_resOpenFrac", _wrap_ParticleDataEntry_resOpenFrac, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_resWidthRescaleFactor", _wrap_ParticleDataEntry_resWidthRescaleFactor, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_resWidthChan", _wrap_ParticleDataEntry_resWidthChan, METH_VARARGS, NULL},
	 { (char *)"ParticleDataEntry_swigregister", ParticleDataEntry_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ParticleData", _wrap_new_ParticleData, METH_VARARGS, NULL},
	 { (char *)"ParticleData_initPtr", _wrap_ParticleData_initPtr, METH_VARARGS, NULL},
	 { (char *)"ParticleData_init", _wrap_ParticleData_init, METH_VARARGS, NULL},
	 { (char *)"ParticleData_reInit", _wrap_ParticleData_reInit, METH_VARARGS, NULL},
	 { (char *)"ParticleData_initWidths", _wrap_ParticleData_initWidths, METH_VARARGS, NULL},
	 { (char *)"ParticleData_listXML", _wrap_ParticleData_listXML, METH_VARARGS, NULL},
	 { (char *)"ParticleData_readXML", _wrap_ParticleData_readXML, METH_VARARGS, NULL},
	 { (char *)"ParticleData_copyXML", _wrap_ParticleData_copyXML, METH_VARARGS, NULL},
	 { (char *)"ParticleData_loadXML", _wrap_ParticleData_loadXML, METH_VARARGS, NULL},
	 { (char *)"ParticleData_processXML", _wrap_ParticleData_processXML, METH_VARARGS, NULL},
	 { (char *)"ParticleData_readFF", _wrap_ParticleData_readFF, METH_VARARGS, NULL},
	 { (char *)"ParticleData_listFF", _wrap_ParticleData_listFF, METH_VARARGS, NULL},
	 { (char *)"ParticleData_readString", _wrap_ParticleData_readString, METH_VARARGS, NULL},
	 { (char *)"ParticleData_readingFailed", _wrap_ParticleData_readingFailed, METH_VARARGS, NULL},
	 { (char *)"ParticleData_listAll", _wrap_ParticleData_listAll, METH_VARARGS, NULL},
	 { (char *)"ParticleData_listChanged", _wrap_ParticleData_listChanged, METH_VARARGS, NULL},
	 { (char *)"ParticleData_getReadHistory", _wrap_ParticleData_getReadHistory, METH_VARARGS, NULL},
	 { (char *)"ParticleData_checkTable", _wrap_ParticleData_checkTable, METH_VARARGS, NULL},
	 { (char *)"ParticleData_addParticle", _wrap_ParticleData_addParticle, METH_VARARGS, NULL},
	 { (char *)"ParticleData_setAll", _wrap_ParticleData_setAll, METH_VARARGS, NULL},
	 { (char *)"ParticleData_isParticle", _wrap_ParticleData_isParticle, METH_VARARGS, NULL},
	 { (char *)"ParticleData_findParticle", _wrap_ParticleData_findParticle, METH_VARARGS, NULL},
	 { (char *)"ParticleData_nextId", _wrap_ParticleData_nextId, METH_VARARGS, NULL},
	 { (char *)"ParticleData_antiName", _wrap_ParticleData_antiName, METH_VARARGS, NULL},
	 { (char *)"ParticleData_names", _wrap_ParticleData_names, METH_VARARGS, NULL},
	 { (char *)"ParticleData_hasAnti", _wrap_ParticleData_hasAnti, METH_VARARGS, NULL},
	 { (char *)"ParticleData_name", _wrap_ParticleData_name, METH_VARARGS, NULL},
	 { (char *)"ParticleData_spinType", _wrap_ParticleData_spinType, METH_VARARGS, NULL},
	 { (char *)"ParticleData_chargeType", _wrap_ParticleData_chargeType, METH_VARARGS, NULL},
	 { (char *)"ParticleData_charge", _wrap_ParticleData_charge, METH_VARARGS, NULL},
	 { (char *)"ParticleData_colType", _wrap_ParticleData_colType, METH_VARARGS, NULL},
	 { (char *)"ParticleData_m0", _wrap_ParticleData_m0, METH_VARARGS, NULL},
	 { (char *)"ParticleData_mWidth", _wrap_ParticleData_mWidth, METH_VARARGS, NULL},
	 { (char *)"ParticleData_mMin", _wrap_ParticleData_mMin, METH_VARARGS, NULL},
	 { (char *)"ParticleData_m0Min", _wrap_ParticleData_m0Min, METH_VARARGS, NULL},
	 { (char *)"ParticleData_mMax", _wrap_ParticleData_mMax, METH_VARARGS, NULL},
	 { (char *)"ParticleData_m0Max", _wrap_ParticleData_m0Max, METH_VARARGS, NULL},
	 { (char *)"ParticleData_tau0", _wrap_ParticleData_tau0, METH_VARARGS, NULL},
	 { (char *)"ParticleData_isResonance", _wrap_ParticleData_isResonance, METH_VARARGS, NULL},
	 { (char *)"ParticleData_mayDecay", _wrap_ParticleData_mayDecay, METH_VARARGS, NULL},
	 { (char *)"ParticleData_doExternalDecay", _wrap_ParticleData_doExternalDecay, METH_VARARGS, NULL},
	 { (char *)"ParticleData_isVisible", _wrap_ParticleData_isVisible, METH_VARARGS, NULL},
	 { (char *)"ParticleData_doForceWidth", _wrap_ParticleData_doForceWidth, METH_VARARGS, NULL},
	 { (char *)"ParticleData_hasChanged", _wrap_ParticleData_hasChanged, METH_VARARGS, NULL},
	 { (char *)"ParticleData_hasChangedMMin", _wrap_ParticleData_hasChangedMMin, METH_VARARGS, NULL},
	 { (char *)"ParticleData_hasChangedMMax", _wrap_ParticleData_hasChangedMMax, METH_VARARGS, NULL},
	 { (char *)"ParticleData_useBreitWigner", _wrap_ParticleData_useBreitWigner, METH_VARARGS, NULL},
	 { (char *)"ParticleData_constituentMass", _wrap_ParticleData_constituentMass, METH_VARARGS, NULL},
	 { (char *)"ParticleData_mSel", _wrap_ParticleData_mSel, METH_VARARGS, NULL},
	 { (char *)"ParticleData_mRun", _wrap_ParticleData_mRun, METH_VARARGS, NULL},
	 { (char *)"ParticleData_canDecay", _wrap_ParticleData_canDecay, METH_VARARGS, NULL},
	 { (char *)"ParticleData_isLepton", _wrap_ParticleData_isLepton, METH_VARARGS, NULL},
	 { (char *)"ParticleData_isQuark", _wrap_ParticleData_isQuark, METH_VARARGS, NULL},
	 { (char *)"ParticleData_isGluon", _wrap_ParticleData_isGluon, METH_VARARGS, NULL},
	 { (char *)"ParticleData_isDiquark", _wrap_ParticleData_isDiquark, METH_VARARGS, NULL},
	 { (char *)"ParticleData_isParton", _wrap_ParticleData_isParton, METH_VARARGS, NULL},
	 { (char *)"ParticleData_isHadron", _wrap_ParticleData_isHadron, METH_VARARGS, NULL},
	 { (char *)"ParticleData_isMeson", _wrap_ParticleData_isMeson, METH_VARARGS, NULL},
	 { (char *)"ParticleData_isBaryon", _wrap_ParticleData_isBaryon, METH_VARARGS, NULL},
	 { (char *)"ParticleData_isOctetHadron", _wrap_ParticleData_isOctetHadron, METH_VARARGS, NULL},
	 { (char *)"ParticleData_heaviestQuark", _wrap_ParticleData_heaviestQuark, METH_VARARGS, NULL},
	 { (char *)"ParticleData_baryonNumberType", _wrap_ParticleData_baryonNumberType, METH_VARARGS, NULL},
	 { (char *)"ParticleData_nQuarksInCode", _wrap_ParticleData_nQuarksInCode, METH_VARARGS, NULL},
	 { (char *)"ParticleData_rescaleBR", _wrap_ParticleData_rescaleBR, METH_VARARGS, NULL},
	 { (char *)"ParticleData_setResonancePtr", _wrap_ParticleData_setResonancePtr, METH_VARARGS, NULL},
	 { (char *)"ParticleData_resInit", _wrap_ParticleData_resInit, METH_VARARGS, NULL},
	 { (char *)"ParticleData_resWidth", _wrap_ParticleData_resWidth, METH_VARARGS, NULL},
	 { (char *)"ParticleData_resWidthOpen", _wrap_ParticleData_resWidthOpen, METH_VARARGS, NULL},
	 { (char *)"ParticleData_resWidthStore", _wrap_ParticleData_resWidthStore, METH_VARARGS, NULL},
	 { (char *)"ParticleData_resOpenFrac", _wrap_ParticleData_resOpenFrac, METH_VARARGS, NULL},
	 { (char *)"ParticleData_resWidthRescaleFactor", _wrap_ParticleData_resWidthRescaleFactor, METH_VARARGS, NULL},
	 { (char *)"ParticleData_resWidthChan", _wrap_ParticleData_resWidthChan, METH_VARARGS, NULL},
	 { (char *)"ParticleData_particleDataEntryPtr", _wrap_ParticleData_particleDataEntryPtr, METH_VARARGS, NULL},
	 { (char *)"ParticleData_getIsInit", _wrap_ParticleData_getIsInit, METH_VARARGS, NULL},
	 { (char *)"ParticleData___str__", _wrap_ParticleData___str__, METH_VARARGS, NULL},
	 { (char *)"delete_ParticleData", _wrap_delete_ParticleData, METH_VARARGS, NULL},
	 { (char *)"ParticleData_swigregister", ParticleData_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PDF", _wrap_new_PDF, METH_VARARGS, NULL},
	 { (char *)"delete_PDF", _wrap_delete_PDF, METH_VARARGS, NULL},
	 { (char *)"PDF_isSetup", _wrap_PDF_isSetup, METH_VARARGS, NULL},
	 { (char *)"PDF_newValenceContent", _wrap_PDF_newValenceContent, METH_VARARGS, NULL},
	 { (char *)"PDF_setExtrapolate", _wrap_PDF_setExtrapolate, METH_VARARGS, NULL},
	 { (char *)"PDF_xf", _wrap_PDF_xf, METH_VARARGS, NULL},
	 { (char *)"PDF_xfVal", _wrap_PDF_xfVal, METH_VARARGS, NULL},
	 { (char *)"PDF_xfSea", _wrap_PDF_xfSea, METH_VARARGS, NULL},
	 { (char *)"PDF_insideBounds", _wrap_PDF_insideBounds, METH_VARARGS, NULL},
	 { (char *)"PDF_alphaS", _wrap_PDF_alphaS, METH_VARARGS, NULL},
	 { (char *)"PDF_mQuarkPDF", _wrap_PDF_mQuarkPDF, METH_VARARGS, NULL},
	 { (char *)"PDF_nMembers", _wrap_PDF_nMembers, METH_VARARGS, NULL},
	 { (char *)"PDF_calcPDFEnvelope", _wrap_PDF_calcPDFEnvelope, METH_VARARGS, NULL},
	 { (char *)"PDF_getPDFEnvelope", _wrap_PDF_getPDFEnvelope, METH_VARARGS, NULL},
	 { (char *)"PDF_gammaPDFxDependence", _wrap_PDF_gammaPDFxDependence, METH_VARARGS, NULL},
	 { (char *)"PDF_gammaPDFRefScale", _wrap_PDF_gammaPDFRefScale, METH_VARARGS, NULL},
	 { (char *)"PDF_sampleGammaValFlavor", _wrap_PDF_sampleGammaValFlavor, METH_VARARGS, NULL},
	 { (char *)"PDF_xfIntegratedTotal", _wrap_PDF_xfIntegratedTotal, METH_VARARGS, NULL},
	 { (char *)"PDF_xGamma", _wrap_PDF_xGamma, METH_VARARGS, NULL},
	 { (char *)"PDF_xPom", _wrap_PDF_xPom, METH_VARARGS, NULL},
	 { (char *)"PDF_xfFlux", _wrap_PDF_xfFlux, METH_VARARGS, NULL},
	 { (char *)"PDF_xfApprox", _wrap_PDF_xfApprox, METH_VARARGS, NULL},
	 { (char *)"PDF_xfGamma", _wrap_PDF_xfGamma, METH_VARARGS, NULL},
	 { (char *)"PDF_getQ2min", _wrap_PDF_getQ2min, METH_VARARGS, NULL},
	 { (char *)"PDF_getXmin", _wrap_PDF_getXmin, METH_VARARGS, NULL},
	 { (char *)"PDF_getXhadr", _wrap_PDF_getXhadr, METH_VARARGS, NULL},
	 { (char *)"PDF_getGammaFluxNorm", _wrap_PDF_getGammaFluxNorm, METH_VARARGS, NULL},
	 { (char *)"PDF_sampleXgamma", _wrap_PDF_sampleXgamma, METH_VARARGS, NULL},
	 { (char *)"PDF_sampleQ2gamma", _wrap_PDF_sampleQ2gamma, METH_VARARGS, NULL},
	 { (char *)"PDF_xfMax", _wrap_PDF_xfMax, METH_VARARGS, NULL},
	 { (char *)"PDF_xfSame", _wrap_PDF_xfSame, METH_VARARGS, NULL},
	 { (char *)"PDF_setVMDscale", _wrap_PDF_setVMDscale, METH_VARARGS, NULL},
	 { (char *)"PDF_idBeam_set", _wrap_PDF_idBeam_set, METH_VARARGS, NULL},
	 { (char *)"PDF_idBeam_get", _wrap_PDF_idBeam_get, METH_VARARGS, NULL},
	 { (char *)"PDF_idBeamAbs_set", _wrap_PDF_idBeamAbs_set, METH_VARARGS, NULL},
	 { (char *)"PDF_idBeamAbs_get", _wrap_PDF_idBeamAbs_get, METH_VARARGS, NULL},
	 { (char *)"PDF_idSav_set", _wrap_PDF_idSav_set, METH_VARARGS, NULL},
	 { (char *)"PDF_idSav_get", _wrap_PDF_idSav_get, METH_VARARGS, NULL},
	 { (char *)"PDF_idVal1_set", _wrap_PDF_idVal1_set, METH_VARARGS, NULL},
	 { (char *)"PDF_idVal1_get", _wrap_PDF_idVal1_get, METH_VARARGS, NULL},
	 { (char *)"PDF_idVal2_set", _wrap_PDF_idVal2_set, METH_VARARGS, NULL},
	 { (char *)"PDF_idVal2_get", _wrap_PDF_idVal2_get, METH_VARARGS, NULL},
	 { (char *)"PDF_xSav_set", _wrap_PDF_xSav_set, METH_VARARGS, NULL},
	 { (char *)"PDF_xSav_get", _wrap_PDF_xSav_get, METH_VARARGS, NULL},
	 { (char *)"PDF_Q2Sav_set", _wrap_PDF_Q2Sav_set, METH_VARARGS, NULL},
	 { (char *)"PDF_Q2Sav_get", _wrap_PDF_Q2Sav_get, METH_VARARGS, NULL},
	 { (char *)"PDF_xu_set", _wrap_PDF_xu_set, METH_VARARGS, NULL},
	 { (char *)"PDF_xu_get", _wrap_PDF_xu_get, METH_VARARGS, NULL},
	 { (char *)"PDF_xd_set", _wrap_PDF_xd_set, METH_VARARGS, NULL},
	 { (char *)"PDF_xd_get", _wrap_PDF_xd_get, METH_VARARGS, NULL},
	 { (char *)"PDF_xs_set", _wrap_PDF_xs_set, METH_VARARGS, NULL},
	 { (char *)"PDF_xs_get", _wrap_PDF_xs_get, METH_VARARGS, NULL},
	 { (char *)"PDF_xubar_set", _wrap_PDF_xubar_set, METH_VARARGS, NULL},
	 { (char *)"PDF_xubar_get", _wrap_PDF_xubar_get, METH_VARARGS, NULL},
	 { (char *)"PDF_xdbar_set", _wrap_PDF_xdbar_set, METH_VARARGS, NULL},
	 { (char *)"PDF_xdbar_get", _wrap_PDF_xdbar_get, METH_VARARGS, NULL},
	 { (char *)"PDF_xsbar_set", _wrap_PDF_xsbar_set, METH_VARARGS, NULL},
	 { (char *)"PDF_xsbar_get", _wrap_PDF_xsbar_get, METH_VARARGS, NULL},
	 { (char *)"PDF_xc_set", _wrap_PDF_xc_set, METH_VARARGS, NULL},
	 { (char *)"PDF_xc_get", _wrap_PDF_xc_get, METH_VARARGS, NULL},
	 { (char *)"PDF_xb_set", _wrap_PDF_xb_set, METH_VARARGS, NULL},
	 { (char *)"PDF_xb_get", _wrap_PDF_xb_get, METH_VARARGS, NULL},
	 { (char *)"PDF_xg_set", _wrap_PDF_xg_set, METH_VARARGS, NULL},
	 { (char *)"PDF_xg_get", _wrap_PDF_xg_get, METH_VARARGS, NULL},
	 { (char *)"PDF_xlepton_set", _wrap_PDF_xlepton_set, METH_VARARGS, NULL},
	 { (char *)"PDF_xlepton_get", _wrap_PDF_xlepton_get, METH_VARARGS, NULL},
	 { (char *)"PDF_xgamma_set", _wrap_PDF_xgamma_set, METH_VARARGS, NULL},
	 { (char *)"PDF_xgamma_get", _wrap_PDF_xgamma_get, METH_VARARGS, NULL},
	 { (char *)"PDF_xuVal_set", _wrap_PDF_xuVal_set, METH_VARARGS, NULL},
	 { (char *)"PDF_xuVal_get", _wrap_PDF_xuVal_get, METH_VARARGS, NULL},
	 { (char *)"PDF_xuSea_set", _wrap_PDF_xuSea_set, METH_VARARGS, NULL},
	 { (char *)"PDF_xuSea_get", _wrap_PDF_xuSea_get, METH_VARARGS, NULL},
	 { (char *)"PDF_xdVal_set", _wrap_PDF_xdVal_set, METH_VARARGS, NULL},
	 { (char *)"PDF_xdVal_get", _wrap_PDF_xdVal_get, METH_VARARGS, NULL},
	 { (char *)"PDF_xdSea_set", _wrap_PDF_xdSea_set, METH_VARARGS, NULL},
	 { (char *)"PDF_xdSea_get", _wrap_PDF_xdSea_get, METH_VARARGS, NULL},
	 { (char *)"PDF_isSet_set", _wrap_PDF_isSet_set, METH_VARARGS, NULL},
	 { (char *)"PDF_isSet_get", _wrap_PDF_isSet_get, METH_VARARGS, NULL},
	 { (char *)"PDF_isInit_set", _wrap_PDF_isInit_set, METH_VARARGS, NULL},
	 { (char *)"PDF_isInit_get", _wrap_PDF_isInit_get, METH_VARARGS, NULL},
	 { (char *)"PDF_xsVal_set", _wrap_PDF_xsVal_set, METH_VARARGS, NULL},
	 { (char *)"PDF_xsVal_get", _wrap_PDF_xsVal_get, METH_VARARGS, NULL},
	 { (char *)"PDF_xcVal_set", _wrap_PDF_xcVal_set, METH_VARARGS, NULL},
	 { (char *)"PDF_xcVal_get", _wrap_PDF_xcVal_get, METH_VARARGS, NULL},
	 { (char *)"PDF_xbVal_set", _wrap_PDF_xbVal_set, METH_VARARGS, NULL},
	 { (char *)"PDF_xbVal_get", _wrap_PDF_xbVal_get, METH_VARARGS, NULL},
	 { (char *)"PDF_xsSea_set", _wrap_PDF_xsSea_set, METH_VARARGS, NULL},
	 { (char *)"PDF_xsSea_get", _wrap_PDF_xsSea_get, METH_VARARGS, NULL},
	 { (char *)"PDF_xcSea_set", _wrap_PDF_xcSea_set, METH_VARARGS, NULL},
	 { (char *)"PDF_xcSea_get", _wrap_PDF_xcSea_get, METH_VARARGS, NULL},
	 { (char *)"PDF_xbSea_set", _wrap_PDF_xbSea_set, METH_VARARGS, NULL},
	 { (char *)"PDF_xbSea_get", _wrap_PDF_xbSea_get, METH_VARARGS, NULL},
	 { (char *)"PDF_hasGammaInLepton_set", _wrap_PDF_hasGammaInLepton_set, METH_VARARGS, NULL},
	 { (char *)"PDF_hasGammaInLepton_get", _wrap_PDF_hasGammaInLepton_get, METH_VARARGS, NULL},
	 { (char *)"PDF_setValenceContent", _wrap_PDF_setValenceContent, METH_VARARGS, NULL},
	 { (char *)"PDF_xfUpdate", _wrap_PDF_xfUpdate, METH_VARARGS, NULL},
	 { (char *)"PDF_printErr", _wrap_PDF_printErr, METH_VARARGS, NULL},
	 { (char *)"disown_PDF", _wrap_disown_PDF, METH_VARARGS, NULL},
	 { (char *)"PDF_swigregister", PDF_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_GRV94L", _wrap_new_GRV94L, METH_VARARGS, NULL},
	 { (char *)"delete_GRV94L", _wrap_delete_GRV94L, METH_VARARGS, NULL},
	 { (char *)"GRV94L_swigregister", GRV94L_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CTEQ5L", _wrap_new_CTEQ5L, METH_VARARGS, NULL},
	 { (char *)"delete_CTEQ5L", _wrap_delete_CTEQ5L, METH_VARARGS, NULL},
	 { (char *)"CTEQ5L_swigregister", CTEQ5L_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MSTWpdf", _wrap_new_MSTWpdf, METH_VARARGS, NULL},
	 { (char *)"delete_MSTWpdf", _wrap_delete_MSTWpdf, METH_VARARGS, NULL},
	 { (char *)"MSTWpdf_swigregister", MSTWpdf_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CTEQ6pdf", _wrap_new_CTEQ6pdf, METH_VARARGS, NULL},
	 { (char *)"CTEQ6pdf_setExtrapolate", _wrap_CTEQ6pdf_setExtrapolate, METH_VARARGS, NULL},
	 { (char *)"delete_CTEQ6pdf", _wrap_delete_CTEQ6pdf, METH_VARARGS, NULL},
	 { (char *)"CTEQ6pdf_swigregister", CTEQ6pdf_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ProtonPoint", _wrap_new_ProtonPoint, METH_VARARGS, NULL},
	 { (char *)"delete_ProtonPoint", _wrap_delete_ProtonPoint, METH_VARARGS, NULL},
	 { (char *)"ProtonPoint_swigregister", ProtonPoint_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_GRVpiL", _wrap_new_GRVpiL, METH_VARARGS, NULL},
	 { (char *)"GRVpiL_setVMDscale", _wrap_GRVpiL_setVMDscale, METH_VARARGS, NULL},
	 { (char *)"delete_GRVpiL", _wrap_delete_GRVpiL, METH_VARARGS, NULL},
	 { (char *)"GRVpiL_swigregister", GRVpiL_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PomFix", _wrap_new_PomFix, METH_VARARGS, NULL},
	 { (char *)"delete_PomFix", _wrap_delete_PomFix, METH_VARARGS, NULL},
	 { (char *)"PomFix_swigregister", PomFix_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PomH1FitAB", _wrap_new_PomH1FitAB, METH_VARARGS, NULL},
	 { (char *)"PomH1FitAB_setExtrapolate", _wrap_PomH1FitAB_setExtrapolate, METH_VARARGS, NULL},
	 { (char *)"delete_PomH1FitAB", _wrap_delete_PomH1FitAB, METH_VARARGS, NULL},
	 { (char *)"PomH1FitAB_swigregister", PomH1FitAB_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PomH1Jets", _wrap_new_PomH1Jets, METH_VARARGS, NULL},
	 { (char *)"PomH1Jets_setExtrapolate", _wrap_PomH1Jets_setExtrapolate, METH_VARARGS, NULL},
	 { (char *)"delete_PomH1Jets", _wrap_delete_PomH1Jets, METH_VARARGS, NULL},
	 { (char *)"PomH1Jets_swigregister", PomH1Jets_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PomHISASD", _wrap_new_PomHISASD, METH_VARARGS, NULL},
	 { (char *)"delete_PomHISASD", _wrap_delete_PomHISASD, METH_VARARGS, NULL},
	 { (char *)"PomHISASD_xPom", _wrap_PomHISASD_xPom, METH_VARARGS, NULL},
	 { (char *)"PomHISASD_swigregister", PomHISASD_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Lepton", _wrap_new_Lepton, METH_VARARGS, NULL},
	 { (char *)"Lepton_sampleQ2gamma", _wrap_Lepton_sampleQ2gamma, METH_VARARGS, NULL},
	 { (char *)"delete_Lepton", _wrap_delete_Lepton, METH_VARARGS, NULL},
	 { (char *)"Lepton_swigregister", Lepton_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LeptonPoint", _wrap_new_LeptonPoint, METH_VARARGS, NULL},
	 { (char *)"delete_LeptonPoint", _wrap_delete_LeptonPoint, METH_VARARGS, NULL},
	 { (char *)"LeptonPoint_swigregister", LeptonPoint_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NeutrinoPoint", _wrap_new_NeutrinoPoint, METH_VARARGS, NULL},
	 { (char *)"delete_NeutrinoPoint", _wrap_delete_NeutrinoPoint, METH_VARARGS, NULL},
	 { (char *)"NeutrinoPoint_swigregister", NeutrinoPoint_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NNPDF", _wrap_new_NNPDF, METH_VARARGS, NULL},
	 { (char *)"delete_NNPDF", _wrap_delete_NNPDF, METH_VARARGS, NULL},
	 { (char *)"NNPDF_swigregister", NNPDF_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LHAPDF", _wrap_new_LHAPDF, METH_VARARGS, NULL},
	 { (char *)"delete_LHAPDF", _wrap_delete_LHAPDF, METH_VARARGS, NULL},
	 { (char *)"LHAPDF_isSetup", _wrap_LHAPDF_isSetup, METH_VARARGS, NULL},
	 { (char *)"LHAPDF_newValenceContent", _wrap_LHAPDF_newValenceContent, METH_VARARGS, NULL},
	 { (char *)"LHAPDF_setExtrapolate", _wrap_LHAPDF_setExtrapolate, METH_VARARGS, NULL},
	 { (char *)"LHAPDF_xf", _wrap_LHAPDF_xf, METH_VARARGS, NULL},
	 { (char *)"LHAPDF_xfVal", _wrap_LHAPDF_xfVal, METH_VARARGS, NULL},
	 { (char *)"LHAPDF_xfSea", _wrap_LHAPDF_xfSea, METH_VARARGS, NULL},
	 { (char *)"LHAPDF_insideBounds", _wrap_LHAPDF_insideBounds, METH_VARARGS, NULL},
	 { (char *)"LHAPDF_alphaS", _wrap_LHAPDF_alphaS, METH_VARARGS, NULL},
	 { (char *)"LHAPDF_mQuarkPDF", _wrap_LHAPDF_mQuarkPDF, METH_VARARGS, NULL},
	 { (char *)"LHAPDF_nMembers", _wrap_LHAPDF_nMembers, METH_VARARGS, NULL},
	 { (char *)"LHAPDF_calcPDFEnvelope", _wrap_LHAPDF_calcPDFEnvelope, METH_VARARGS, NULL},
	 { (char *)"LHAPDF_getPDFEnvelope", _wrap_LHAPDF_getPDFEnvelope, METH_VARARGS, NULL},
	 { (char *)"LHAPDF_swigregister", LHAPDF_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CJKL", _wrap_new_CJKL, METH_VARARGS, NULL},
	 { (char *)"CJKL_gammaPDFxDependence", _wrap_CJKL_gammaPDFxDependence, METH_VARARGS, NULL},
	 { (char *)"CJKL_gammaPDFRefScale", _wrap_CJKL_gammaPDFRefScale, METH_VARARGS, NULL},
	 { (char *)"CJKL_sampleGammaValFlavor", _wrap_CJKL_sampleGammaValFlavor, METH_VARARGS, NULL},
	 { (char *)"CJKL_xfIntegratedTotal", _wrap_CJKL_xfIntegratedTotal, METH_VARARGS, NULL},
	 { (char *)"delete_CJKL", _wrap_delete_CJKL, METH_VARARGS, NULL},
	 { (char *)"CJKL_swigregister", CJKL_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LHAGrid1", _wrap_new_LHAGrid1, METH_VARARGS, NULL},
	 { (char *)"delete_LHAGrid1", _wrap_delete_LHAGrid1, METH_VARARGS, NULL},
	 { (char *)"LHAGrid1_setExtrapolate", _wrap_LHAGrid1_setExtrapolate, METH_VARARGS, NULL},
	 { (char *)"LHAGrid1_swigregister", LHAGrid1_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Lepton2gamma", _wrap_new_Lepton2gamma, METH_VARARGS, NULL},
	 { (char *)"Lepton2gamma_xfUpdate", _wrap_Lepton2gamma_xfUpdate, METH_VARARGS, NULL},
	 { (char *)"Lepton2gamma_xGamma", _wrap_Lepton2gamma_xGamma, METH_VARARGS, NULL},
	 { (char *)"Lepton2gamma_xfMax", _wrap_Lepton2gamma_xfMax, METH_VARARGS, NULL},
	 { (char *)"Lepton2gamma_xfSame", _wrap_Lepton2gamma_xfSame, METH_VARARGS, NULL},
	 { (char *)"Lepton2gamma_sampleQ2gamma", _wrap_Lepton2gamma_sampleQ2gamma, METH_VARARGS, NULL},
	 { (char *)"delete_Lepton2gamma", _wrap_delete_Lepton2gamma, METH_VARARGS, NULL},
	 { (char *)"Lepton2gamma_swigregister", Lepton2gamma_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_GammaPoint", _wrap_new_GammaPoint, METH_VARARGS, NULL},
	 { (char *)"delete_GammaPoint", _wrap_delete_GammaPoint, METH_VARARGS, NULL},
	 { (char *)"GammaPoint_swigregister", GammaPoint_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EPAexternal", _wrap_new_EPAexternal, METH_VARARGS, NULL},
	 { (char *)"EPAexternal_xfUpdate", _wrap_EPAexternal_xfUpdate, METH_VARARGS, NULL},
	 { (char *)"EPAexternal_xfFlux", _wrap_EPAexternal_xfFlux, METH_VARARGS, NULL},
	 { (char *)"EPAexternal_xfGamma", _wrap_EPAexternal_xfGamma, METH_VARARGS, NULL},
	 { (char *)"EPAexternal_xfApprox", _wrap_EPAexternal_xfApprox, METH_VARARGS, NULL},
	 { (char *)"EPAexternal_getQ2min", _wrap_EPAexternal_getQ2min, METH_VARARGS, NULL},
	 { (char *)"EPAexternal_getXmin", _wrap_EPAexternal_getXmin, METH_VARARGS, NULL},
	 { (char *)"EPAexternal_getXhadr", _wrap_EPAexternal_getXhadr, METH_VARARGS, NULL},
	 { (char *)"EPAexternal_getGammaFluxNorm", _wrap_EPAexternal_getGammaFluxNorm, METH_VARARGS, NULL},
	 { (char *)"EPAexternal_sampleXgamma", _wrap_EPAexternal_sampleXgamma, METH_VARARGS, NULL},
	 { (char *)"EPAexternal_sampleQ2gamma", _wrap_EPAexternal_sampleQ2gamma, METH_VARARGS, NULL},
	 { (char *)"delete_EPAexternal", _wrap_delete_EPAexternal, METH_VARARGS, NULL},
	 { (char *)"EPAexternal_swigregister", EPAexternal_swigregister, METH_VARARGS, NULL},
	 { (char *)"nPDF_xfUpdate", _wrap_nPDF_xfUpdate, METH_VARARGS, NULL},
	 { (char *)"nPDF_rUpdate", _wrap_nPDF_rUpdate, METH_VARARGS, NULL},
	 { (char *)"nPDF_initNPDF", _wrap_nPDF_initNPDF, METH_VARARGS, NULL},
	 { (char *)"nPDF_getA", _wrap_nPDF_getA, METH_VARARGS, NULL},
	 { (char *)"nPDF_getZ", _wrap_nPDF_getZ, METH_VARARGS, NULL},
	 { (char *)"nPDF_setMode", _wrap_nPDF_setMode, METH_VARARGS, NULL},
	 { (char *)"nPDF_resetMode", _wrap_nPDF_resetMode, METH_VARARGS, NULL},
	 { (char *)"delete_nPDF", _wrap_delete_nPDF, METH_VARARGS, NULL},
	 { (char *)"nPDF_swigregister", nPDF_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Isospin", _wrap_new_Isospin, METH_VARARGS, NULL},
	 { (char *)"Isospin_rUpdate", _wrap_Isospin_rUpdate, METH_VARARGS, NULL},
	 { (char *)"delete_Isospin", _wrap_delete_Isospin, METH_VARARGS, NULL},
	 { (char *)"Isospin_swigregister", Isospin_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EPS09", _wrap_new_EPS09, METH_VARARGS, NULL},
	 { (char *)"EPS09_rUpdate", _wrap_EPS09_rUpdate, METH_VARARGS, NULL},
	 { (char *)"EPS09_setErrorSet", _wrap_EPS09_setErrorSet, METH_VARARGS, NULL},
	 { (char *)"delete_EPS09", _wrap_delete_EPS09, METH_VARARGS, NULL},
	 { (char *)"EPS09_swigregister", EPS09_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EPPS16", _wrap_new_EPPS16, METH_VARARGS, NULL},
	 { (char *)"EPPS16_rUpdate", _wrap_EPPS16_rUpdate, METH_VARARGS, NULL},
	 { (char *)"EPPS16_setErrorSet", _wrap_EPPS16_setErrorSet, METH_VARARGS, NULL},
	 { (char *)"delete_EPPS16", _wrap_delete_EPPS16, METH_VARARGS, NULL},
	 { (char *)"EPPS16_swigregister", EPPS16_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceWidths", _wrap_delete_ResonanceWidths, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_initBasic", _wrap_ResonanceWidths_initBasic, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_init", _wrap_ResonanceWidths_init, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_id", _wrap_ResonanceWidths_id, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_width", _wrap_ResonanceWidths_width, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_widthOpen", _wrap_ResonanceWidths_widthOpen, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_widthStore", _wrap_ResonanceWidths_widthStore, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_openFrac", _wrap_ResonanceWidths_openFrac, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_widthRescaleFactor", _wrap_ResonanceWidths_widthRescaleFactor, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_widthChan", _wrap_ResonanceWidths_widthChan, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceWidths", _wrap_new_ResonanceWidths, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_idRes_set", _wrap_ResonanceWidths_idRes_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_idRes_get", _wrap_ResonanceWidths_idRes_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_hasAntiRes_set", _wrap_ResonanceWidths_hasAntiRes_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_hasAntiRes_get", _wrap_ResonanceWidths_hasAntiRes_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_doForceWidth_set", _wrap_ResonanceWidths_doForceWidth_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_doForceWidth_get", _wrap_ResonanceWidths_doForceWidth_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_isGeneric_set", _wrap_ResonanceWidths_isGeneric_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_isGeneric_get", _wrap_ResonanceWidths_isGeneric_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_allowCalcWidth_set", _wrap_ResonanceWidths_allowCalcWidth_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_allowCalcWidth_get", _wrap_ResonanceWidths_allowCalcWidth_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_minWidth_set", _wrap_ResonanceWidths_minWidth_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_minWidth_get", _wrap_ResonanceWidths_minWidth_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_minThreshold_set", _wrap_ResonanceWidths_minThreshold_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_minThreshold_get", _wrap_ResonanceWidths_minThreshold_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_mRes_set", _wrap_ResonanceWidths_mRes_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_mRes_get", _wrap_ResonanceWidths_mRes_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_GammaRes_set", _wrap_ResonanceWidths_GammaRes_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_GammaRes_get", _wrap_ResonanceWidths_GammaRes_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_m2Res_set", _wrap_ResonanceWidths_m2Res_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_m2Res_get", _wrap_ResonanceWidths_m2Res_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_GamMRat_set", _wrap_ResonanceWidths_GamMRat_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_GamMRat_get", _wrap_ResonanceWidths_GamMRat_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_openPos_set", _wrap_ResonanceWidths_openPos_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_openPos_get", _wrap_ResonanceWidths_openPos_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_openNeg_set", _wrap_ResonanceWidths_openNeg_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_openNeg_get", _wrap_ResonanceWidths_openNeg_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_forceFactor_set", _wrap_ResonanceWidths_forceFactor_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_forceFactor_get", _wrap_ResonanceWidths_forceFactor_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_iChannel_set", _wrap_ResonanceWidths_iChannel_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_iChannel_get", _wrap_ResonanceWidths_iChannel_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_onMode_set", _wrap_ResonanceWidths_onMode_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_onMode_get", _wrap_ResonanceWidths_onMode_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_meMode_set", _wrap_ResonanceWidths_meMode_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_meMode_get", _wrap_ResonanceWidths_meMode_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_mult_set", _wrap_ResonanceWidths_mult_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_mult_get", _wrap_ResonanceWidths_mult_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_id1_set", _wrap_ResonanceWidths_id1_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_id1_get", _wrap_ResonanceWidths_id1_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_id2_set", _wrap_ResonanceWidths_id2_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_id2_get", _wrap_ResonanceWidths_id2_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_id3_set", _wrap_ResonanceWidths_id3_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_id3_get", _wrap_ResonanceWidths_id3_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_id1Abs_set", _wrap_ResonanceWidths_id1Abs_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_id1Abs_get", _wrap_ResonanceWidths_id1Abs_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_id2Abs_set", _wrap_ResonanceWidths_id2Abs_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_id2Abs_get", _wrap_ResonanceWidths_id2Abs_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_id3Abs_set", _wrap_ResonanceWidths_id3Abs_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_id3Abs_get", _wrap_ResonanceWidths_id3Abs_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_idInFlav_set", _wrap_ResonanceWidths_idInFlav_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_idInFlav_get", _wrap_ResonanceWidths_idInFlav_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_widNow_set", _wrap_ResonanceWidths_widNow_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_widNow_get", _wrap_ResonanceWidths_widNow_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_mHat_set", _wrap_ResonanceWidths_mHat_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_mHat_get", _wrap_ResonanceWidths_mHat_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_mf1_set", _wrap_ResonanceWidths_mf1_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_mf1_get", _wrap_ResonanceWidths_mf1_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_mf2_set", _wrap_ResonanceWidths_mf2_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_mf2_get", _wrap_ResonanceWidths_mf2_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_mf3_set", _wrap_ResonanceWidths_mf3_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_mf3_get", _wrap_ResonanceWidths_mf3_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_mr1_set", _wrap_ResonanceWidths_mr1_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_mr1_get", _wrap_ResonanceWidths_mr1_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_mr2_set", _wrap_ResonanceWidths_mr2_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_mr2_get", _wrap_ResonanceWidths_mr2_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_mr3_set", _wrap_ResonanceWidths_mr3_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_mr3_get", _wrap_ResonanceWidths_mr3_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_ps_set", _wrap_ResonanceWidths_ps_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_ps_get", _wrap_ResonanceWidths_ps_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_kinFac_set", _wrap_ResonanceWidths_kinFac_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_kinFac_get", _wrap_ResonanceWidths_kinFac_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_alpEM_set", _wrap_ResonanceWidths_alpEM_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_alpEM_get", _wrap_ResonanceWidths_alpEM_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_alpS_set", _wrap_ResonanceWidths_alpS_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_alpS_get", _wrap_ResonanceWidths_alpS_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_colQ_set", _wrap_ResonanceWidths_colQ_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_colQ_get", _wrap_ResonanceWidths_colQ_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_preFac_set", _wrap_ResonanceWidths_preFac_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_preFac_get", _wrap_ResonanceWidths_preFac_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_particlePtr_set", _wrap_ResonanceWidths_particlePtr_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_particlePtr_get", _wrap_ResonanceWidths_particlePtr_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_infoPtr_set", _wrap_ResonanceWidths_infoPtr_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_infoPtr_get", _wrap_ResonanceWidths_infoPtr_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_settingsPtr_set", _wrap_ResonanceWidths_settingsPtr_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_settingsPtr_get", _wrap_ResonanceWidths_settingsPtr_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_particleDataPtr_set", _wrap_ResonanceWidths_particleDataPtr_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_particleDataPtr_get", _wrap_ResonanceWidths_particleDataPtr_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_couplingsPtr_set", _wrap_ResonanceWidths_couplingsPtr_set, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_couplingsPtr_get", _wrap_ResonanceWidths_couplingsPtr_get, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_initConstants", _wrap_ResonanceWidths_initConstants, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_initBSM", _wrap_ResonanceWidths_initBSM, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_allowCalc", _wrap_ResonanceWidths_allowCalc, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_calcPreFac", _wrap_ResonanceWidths_calcPreFac, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_calcWidth", _wrap_ResonanceWidths_calcWidth, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_numInt1BW", _wrap_ResonanceWidths_numInt1BW, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_numInt2BW", _wrap_ResonanceWidths_numInt2BW, METH_VARARGS, NULL},
	 { (char *)"disown_ResonanceWidths", _wrap_disown_ResonanceWidths, METH_VARARGS, NULL},
	 { (char *)"ResonanceWidths_swigregister", ResonanceWidths_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceGeneric", _wrap_new_ResonanceGeneric, METH_VARARGS, NULL},
	 { (char *)"ResonanceGeneric_allowCalc", _wrap_ResonanceGeneric_allowCalc, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceGeneric", _wrap_delete_ResonanceGeneric, METH_VARARGS, NULL},
	 { (char *)"ResonanceGeneric_swigregister", ResonanceGeneric_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceGmZ", _wrap_new_ResonanceGmZ, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceGmZ", _wrap_delete_ResonanceGmZ, METH_VARARGS, NULL},
	 { (char *)"ResonanceGmZ_swigregister", ResonanceGmZ_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceW", _wrap_new_ResonanceW, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceW", _wrap_delete_ResonanceW, METH_VARARGS, NULL},
	 { (char *)"ResonanceW_swigregister", ResonanceW_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceTop", _wrap_new_ResonanceTop, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceTop", _wrap_delete_ResonanceTop, METH_VARARGS, NULL},
	 { (char *)"ResonanceTop_swigregister", ResonanceTop_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceFour", _wrap_new_ResonanceFour, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceFour", _wrap_delete_ResonanceFour, METH_VARARGS, NULL},
	 { (char *)"ResonanceFour_swigregister", ResonanceFour_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceH", _wrap_new_ResonanceH, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceH", _wrap_delete_ResonanceH, METH_VARARGS, NULL},
	 { (char *)"ResonanceH_swigregister", ResonanceH_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceHchg", _wrap_new_ResonanceHchg, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceHchg", _wrap_delete_ResonanceHchg, METH_VARARGS, NULL},
	 { (char *)"ResonanceHchg_swigregister", ResonanceHchg_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceZprime", _wrap_new_ResonanceZprime, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceZprime", _wrap_delete_ResonanceZprime, METH_VARARGS, NULL},
	 { (char *)"ResonanceZprime_swigregister", ResonanceZprime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceWprime", _wrap_new_ResonanceWprime, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceWprime", _wrap_delete_ResonanceWprime, METH_VARARGS, NULL},
	 { (char *)"ResonanceWprime_swigregister", ResonanceWprime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceRhorizontal", _wrap_new_ResonanceRhorizontal, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceRhorizontal", _wrap_delete_ResonanceRhorizontal, METH_VARARGS, NULL},
	 { (char *)"ResonanceRhorizontal_swigregister", ResonanceRhorizontal_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceExcited", _wrap_new_ResonanceExcited, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceExcited", _wrap_delete_ResonanceExcited, METH_VARARGS, NULL},
	 { (char *)"ResonanceExcited_swigregister", ResonanceExcited_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceGraviton", _wrap_new_ResonanceGraviton, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceGraviton", _wrap_delete_ResonanceGraviton, METH_VARARGS, NULL},
	 { (char *)"ResonanceGraviton_swigregister", ResonanceGraviton_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceKKgluon", _wrap_new_ResonanceKKgluon, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceKKgluon", _wrap_delete_ResonanceKKgluon, METH_VARARGS, NULL},
	 { (char *)"ResonanceKKgluon_swigregister", ResonanceKKgluon_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceLeptoquark", _wrap_new_ResonanceLeptoquark, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceLeptoquark", _wrap_delete_ResonanceLeptoquark, METH_VARARGS, NULL},
	 { (char *)"ResonanceLeptoquark_swigregister", ResonanceLeptoquark_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceNuRight", _wrap_new_ResonanceNuRight, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceNuRight", _wrap_delete_ResonanceNuRight, METH_VARARGS, NULL},
	 { (char *)"ResonanceNuRight_swigregister", ResonanceNuRight_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceZRight", _wrap_new_ResonanceZRight, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceZRight", _wrap_delete_ResonanceZRight, METH_VARARGS, NULL},
	 { (char *)"ResonanceZRight_swigregister", ResonanceZRight_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceWRight", _wrap_new_ResonanceWRight, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceWRight", _wrap_delete_ResonanceWRight, METH_VARARGS, NULL},
	 { (char *)"ResonanceWRight_swigregister", ResonanceWRight_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceHchgchgLeft", _wrap_new_ResonanceHchgchgLeft, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceHchgchgLeft", _wrap_delete_ResonanceHchgchgLeft, METH_VARARGS, NULL},
	 { (char *)"ResonanceHchgchgLeft_swigregister", ResonanceHchgchgLeft_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceHchgchgRight", _wrap_new_ResonanceHchgchgRight, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceHchgchgRight", _wrap_delete_ResonanceHchgchgRight, METH_VARARGS, NULL},
	 { (char *)"ResonanceHchgchgRight_swigregister", ResonanceHchgchgRight_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_SigmaTotAux", _wrap_delete_SigmaTotAux, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_init", _wrap_SigmaTotAux_init, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_calcTotEl", _wrap_SigmaTotAux_calcTotEl, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_isExpEl_set", _wrap_SigmaTotAux_isExpEl_set, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_isExpEl_get", _wrap_SigmaTotAux_isExpEl_get, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_hasCou_set", _wrap_SigmaTotAux_hasCou_set, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_hasCou_get", _wrap_SigmaTotAux_hasCou_get, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_sigTot_set", _wrap_SigmaTotAux_sigTot_set, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_sigTot_get", _wrap_SigmaTotAux_sigTot_get, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_rhoOwn_set", _wrap_SigmaTotAux_rhoOwn_set, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_rhoOwn_get", _wrap_SigmaTotAux_rhoOwn_get, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_sigEl_set", _wrap_SigmaTotAux_sigEl_set, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_sigEl_get", _wrap_SigmaTotAux_sigEl_get, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_bEl_set", _wrap_SigmaTotAux_bEl_set, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_bEl_get", _wrap_SigmaTotAux_bEl_get, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_sigTotCou_set", _wrap_SigmaTotAux_sigTotCou_set, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_sigTotCou_get", _wrap_SigmaTotAux_sigTotCou_get, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_sigElCou_set", _wrap_SigmaTotAux_sigElCou_set, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_sigElCou_get", _wrap_SigmaTotAux_sigElCou_get, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_dsigmaEl", _wrap_SigmaTotAux_dsigmaEl, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_calcDiff", _wrap_SigmaTotAux_calcDiff, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_sigXB_set", _wrap_SigmaTotAux_sigXB_set, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_sigXB_get", _wrap_SigmaTotAux_sigXB_get, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_sigAX_set", _wrap_SigmaTotAux_sigAX_set, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_sigAX_get", _wrap_SigmaTotAux_sigAX_get, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_sigXX_set", _wrap_SigmaTotAux_sigXX_set, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_sigXX_get", _wrap_SigmaTotAux_sigXX_get, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_sigAXB_set", _wrap_SigmaTotAux_sigAXB_set, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_sigAXB_get", _wrap_SigmaTotAux_sigAXB_get, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_dsigmaSD", _wrap_SigmaTotAux_dsigmaSD, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_splitDiff", _wrap_SigmaTotAux_splitDiff, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_dsigmaDD", _wrap_SigmaTotAux_dsigmaDD, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_dsigmaCD", _wrap_SigmaTotAux_dsigmaCD, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_mMinCD", _wrap_SigmaTotAux_mMinCD, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_tRange", _wrap_SigmaTotAux_tRange, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_tInRange", _wrap_SigmaTotAux_tInRange, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_pFormFac", _wrap_SigmaTotAux_pFormFac, METH_VARARGS, NULL},
	 { (char *)"new_SigmaTotAux", _wrap_new_SigmaTotAux, METH_VARARGS, NULL},
	 { (char *)"SigmaTotAux_swigregister", SigmaTotAux_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SigmaTotal", _wrap_new_SigmaTotal, METH_VARARGS, NULL},
	 { (char *)"delete_SigmaTotal", _wrap_delete_SigmaTotal, METH_VARARGS, NULL},
	 { (char *)"SigmaTotal_init", _wrap_SigmaTotal_init, METH_VARARGS, NULL},
	 { (char *)"SigmaTotal_calc", _wrap_SigmaTotal_calc, METH_VARARGS, NULL},
	 { (char *)"SigmaTotal_hasSigmaTot", _wrap_SigmaTotal_hasSigmaTot, METH_VARARGS, NULL},
	 { (char *)"SigmaTotal_sigmaTot", _wrap_SigmaTotal_sigmaTot, METH_VARARGS, NULL},
	 { (char *)"SigmaTotal_rho", _wrap_SigmaTotal_rho, METH_VARARGS, NULL},
	 { (char *)"SigmaTotal_sigmaEl", _wrap_SigmaTotal_sigmaEl, METH_VARARGS, NULL},
	 { (char *)"SigmaTotal_bElIsExp", _wrap_SigmaTotal_bElIsExp, METH_VARARGS, NULL},
	 { (char *)"SigmaTotal_bSlopeEl", _wrap_SigmaTotal_bSlopeEl, METH_VARARGS, NULL},
	 { (char *)"SigmaTotal_hasCoulomb", _wrap_SigmaTotal_hasCoulomb, METH_VARARGS, NULL},
	 { (char *)"SigmaTotal_dsigmaEl", _wrap_SigmaTotal_dsigmaEl, METH_VARARGS, NULL},
	 { (char *)"SigmaTotal_sigmaXB", _wrap_SigmaTotal_sigmaXB, METH_VARARGS, NULL},
	 { (char *)"SigmaTotal_sigmaAX", _wrap_SigmaTotal_sigmaAX, METH_VARARGS, NULL},
	 { (char *)"SigmaTotal_sigmaXX", _wrap_SigmaTotal_sigmaXX, METH_VARARGS, NULL},
	 { (char *)"SigmaTotal_sigmaAXB", _wrap_SigmaTotal_sigmaAXB, METH_VARARGS, NULL},
	 { (char *)"SigmaTotal_sigmaND", _wrap_SigmaTotal_sigmaND, METH_VARARGS, NULL},
	 { (char *)"SigmaTotal_dsigmaSD", _wrap_SigmaTotal_dsigmaSD, METH_VARARGS, NULL},
	 { (char *)"SigmaTotal_splitDiff", _wrap_SigmaTotal_splitDiff, METH_VARARGS, NULL},
	 { (char *)"SigmaTotal_dsigmaDD", _wrap_SigmaTotal_dsigmaDD, METH_VARARGS, NULL},
	 { (char *)"SigmaTotal_dsigmaCD", _wrap_SigmaTotal_dsigmaCD, METH_VARARGS, NULL},
	 { (char *)"SigmaTotal_mMinCD", _wrap_SigmaTotal_mMinCD, METH_VARARGS, NULL},
	 { (char *)"SigmaTotal_tRange", _wrap_SigmaTotal_tRange, METH_VARARGS, NULL},
	 { (char *)"SigmaTotal_tInRange", _wrap_SigmaTotal_tInRange, METH_VARARGS, NULL},
	 { (char *)"SigmaTotal_swigregister", SigmaTotal_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SigmaTotOwn", _wrap_new_SigmaTotOwn, METH_VARARGS, NULL},
	 { (char *)"SigmaTotOwn_init", _wrap_SigmaTotOwn_init, METH_VARARGS, NULL},
	 { (char *)"SigmaTotOwn_calcTotEl", _wrap_SigmaTotOwn_calcTotEl, METH_VARARGS, NULL},
	 { (char *)"SigmaTotOwn_dsigmaEl", _wrap_SigmaTotOwn_dsigmaEl, METH_VARARGS, NULL},
	 { (char *)"SigmaTotOwn_calcDiff", _wrap_SigmaTotOwn_calcDiff, METH_VARARGS, NULL},
	 { (char *)"SigmaTotOwn_dsigmaSD", _wrap_SigmaTotOwn_dsigmaSD, METH_VARARGS, NULL},
	 { (char *)"SigmaTotOwn_dsigmaDD", _wrap_SigmaTotOwn_dsigmaDD, METH_VARARGS, NULL},
	 { (char *)"SigmaTotOwn_dsigmaCD", _wrap_SigmaTotOwn_dsigmaCD, METH_VARARGS, NULL},
	 { (char *)"SigmaTotOwn_mMinCD", _wrap_SigmaTotOwn_mMinCD, METH_VARARGS, NULL},
	 { (char *)"delete_SigmaTotOwn", _wrap_delete_SigmaTotOwn, METH_VARARGS, NULL},
	 { (char *)"SigmaTotOwn_swigregister", SigmaTotOwn_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SigmaSaSDL", _wrap_new_SigmaSaSDL, METH_VARARGS, NULL},
	 { (char *)"SigmaSaSDL_init", _wrap_SigmaSaSDL_init, METH_VARARGS, NULL},
	 { (char *)"SigmaSaSDL_calcTotEl", _wrap_SigmaSaSDL_calcTotEl, METH_VARARGS, NULL},
	 { (char *)"SigmaSaSDL_dsigmaEl", _wrap_SigmaSaSDL_dsigmaEl, METH_VARARGS, NULL},
	 { (char *)"SigmaSaSDL_calcDiff", _wrap_SigmaSaSDL_calcDiff, METH_VARARGS, NULL},
	 { (char *)"SigmaSaSDL_dsigmaSD", _wrap_SigmaSaSDL_dsigmaSD, METH_VARARGS, NULL},
	 { (char *)"SigmaSaSDL_dsigmaDD", _wrap_SigmaSaSDL_dsigmaDD, METH_VARARGS, NULL},
	 { (char *)"SigmaSaSDL_dsigmaCD", _wrap_SigmaSaSDL_dsigmaCD, METH_VARARGS, NULL},
	 { (char *)"SigmaSaSDL_mMinCD", _wrap_SigmaSaSDL_mMinCD, METH_VARARGS, NULL},
	 { (char *)"delete_SigmaSaSDL", _wrap_delete_SigmaSaSDL, METH_VARARGS, NULL},
	 { (char *)"SigmaSaSDL_swigregister", SigmaSaSDL_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SigmaMBR", _wrap_new_SigmaMBR, METH_VARARGS, NULL},
	 { (char *)"SigmaMBR_init", _wrap_SigmaMBR_init, METH_VARARGS, NULL},
	 { (char *)"SigmaMBR_calcTotEl", _wrap_SigmaMBR_calcTotEl, METH_VARARGS, NULL},
	 { (char *)"SigmaMBR_dsigmaEl", _wrap_SigmaMBR_dsigmaEl, METH_VARARGS, NULL},
	 { (char *)"SigmaMBR_calcDiff", _wrap_SigmaMBR_calcDiff, METH_VARARGS, NULL},
	 { (char *)"SigmaMBR_splitDiff", _wrap_SigmaMBR_splitDiff, METH_VARARGS, NULL},
	 { (char *)"SigmaMBR_dsigmaSD", _wrap_SigmaMBR_dsigmaSD, METH_VARARGS, NULL},
	 { (char *)"SigmaMBR_dsigmaDD", _wrap_SigmaMBR_dsigmaDD, METH_VARARGS, NULL},
	 { (char *)"SigmaMBR_dsigmaCD", _wrap_SigmaMBR_dsigmaCD, METH_VARARGS, NULL},
	 { (char *)"SigmaMBR_mMinCD", _wrap_SigmaMBR_mMinCD, METH_VARARGS, NULL},
	 { (char *)"delete_SigmaMBR", _wrap_delete_SigmaMBR, METH_VARARGS, NULL},
	 { (char *)"SigmaMBR_swigregister", SigmaMBR_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SigmaABMST", _wrap_new_SigmaABMST, METH_VARARGS, NULL},
	 { (char *)"SigmaABMST_init", _wrap_SigmaABMST_init, METH_VARARGS, NULL},
	 { (char *)"SigmaABMST_calcTotEl", _wrap_SigmaABMST_calcTotEl, METH_VARARGS, NULL},
	 { (char *)"SigmaABMST_dsigmaEl", _wrap_SigmaABMST_dsigmaEl, METH_VARARGS, NULL},
	 { (char *)"SigmaABMST_calcDiff", _wrap_SigmaABMST_calcDiff, METH_VARARGS, NULL},
	 { (char *)"SigmaABMST_dsigmaSD", _wrap_SigmaABMST_dsigmaSD, METH_VARARGS, NULL},
	 { (char *)"SigmaABMST_dsigmaDD", _wrap_SigmaABMST_dsigmaDD, METH_VARARGS, NULL},
	 { (char *)"SigmaABMST_dsigmaCD", _wrap_SigmaABMST_dsigmaCD, METH_VARARGS, NULL},
	 { (char *)"SigmaABMST_mMinCD", _wrap_SigmaABMST_mMinCD, METH_VARARGS, NULL},
	 { (char *)"delete_SigmaABMST", _wrap_delete_SigmaABMST, METH_VARARGS, NULL},
	 { (char *)"SigmaABMST_swigregister", SigmaABMST_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SigmaRPP", _wrap_new_SigmaRPP, METH_VARARGS, NULL},
	 { (char *)"SigmaRPP_init", _wrap_SigmaRPP_init, METH_VARARGS, NULL},
	 { (char *)"SigmaRPP_calcTotEl", _wrap_SigmaRPP_calcTotEl, METH_VARARGS, NULL},
	 { (char *)"SigmaRPP_dsigmaEl", _wrap_SigmaRPP_dsigmaEl, METH_VARARGS, NULL},
	 { (char *)"delete_SigmaRPP", _wrap_delete_SigmaRPP, METH_VARARGS, NULL},
	 { (char *)"SigmaRPP_swigregister", SigmaRPP_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SLHAinterface", _wrap_new_SLHAinterface, METH_VARARGS, NULL},
	 { (char *)"SLHAinterface_setPtr", _wrap_SLHAinterface_setPtr, METH_VARARGS, NULL},
	 { (char *)"SLHAinterface_init", _wrap_SLHAinterface_init, METH_VARARGS, NULL},
	 { (char *)"SLHAinterface_initSLHA", _wrap_SLHAinterface_initSLHA, METH_VARARGS, NULL},
	 { (char *)"SLHAinterface_pythia2slha", _wrap_SLHAinterface_pythia2slha, METH_VARARGS, NULL},
	 { (char *)"SLHAinterface_slha_set", _wrap_SLHAinterface_slha_set, METH_VARARGS, NULL},
	 { (char *)"SLHAinterface_slha_get", _wrap_SLHAinterface_slha_get, METH_VARARGS, NULL},
	 { (char *)"SLHAinterface_coupSUSY_set", _wrap_SLHAinterface_coupSUSY_set, METH_VARARGS, NULL},
	 { (char *)"SLHAinterface_coupSUSY_get", _wrap_SLHAinterface_coupSUSY_get, METH_VARARGS, NULL},
	 { (char *)"SLHAinterface_couplingsPtr_set", _wrap_SLHAinterface_couplingsPtr_set, METH_VARARGS, NULL},
	 { (char *)"SLHAinterface_couplingsPtr_get", _wrap_SLHAinterface_couplingsPtr_get, METH_VARARGS, NULL},
	 { (char *)"SLHAinterface_infoPtr_set", _wrap_SLHAinterface_infoPtr_set, METH_VARARGS, NULL},
	 { (char *)"SLHAinterface_infoPtr_get", _wrap_SLHAinterface_infoPtr_get, METH_VARARGS, NULL},
	 { (char *)"SLHAinterface_settingsPtr_set", _wrap_SLHAinterface_settingsPtr_set, METH_VARARGS, NULL},
	 { (char *)"SLHAinterface_settingsPtr_get", _wrap_SLHAinterface_settingsPtr_get, METH_VARARGS, NULL},
	 { (char *)"SLHAinterface_meMode_set", _wrap_SLHAinterface_meMode_set, METH_VARARGS, NULL},
	 { (char *)"SLHAinterface_meMode_get", _wrap_SLHAinterface_meMode_get, METH_VARARGS, NULL},
	 { (char *)"delete_SLHAinterface", _wrap_delete_SLHAinterface, METH_VARARGS, NULL},
	 { (char *)"SLHAinterface_swigregister", SLHAinterface_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_WidthFunction", _wrap_new_WidthFunction, METH_VARARGS, NULL},
	 { (char *)"delete_WidthFunction", _wrap_delete_WidthFunction, METH_VARARGS, NULL},
	 { (char *)"WidthFunction_setPointers", _wrap_WidthFunction_setPointers, METH_VARARGS, NULL},
	 { (char *)"WidthFunction_getWidth", _wrap_WidthFunction_getWidth, METH_VARARGS, NULL},
	 { (char *)"WidthFunction_f", _wrap_WidthFunction_f, METH_VARARGS, NULL},
	 { (char *)"WidthFunction_swigregister", WidthFunction_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_StauWidths", _wrap_delete_StauWidths, METH_VARARGS, NULL},
	 { (char *)"StauWidths_getWidth", _wrap_StauWidths_getWidth, METH_VARARGS, NULL},
	 { (char *)"new_StauWidths", _wrap_new_StauWidths, METH_VARARGS, NULL},
	 { (char *)"StauWidths_swigregister", StauWidths_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Particle", _wrap_new_Particle, METH_VARARGS, NULL},
	 { (char *)"Particle_setEvtPtr", _wrap_Particle_setEvtPtr, METH_VARARGS, NULL},
	 { (char *)"Particle_setPDEPtr", _wrap_Particle_setPDEPtr, METH_VARARGS, NULL},
	 { (char *)"Particle_statusPos", _wrap_Particle_statusPos, METH_VARARGS, NULL},
	 { (char *)"Particle_statusNeg", _wrap_Particle_statusNeg, METH_VARARGS, NULL},
	 { (char *)"Particle_statusCode", _wrap_Particle_statusCode, METH_VARARGS, NULL},
	 { (char *)"Particle_mothers", _wrap_Particle_mothers, METH_VARARGS, NULL},
	 { (char *)"Particle_daughters", _wrap_Particle_daughters, METH_VARARGS, NULL},
	 { (char *)"Particle_cols", _wrap_Particle_cols, METH_VARARGS, NULL},
	 { (char *)"Particle_id", _wrap_Particle_id, METH_VARARGS, NULL},
	 { (char *)"Particle_status", _wrap_Particle_status, METH_VARARGS, NULL},
	 { (char *)"Particle_mother1", _wrap_Particle_mother1, METH_VARARGS, NULL},
	 { (char *)"Particle_mother2", _wrap_Particle_mother2, METH_VARARGS, NULL},
	 { (char *)"Particle_daughter1", _wrap_Particle_daughter1, METH_VARARGS, NULL},
	 { (char *)"Particle_daughter2", _wrap_Particle_daughter2, METH_VARARGS, NULL},
	 { (char *)"Particle_col", _wrap_Particle_col, METH_VARARGS, NULL},
	 { (char *)"Particle_acol", _wrap_Particle_acol, METH_VARARGS, NULL},
	 { (char *)"Particle_p", _wrap_Particle_p, METH_VARARGS, NULL},
	 { (char *)"Particle_px", _wrap_Particle_px, METH_VARARGS, NULL},
	 { (char *)"Particle_py", _wrap_Particle_py, METH_VARARGS, NULL},
	 { (char *)"Particle_pz", _wrap_Particle_pz, METH_VARARGS, NULL},
	 { (char *)"Particle_e", _wrap_Particle_e, METH_VARARGS, NULL},
	 { (char *)"Particle_m", _wrap_Particle_m, METH_VARARGS, NULL},
	 { (char *)"Particle_scale", _wrap_Particle_scale, METH_VARARGS, NULL},
	 { (char *)"Particle_pol", _wrap_Particle_pol, METH_VARARGS, NULL},
	 { (char *)"Particle_hasVertex", _wrap_Particle_hasVertex, METH_VARARGS, NULL},
	 { (char *)"Particle_vProd", _wrap_Particle_vProd, METH_VARARGS, NULL},
	 { (char *)"Particle_xProd", _wrap_Particle_xProd, METH_VARARGS, NULL},
	 { (char *)"Particle_yProd", _wrap_Particle_yProd, METH_VARARGS, NULL},
	 { (char *)"Particle_zProd", _wrap_Particle_zProd, METH_VARARGS, NULL},
	 { (char *)"Particle_tProd", _wrap_Particle_tProd, METH_VARARGS, NULL},
	 { (char *)"Particle_tau", _wrap_Particle_tau, METH_VARARGS, NULL},
	 { (char *)"Particle_idAbs", _wrap_Particle_idAbs, METH_VARARGS, NULL},
	 { (char *)"Particle_statusAbs", _wrap_Particle_statusAbs, METH_VARARGS, NULL},
	 { (char *)"Particle_isFinal", _wrap_Particle_isFinal, METH_VARARGS, NULL},
	 { (char *)"Particle_intPol", _wrap_Particle_intPol, METH_VARARGS, NULL},
	 { (char *)"Particle_isRescatteredIncoming", _wrap_Particle_isRescatteredIncoming, METH_VARARGS, NULL},
	 { (char *)"Particle_m2", _wrap_Particle_m2, METH_VARARGS, NULL},
	 { (char *)"Particle_mCalc", _wrap_Particle_mCalc, METH_VARARGS, NULL},
	 { (char *)"Particle_m2Calc", _wrap_Particle_m2Calc, METH_VARARGS, NULL},
	 { (char *)"Particle_eCalc", _wrap_Particle_eCalc, METH_VARARGS, NULL},
	 { (char *)"Particle_pT", _wrap_Particle_pT, METH_VARARGS, NULL},
	 { (char *)"Particle_pT2", _wrap_Particle_pT2, METH_VARARGS, NULL},
	 { (char *)"Particle_mT", _wrap_Particle_mT, METH_VARARGS, NULL},
	 { (char *)"Particle_mT2", _wrap_Particle_mT2, METH_VARARGS, NULL},
	 { (char *)"Particle_pAbs", _wrap_Particle_pAbs, METH_VARARGS, NULL},
	 { (char *)"Particle_pAbs2", _wrap_Particle_pAbs2, METH_VARARGS, NULL},
	 { (char *)"Particle_eT", _wrap_Particle_eT, METH_VARARGS, NULL},
	 { (char *)"Particle_eT2", _wrap_Particle_eT2, METH_VARARGS, NULL},
	 { (char *)"Particle_theta", _wrap_Particle_theta, METH_VARARGS, NULL},
	 { (char *)"Particle_phi", _wrap_Particle_phi, METH_VARARGS, NULL},
	 { (char *)"Particle_thetaXZ", _wrap_Particle_thetaXZ, METH_VARARGS, NULL},
	 { (char *)"Particle_pPos", _wrap_Particle_pPos, METH_VARARGS, NULL},
	 { (char *)"Particle_pNeg", _wrap_Particle_pNeg, METH_VARARGS, NULL},
	 { (char *)"Particle_eta", _wrap_Particle_eta, METH_VARARGS, NULL},
	 { (char *)"Particle_y", _wrap_Particle_y, METH_VARARGS, NULL},
	 { (char *)"Particle_vDec", _wrap_Particle_vDec, METH_VARARGS, NULL},
	 { (char *)"Particle_xDec", _wrap_Particle_xDec, METH_VARARGS, NULL},
	 { (char *)"Particle_yDec", _wrap_Particle_yDec, METH_VARARGS, NULL},
	 { (char *)"Particle_zDec", _wrap_Particle_zDec, METH_VARARGS, NULL},
	 { (char *)"Particle_tDec", _wrap_Particle_tDec, METH_VARARGS, NULL},
	 { (char *)"Particle_index", _wrap_Particle_index, METH_VARARGS, NULL},
	 { (char *)"Particle_iTopCopy", _wrap_Particle_iTopCopy, METH_VARARGS, NULL},
	 { (char *)"Particle_iBotCopy", _wrap_Particle_iBotCopy, METH_VARARGS, NULL},
	 { (char *)"Particle_iTopCopyId", _wrap_Particle_iTopCopyId, METH_VARARGS, NULL},
	 { (char *)"Particle_iBotCopyId", _wrap_Particle_iBotCopyId, METH_VARARGS, NULL},
	 { (char *)"Particle_motherList", _wrap_Particle_motherList, METH_VARARGS, NULL},
	 { (char *)"Particle_daughterList", _wrap_Particle_daughterList, METH_VARARGS, NULL},
	 { (char *)"Particle_daughterListRecursive", _wrap_Particle_daughterListRecursive, METH_VARARGS, NULL},
	 { (char *)"Particle_sisterList", _wrap_Particle_sisterList, METH_VARARGS, NULL},
	 { (char *)"Particle_isAncestor", _wrap_Particle_isAncestor, METH_VARARGS, NULL},
	 { (char *)"Particle_statusHepMC", _wrap_Particle_statusHepMC, METH_VARARGS, NULL},
	 { (char *)"Particle_isFinalPartonLevel", _wrap_Particle_isFinalPartonLevel, METH_VARARGS, NULL},
	 { (char *)"Particle_undoDecay", _wrap_Particle_undoDecay, METH_VARARGS, NULL},
	 { (char *)"Particle_name", _wrap_Particle_name, METH_VARARGS, NULL},
	 { (char *)"Particle_nameWithStatus", _wrap_Particle_nameWithStatus, METH_VARARGS, NULL},
	 { (char *)"Particle_spinType", _wrap_Particle_spinType, METH_VARARGS, NULL},
	 { (char *)"Particle_chargeType", _wrap_Particle_chargeType, METH_VARARGS, NULL},
	 { (char *)"Particle_charge", _wrap_Particle_charge, METH_VARARGS, NULL},
	 { (char *)"Particle_isCharged", _wrap_Particle_isCharged, METH_VARARGS, NULL},
	 { (char *)"Particle_isNeutral", _wrap_Particle_isNeutral, METH_VARARGS, NULL},
	 { (char *)"Particle_colType", _wrap_Particle_colType, METH_VARARGS, NULL},
	 { (char *)"Particle_m0", _wrap_Particle_m0, METH_VARARGS, NULL},
	 { (char *)"Particle_mWidth", _wrap_Particle_mWidth, METH_VARARGS, NULL},
	 { (char *)"Particle_mMin", _wrap_Particle_mMin, METH_VARARGS, NULL},
	 { (char *)"Particle_mMax", _wrap_Particle_mMax, METH_VARARGS, NULL},
	 { (char *)"Particle_mSel", _wrap_Particle_mSel, METH_VARARGS, NULL},
	 { (char *)"Particle_constituentMass", _wrap_Particle_constituentMass, METH_VARARGS, NULL},
	 { (char *)"Particle_tau0", _wrap_Particle_tau0, METH_VARARGS, NULL},
	 { (char *)"Particle_mayDecay", _wrap_Particle_mayDecay, METH_VARARGS, NULL},
	 { (char *)"Particle_canDecay", _wrap_Particle_canDecay, METH_VARARGS, NULL},
	 { (char *)"Particle_doExternalDecay", _wrap_Particle_doExternalDecay, METH_VARARGS, NULL},
	 { (char *)"Particle_isResonance", _wrap_Particle_isResonance, METH_VARARGS, NULL},
	 { (char *)"Particle_isVisible", _wrap_Particle_isVisible, METH_VARARGS, NULL},
	 { (char *)"Particle_isLepton", _wrap_Particle_isLepton, METH_VARARGS, NULL},
	 { (char *)"Particle_isQuark", _wrap_Particle_isQuark, METH_VARARGS, NULL},
	 { (char *)"Particle_isGluon", _wrap_Particle_isGluon, METH_VARARGS, NULL},
	 { (char *)"Particle_isDiquark", _wrap_Particle_isDiquark, METH_VARARGS, NULL},
	 { (char *)"Particle_isParton", _wrap_Particle_isParton, METH_VARARGS, NULL},
	 { (char *)"Particle_isHadron", _wrap_Particle_isHadron, METH_VARARGS, NULL},
	 { (char *)"Particle_particleDataEntry", _wrap_Particle_particleDataEntry, METH_VARARGS, NULL},
	 { (char *)"Particle_rescale3", _wrap_Particle_rescale3, METH_VARARGS, NULL},
	 { (char *)"Particle_rescale4", _wrap_Particle_rescale4, METH_VARARGS, NULL},
	 { (char *)"Particle_rescale5", _wrap_Particle_rescale5, METH_VARARGS, NULL},
	 { (char *)"Particle_rot", _wrap_Particle_rot, METH_VARARGS, NULL},
	 { (char *)"Particle_bst", _wrap_Particle_bst, METH_VARARGS, NULL},
	 { (char *)"Particle_bstback", _wrap_Particle_bstback, METH_VARARGS, NULL},
	 { (char *)"Particle_rotbst", _wrap_Particle_rotbst, METH_VARARGS, NULL},
	 { (char *)"Particle_offsetHistory", _wrap_Particle_offsetHistory, METH_VARARGS, NULL},
	 { (char *)"Particle_offsetCol", _wrap_Particle_offsetCol, METH_VARARGS, NULL},
	 { (char *)"delete_Particle", _wrap_delete_Particle, METH_VARARGS, NULL},
	 { (char *)"Particle_swigregister", Particle_swigregister, METH_VARARGS, NULL},
	 { (char *)"m", _wrap_m, METH_VARARGS, NULL},
	 { (char *)"new_Junction", _wrap_new_Junction, METH_VARARGS, NULL},
	 { (char *)"Junction_cols", _wrap_Junction_cols, METH_VARARGS, NULL},
	 { (char *)"Junction_remains", _wrap_Junction_remains, METH_VARARGS, NULL},
	 { (char *)"Junction_kind", _wrap_Junction_kind, METH_VARARGS, NULL},
	 { (char *)"Junction_col", _wrap_Junction_col, METH_VARARGS, NULL},
	 { (char *)"Junction_endCol", _wrap_Junction_endCol, METH_VARARGS, NULL},
	 { (char *)"Junction_status", _wrap_Junction_status, METH_VARARGS, NULL},
	 { (char *)"delete_Junction", _wrap_delete_Junction, METH_VARARGS, NULL},
	 { (char *)"Junction_swigregister", Junction_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Event", _wrap_new_Event, METH_VARARGS, NULL},
	 { (char *)"Event_init", _wrap_Event_init, METH_VARARGS, NULL},
	 { (char *)"Event_clear", _wrap_Event_clear, METH_VARARGS, NULL},
	 { (char *)"Event_reset", _wrap_Event_reset, METH_VARARGS, NULL},
	 { (char *)"Event_front", _wrap_Event_front, METH_VARARGS, NULL},
	 { (char *)"Event_at", _wrap_Event_at, METH_VARARGS, NULL},
	 { (char *)"Event_back", _wrap_Event_back, METH_VARARGS, NULL},
	 { (char *)"Event_size", _wrap_Event_size, METH_VARARGS, NULL},
	 { (char *)"Event_append", _wrap_Event_append, METH_VARARGS, NULL},
	 { (char *)"Event_setEvtPtr", _wrap_Event_setEvtPtr, METH_VARARGS, NULL},
	 { (char *)"Event_copy", _wrap_Event_copy, METH_VARARGS, NULL},
	 { (char *)"Event_popBack", _wrap_Event_popBack, METH_VARARGS, NULL},
	 { (char *)"Event_remove", _wrap_Event_remove, METH_VARARGS, NULL},
	 { (char *)"Event_restorePtrs", _wrap_Event_restorePtrs, METH_VARARGS, NULL},
	 { (char *)"Event_saveSize", _wrap_Event_saveSize, METH_VARARGS, NULL},
	 { (char *)"Event_restoreSize", _wrap_Event_restoreSize, METH_VARARGS, NULL},
	 { (char *)"Event_savedSizeValue", _wrap_Event_savedSizeValue, METH_VARARGS, NULL},
	 { (char *)"Event_initColTag", _wrap_Event_initColTag, METH_VARARGS, NULL},
	 { (char *)"Event_lastColTag", _wrap_Event_lastColTag, METH_VARARGS, NULL},
	 { (char *)"Event_nextColTag", _wrap_Event_nextColTag, METH_VARARGS, NULL},
	 { (char *)"Event_scale", _wrap_Event_scale, METH_VARARGS, NULL},
	 { (char *)"Event_scaleSecond", _wrap_Event_scaleSecond, METH_VARARGS, NULL},
	 { (char *)"Event_daughterList", _wrap_Event_daughterList, METH_VARARGS, NULL},
	 { (char *)"Event_rot", _wrap_Event_rot, METH_VARARGS, NULL},
	 { (char *)"Event_bst", _wrap_Event_bst, METH_VARARGS, NULL},
	 { (char *)"Event_rotbst", _wrap_Event_rotbst, METH_VARARGS, NULL},
	 { (char *)"Event_clearJunctions", _wrap_Event_clearJunctions, METH_VARARGS, NULL},
	 { (char *)"Event_appendJunction", _wrap_Event_appendJunction, METH_VARARGS, NULL},
	 { (char *)"Event_sizeJunction", _wrap_Event_sizeJunction, METH_VARARGS, NULL},
	 { (char *)"Event_remainsJunction", _wrap_Event_remainsJunction, METH_VARARGS, NULL},
	 { (char *)"Event_kindJunction", _wrap_Event_kindJunction, METH_VARARGS, NULL},
	 { (char *)"Event_colJunction", _wrap_Event_colJunction, METH_VARARGS, NULL},
	 { (char *)"Event_endColJunction", _wrap_Event_endColJunction, METH_VARARGS, NULL},
	 { (char *)"Event_statusJunction", _wrap_Event_statusJunction, METH_VARARGS, NULL},
	 { (char *)"Event_getJunction", _wrap_Event_getJunction, METH_VARARGS, NULL},
	 { (char *)"Event_eraseJunction", _wrap_Event_eraseJunction, METH_VARARGS, NULL},
	 { (char *)"Event_saveJunctionSize", _wrap_Event_saveJunctionSize, METH_VARARGS, NULL},
	 { (char *)"Event_restoreJunctionSize", _wrap_Event_restoreJunctionSize, METH_VARARGS, NULL},
	 { (char *)"Event_listJunctions", _wrap_Event_listJunctions, METH_VARARGS, NULL},
	 { (char *)"Event_savePartonLevelSize", _wrap_Event_savePartonLevelSize, METH_VARARGS, NULL},
	 { (char *)"Event___iadd__", _wrap_Event___iadd__, METH_VARARGS, NULL},
	 { (char *)"Event___str__", _wrap_Event___str__, METH_VARARGS, NULL},
	 { (char *)"Event___getitem__", _wrap_Event___getitem__, METH_VARARGS, NULL},
	 { (char *)"delete_Event", _wrap_delete_Event, METH_VARARGS, NULL},
	 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FlavContainer", _wrap_new_FlavContainer, METH_VARARGS, NULL},
	 { (char *)"FlavContainer_copy", _wrap_FlavContainer_copy, METH_VARARGS, NULL},
	 { (char *)"FlavContainer_anti", _wrap_FlavContainer_anti, METH_VARARGS, NULL},
	 { (char *)"FlavContainer_isDiquark", _wrap_FlavContainer_isDiquark, METH_VARARGS, NULL},
	 { (char *)"FlavContainer_id_set", _wrap_FlavContainer_id_set, METH_VARARGS, NULL},
	 { (char *)"FlavContainer_id_get", _wrap_FlavContainer_id_get, METH_VARARGS, NULL},
	 { (char *)"FlavContainer_rank_set", _wrap_FlavContainer_rank_set, METH_VARARGS, NULL},
	 { (char *)"FlavContainer_rank_get", _wrap_FlavContainer_rank_get, METH_VARARGS, NULL},
	 { (char *)"FlavContainer_nPop_set", _wrap_FlavContainer_nPop_set, METH_VARARGS, NULL},
	 { (char *)"FlavContainer_nPop_get", _wrap_FlavContainer_nPop_get, METH_VARARGS, NULL},
	 { (char *)"FlavContainer_idPop_set", _wrap_FlavContainer_idPop_set, METH_VARARGS, NULL},
	 { (char *)"FlavContainer_idPop_get", _wrap_FlavContainer_idPop_get, METH_VARARGS, NULL},
	 { (char *)"FlavContainer_idVtx_set", _wrap_FlavContainer_idVtx_set, METH_VARARGS, NULL},
	 { (char *)"FlavContainer_idVtx_get", _wrap_FlavContainer_idVtx_get, METH_VARARGS, NULL},
	 { (char *)"delete_FlavContainer", _wrap_delete_FlavContainer, METH_VARARGS, NULL},
	 { (char *)"FlavContainer_swigregister", FlavContainer_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StringFlav", _wrap_new_StringFlav, METH_VARARGS, NULL},
	 { (char *)"delete_StringFlav", _wrap_delete_StringFlav, METH_VARARGS, NULL},
	 { (char *)"StringFlav_init", _wrap_StringFlav_init, METH_VARARGS, NULL},
	 { (char *)"StringFlav_pickLightQ", _wrap_StringFlav_pickLightQ, METH_VARARGS, NULL},
	 { (char *)"StringFlav_pick", _wrap_StringFlav_pick, METH_VARARGS, NULL},
	 { (char *)"StringFlav_pickGauss", _wrap_StringFlav_pickGauss, METH_VARARGS, NULL},
	 { (char *)"StringFlav_pickThermal", _wrap_StringFlav_pickThermal, METH_VARARGS, NULL},
	 { (char *)"StringFlav_combine", _wrap_StringFlav_combine, METH_VARARGS, NULL},
	 { (char *)"StringFlav_combineId", _wrap_StringFlav_combineId, METH_VARARGS, NULL},
	 { (char *)"StringFlav_getHadronIDwin", _wrap_StringFlav_getHadronIDwin, METH_VARARGS, NULL},
	 { (char *)"StringFlav_combineLastThermal", _wrap_StringFlav_combineLastThermal, METH_VARARGS, NULL},
	 { (char *)"StringFlav_getHadronID", _wrap_StringFlav_getHadronID, METH_VARARGS, NULL},
	 { (char *)"StringFlav_getHadronMassWin", _wrap_StringFlav_getHadronMassWin, METH_VARARGS, NULL},
	 { (char *)"StringFlav_assignPopQ", _wrap_StringFlav_assignPopQ, METH_VARARGS, NULL},
	 { (char *)"StringFlav_makeDiquark", _wrap_StringFlav_makeDiquark, METH_VARARGS, NULL},
	 { (char *)"StringFlav_addQuarkDiquark", _wrap_StringFlav_addQuarkDiquark, METH_VARARGS, NULL},
	 { (char *)"StringFlav_getMesonSpinCounter", _wrap_StringFlav_getMesonSpinCounter, METH_VARARGS, NULL},
	 { (char *)"StringFlav_swigregister", StringFlav_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LundFFRaw", _wrap_new_LundFFRaw, METH_VARARGS, NULL},
	 { (char *)"delete_LundFFRaw", _wrap_delete_LundFFRaw, METH_VARARGS, NULL},
	 { (char *)"LundFFRaw_f", _wrap_LundFFRaw_f, METH_VARARGS, NULL},
	 { (char *)"LundFFRaw_swigregister", LundFFRaw_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LundFFAvg", _wrap_new_LundFFAvg, METH_VARARGS, NULL},
	 { (char *)"delete_LundFFAvg", _wrap_delete_LundFFAvg, METH_VARARGS, NULL},
	 { (char *)"LundFFAvg_f", _wrap_LundFFAvg_f, METH_VARARGS, NULL},
	 { (char *)"LundFFAvg_swigregister", LundFFAvg_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StringZ", _wrap_new_StringZ, METH_VARARGS, NULL},
	 { (char *)"delete_StringZ", _wrap_delete_StringZ, METH_VARARGS, NULL},
	 { (char *)"StringZ_init", _wrap_StringZ_init, METH_VARARGS, NULL},
	 { (char *)"StringZ_zFrag", _wrap_StringZ_zFrag, METH_VARARGS, NULL},
	 { (char *)"StringZ_stopMass", _wrap_StringZ_stopMass, METH_VARARGS, NULL},
	 { (char *)"StringZ_stopNewFlav", _wrap_StringZ_stopNewFlav, METH_VARARGS, NULL},
	 { (char *)"StringZ_stopSmear", _wrap_StringZ_stopSmear, METH_VARARGS, NULL},
	 { (char *)"StringZ_aAreaLund", _wrap_StringZ_aAreaLund, METH_VARARGS, NULL},
	 { (char *)"StringZ_bAreaLund", _wrap_StringZ_bAreaLund, METH_VARARGS, NULL},
	 { (char *)"StringZ_deriveBLund", _wrap_StringZ_deriveBLund, METH_VARARGS, NULL},
	 { (char *)"StringZ_swigregister", StringZ_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StringPT", _wrap_new_StringPT, METH_VARARGS, NULL},
	 { (char *)"delete_StringPT", _wrap_delete_StringPT, METH_VARARGS, NULL},
	 { (char *)"StringPT_init", _wrap_StringPT_init, METH_VARARGS, NULL},
	 { (char *)"StringPT_pxy", _wrap_StringPT_pxy, METH_VARARGS, NULL},
	 { (char *)"StringPT_pxyGauss", _wrap_StringPT_pxyGauss, METH_VARARGS, NULL},
	 { (char *)"StringPT_pxyThermal", _wrap_StringPT_pxyThermal, METH_VARARGS, NULL},
	 { (char *)"StringPT_suppressPT2", _wrap_StringPT_suppressPT2, METH_VARARGS, NULL},
	 { (char *)"StringPT_swigregister", StringPT_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ColSinglet", _wrap_new_ColSinglet, METH_VARARGS, NULL},
	 { (char *)"ColSinglet_size", _wrap_ColSinglet_size, METH_VARARGS, NULL},
	 { (char *)"ColSinglet_iParton_set", _wrap_ColSinglet_iParton_set, METH_VARARGS, NULL},
	 { (char *)"ColSinglet_iParton_get", _wrap_ColSinglet_iParton_get, METH_VARARGS, NULL},
	 { (char *)"ColSinglet_pSum_set", _wrap_ColSinglet_pSum_set, METH_VARARGS, NULL},
	 { (char *)"ColSinglet_pSum_get", _wrap_ColSinglet_pSum_get, METH_VARARGS, NULL},
	 { (char *)"ColSinglet_mass_set", _wrap_ColSinglet_mass_set, METH_VARARGS, NULL},
	 { (char *)"ColSinglet_mass_get", _wrap_ColSinglet_mass_get, METH_VARARGS, NULL},
	 { (char *)"ColSinglet_massExcess_set", _wrap_ColSinglet_massExcess_set, METH_VARARGS, NULL},
	 { (char *)"ColSinglet_massExcess_get", _wrap_ColSinglet_massExcess_get, METH_VARARGS, NULL},
	 { (char *)"ColSinglet_hasJunction_set", _wrap_ColSinglet_hasJunction_set, METH_VARARGS, NULL},
	 { (char *)"ColSinglet_hasJunction_get", _wrap_ColSinglet_hasJunction_get, METH_VARARGS, NULL},
	 { (char *)"ColSinglet_isClosed_set", _wrap_ColSinglet_isClosed_set, METH_VARARGS, NULL},
	 { (char *)"ColSinglet_isClosed_get", _wrap_ColSinglet_isClosed_get, METH_VARARGS, NULL},
	 { (char *)"ColSinglet_isCollected_set", _wrap_ColSinglet_isCollected_set, METH_VARARGS, NULL},
	 { (char *)"ColSinglet_isCollected_get", _wrap_ColSinglet_isCollected_get, METH_VARARGS, NULL},
	 { (char *)"delete_ColSinglet", _wrap_delete_ColSinglet, METH_VARARGS, NULL},
	 { (char *)"ColSinglet_swigregister", ColSinglet_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ColConfig", _wrap_new_ColConfig, METH_VARARGS, NULL},
	 { (char *)"ColConfig_init", _wrap_ColConfig_init, METH_VARARGS, NULL},
	 { (char *)"ColConfig_size", _wrap_ColConfig_size, METH_VARARGS, NULL},
	 { (char *)"ColConfig_clear", _wrap_ColConfig_clear, METH_VARARGS, NULL},
	 { (char *)"ColConfig_insert", _wrap_ColConfig_insert, METH_VARARGS, NULL},
	 { (char *)"ColConfig_erase", _wrap_ColConfig_erase, METH_VARARGS, NULL},
	 { (char *)"ColConfig_collect", _wrap_ColConfig_collect, METH_VARARGS, NULL},
	 { (char *)"ColConfig_findSinglet", _wrap_ColConfig_findSinglet, METH_VARARGS, NULL},
	 { (char *)"ColConfig_rapPairs_set", _wrap_ColConfig_rapPairs_set, METH_VARARGS, NULL},
	 { (char *)"ColConfig_rapPairs_get", _wrap_ColConfig_rapPairs_get, METH_VARARGS, NULL},
	 { (char *)"ColConfig___str__", _wrap_ColConfig___str__, METH_VARARGS, NULL},
	 { (char *)"ColConfig___getitem__", _wrap_ColConfig___getitem__, METH_VARARGS, NULL},
	 { (char *)"delete_ColConfig", _wrap_delete_ColConfig, METH_VARARGS, NULL},
	 { (char *)"ColConfig_swigregister", ColConfig_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StringRegion", _wrap_new_StringRegion, METH_VARARGS, NULL},
	 { (char *)"StringRegion_isSetUp_set", _wrap_StringRegion_isSetUp_set, METH_VARARGS, NULL},
	 { (char *)"StringRegion_isSetUp_get", _wrap_StringRegion_isSetUp_get, METH_VARARGS, NULL},
	 { (char *)"StringRegion_isEmpty_set", _wrap_StringRegion_isEmpty_set, METH_VARARGS, NULL},
	 { (char *)"StringRegion_isEmpty_get", _wrap_StringRegion_isEmpty_get, METH_VARARGS, NULL},
	 { (char *)"StringRegion_pPos_set", _wrap_StringRegion_pPos_set, METH_VARARGS, NULL},
	 { (char *)"StringRegion_pPos_get", _wrap_StringRegion_pPos_get, METH_VARARGS, NULL},
	 { (char *)"StringRegion_pNeg_set", _wrap_StringRegion_pNeg_set, METH_VARARGS, NULL},
	 { (char *)"StringRegion_pNeg_get", _wrap_StringRegion_pNeg_get, METH_VARARGS, NULL},
	 { (char *)"StringRegion_eX_set", _wrap_StringRegion_eX_set, METH_VARARGS, NULL},
	 { (char *)"StringRegion_eX_get", _wrap_StringRegion_eX_get, METH_VARARGS, NULL},
	 { (char *)"StringRegion_eY_set", _wrap_StringRegion_eY_set, METH_VARARGS, NULL},
	 { (char *)"StringRegion_eY_get", _wrap_StringRegion_eY_get, METH_VARARGS, NULL},
	 { (char *)"StringRegion_pPosMass_set", _wrap_StringRegion_pPosMass_set, METH_VARARGS, NULL},
	 { (char *)"StringRegion_pPosMass_get", _wrap_StringRegion_pPosMass_get, METH_VARARGS, NULL},
	 { (char *)"StringRegion_pNegMass_set", _wrap_StringRegion_pNegMass_set, METH_VARARGS, NULL},
	 { (char *)"StringRegion_pNegMass_get", _wrap_StringRegion_pNegMass_get, METH_VARARGS, NULL},
	 { (char *)"StringRegion_massOffset_set", _wrap_StringRegion_massOffset_set, METH_VARARGS, NULL},
	 { (char *)"StringRegion_massOffset_get", _wrap_StringRegion_massOffset_get, METH_VARARGS, NULL},
	 { (char *)"StringRegion_w2_set", _wrap_StringRegion_w2_set, METH_VARARGS, NULL},
	 { (char *)"StringRegion_w2_get", _wrap_StringRegion_w2_get, METH_VARARGS, NULL},
	 { (char *)"StringRegion_xPosProj_set", _wrap_StringRegion_xPosProj_set, METH_VARARGS, NULL},
	 { (char *)"StringRegion_xPosProj_get", _wrap_StringRegion_xPosProj_get, METH_VARARGS, NULL},
	 { (char *)"StringRegion_xNegProj_set", _wrap_StringRegion_xNegProj_set, METH_VARARGS, NULL},
	 { (char *)"StringRegion_xNegProj_get", _wrap_StringRegion_xNegProj_get, METH_VARARGS, NULL},
	 { (char *)"StringRegion_pxProj_set", _wrap_StringRegion_pxProj_set, METH_VARARGS, NULL},
	 { (char *)"StringRegion_pxProj_get", _wrap_StringRegion_pxProj_get, METH_VARARGS, NULL},
	 { (char *)"StringRegion_pyProj_set", _wrap_StringRegion_pyProj_set, METH_VARARGS, NULL},
	 { (char *)"StringRegion_pyProj_get", _wrap_StringRegion_pyProj_get, METH_VARARGS, NULL},
	 { (char *)"StringRegion_gluonOffset", _wrap_StringRegion_gluonOffset, METH_VARARGS, NULL},
	 { (char *)"StringRegion_gluonOffsetJRF", _wrap_StringRegion_gluonOffsetJRF, METH_VARARGS, NULL},
	 { (char *)"StringRegion_massiveOffset", _wrap_StringRegion_massiveOffset, METH_VARARGS, NULL},
	 { (char *)"StringRegion_setUp", _wrap_StringRegion_setUp, METH_VARARGS, NULL},
	 { (char *)"StringRegion_pHad", _wrap_StringRegion_pHad, METH_VARARGS, NULL},
	 { (char *)"StringRegion_project", _wrap_StringRegion_project, METH_VARARGS, NULL},
	 { (char *)"StringRegion_xPos", _wrap_StringRegion_xPos, METH_VARARGS, NULL},
	 { (char *)"StringRegion_xNeg", _wrap_StringRegion_xNeg, METH_VARARGS, NULL},
	 { (char *)"StringRegion_px", _wrap_StringRegion_px, METH_VARARGS, NULL},
	 { (char *)"StringRegion_py", _wrap_StringRegion_py, METH_VARARGS, NULL},
	 { (char *)"delete_StringRegion", _wrap_delete_StringRegion, METH_VARARGS, NULL},
	 { (char *)"StringRegion_swigregister", StringRegion_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StringSystem", _wrap_new_StringSystem, METH_VARARGS, NULL},
	 { (char *)"StringSystem_setUp", _wrap_StringSystem_setUp, METH_VARARGS, NULL},
	 { (char *)"StringSystem_iReg", _wrap_StringSystem_iReg, METH_VARARGS, NULL},
	 { (char *)"StringSystem_region", _wrap_StringSystem_region, METH_VARARGS, NULL},
	 { (char *)"StringSystem_regionLowPos", _wrap_StringSystem_regionLowPos, METH_VARARGS, NULL},
	 { (char *)"StringSystem_regionLowNeg", _wrap_StringSystem_regionLowNeg, METH_VARARGS, NULL},
	 { (char *)"StringSystem_system_set", _wrap_StringSystem_system_set, METH_VARARGS, NULL},
	 { (char *)"StringSystem_system_get", _wrap_StringSystem_system_get, METH_VARARGS, NULL},
	 { (char *)"StringSystem_sizePartons_set", _wrap_StringSystem_sizePartons_set, METH_VARARGS, NULL},
	 { (char *)"StringSystem_sizePartons_get", _wrap_StringSystem_sizePartons_get, METH_VARARGS, NULL},
	 { (char *)"StringSystem_sizeStrings_set", _wrap_StringSystem_sizeStrings_set, METH_VARARGS, NULL},
	 { (char *)"StringSystem_sizeStrings_get", _wrap_StringSystem_sizeStrings_get, METH_VARARGS, NULL},
	 { (char *)"StringSystem_sizeRegions_set", _wrap_StringSystem_sizeRegions_set, METH_VARARGS, NULL},
	 { (char *)"StringSystem_sizeRegions_get", _wrap_StringSystem_sizeRegions_get, METH_VARARGS, NULL},
	 { (char *)"StringSystem_indxReg_set", _wrap_StringSystem_indxReg_set, METH_VARARGS, NULL},
	 { (char *)"StringSystem_indxReg_get", _wrap_StringSystem_indxReg_get, METH_VARARGS, NULL},
	 { (char *)"StringSystem_iMax_set", _wrap_StringSystem_iMax_set, METH_VARARGS, NULL},
	 { (char *)"StringSystem_iMax_get", _wrap_StringSystem_iMax_get, METH_VARARGS, NULL},
	 { (char *)"StringSystem_mJoin_set", _wrap_StringSystem_mJoin_set, METH_VARARGS, NULL},
	 { (char *)"StringSystem_mJoin_get", _wrap_StringSystem_mJoin_get, METH_VARARGS, NULL},
	 { (char *)"StringSystem_m2Join_set", _wrap_StringSystem_m2Join_set, METH_VARARGS, NULL},
	 { (char *)"StringSystem_m2Join_get", _wrap_StringSystem_m2Join_get, METH_VARARGS, NULL},
	 { (char *)"delete_StringSystem", _wrap_delete_StringSystem, METH_VARARGS, NULL},
	 { (char *)"StringSystem_swigregister", StringSystem_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StringVertex", _wrap_new_StringVertex, METH_VARARGS, NULL},
	 { (char *)"StringVertex_fromPos_set", _wrap_StringVertex_fromPos_set, METH_VARARGS, NULL},
	 { (char *)"StringVertex_fromPos_get", _wrap_StringVertex_fromPos_get, METH_VARARGS, NULL},
	 { (char *)"StringVertex_iRegPos_set", _wrap_StringVertex_iRegPos_set, METH_VARARGS, NULL},
	 { (char *)"StringVertex_iRegPos_get", _wrap_StringVertex_iRegPos_get, METH_VARARGS, NULL},
	 { (char *)"StringVertex_iRegNeg_set", _wrap_StringVertex_iRegNeg_set, METH_VARARGS, NULL},
	 { (char *)"StringVertex_iRegNeg_get", _wrap_StringVertex_iRegNeg_get, METH_VARARGS, NULL},
	 { (char *)"StringVertex_xRegPos_set", _wrap_StringVertex_xRegPos_set, METH_VARARGS, NULL},
	 { (char *)"StringVertex_xRegPos_get", _wrap_StringVertex_xRegPos_get, METH_VARARGS, NULL},
	 { (char *)"StringVertex_xRegNeg_set", _wrap_StringVertex_xRegNeg_set, METH_VARARGS, NULL},
	 { (char *)"StringVertex_xRegNeg_get", _wrap_StringVertex_xRegNeg_get, METH_VARARGS, NULL},
	 { (char *)"delete_StringVertex", _wrap_delete_StringVertex, METH_VARARGS, NULL},
	 { (char *)"StringVertex_swigregister", StringVertex_swigregister, METH_VARARGS, NULL},
	 { (char *)"SigmaPartialWave_init", _wrap_SigmaPartialWave_init, METH_VARARGS, NULL},
	 { (char *)"SigmaPartialWave_readFile", _wrap_SigmaPartialWave_readFile, METH_VARARGS, NULL},
	 { (char *)"SigmaPartialWave_setSubprocess", _wrap_SigmaPartialWave_setSubprocess, METH_VARARGS, NULL},
	 { (char *)"SigmaPartialWave_sigmaEl", _wrap_SigmaPartialWave_sigmaEl, METH_VARARGS, NULL},
	 { (char *)"SigmaPartialWave_sigmaTot", _wrap_SigmaPartialWave_sigmaTot, METH_VARARGS, NULL},
	 { (char *)"SigmaPartialWave_dSigma", _wrap_SigmaPartialWave_dSigma, METH_VARARGS, NULL},
	 { (char *)"SigmaPartialWave_pickCosTheta", _wrap_SigmaPartialWave_pickCosTheta, METH_VARARGS, NULL},
	 { (char *)"SigmaPartialWave_getSigmaElMax", _wrap_SigmaPartialWave_getSigmaElMax, METH_VARARGS, NULL},
	 { (char *)"new_SigmaPartialWave", _wrap_new_SigmaPartialWave, METH_VARARGS, NULL},
	 { (char *)"delete_SigmaPartialWave", _wrap_delete_SigmaPartialWave, METH_VARARGS, NULL},
	 { (char *)"SigmaPartialWave_swigregister", SigmaPartialWave_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HadronScatterPair", _wrap_new_HadronScatterPair, METH_VARARGS, NULL},
	 { (char *)"HadronScatterPair___lt__", _wrap_HadronScatterPair___lt__, METH_VARARGS, NULL},
	 { (char *)"HadronScatterPair_i1_set", _wrap_HadronScatterPair_i1_set, METH_VARARGS, NULL},
	 { (char *)"HadronScatterPair_i1_get", _wrap_HadronScatterPair_i1_get, METH_VARARGS, NULL},
	 { (char *)"HadronScatterPair_yt1_set", _wrap_HadronScatterPair_yt1_set, METH_VARARGS, NULL},
	 { (char *)"HadronScatterPair_yt1_get", _wrap_HadronScatterPair_yt1_get, METH_VARARGS, NULL},
	 { (char *)"HadronScatterPair_pt1_set", _wrap_HadronScatterPair_pt1_set, METH_VARARGS, NULL},
	 { (char *)"HadronScatterPair_pt1_get", _wrap_HadronScatterPair_pt1_get, METH_VARARGS, NULL},
	 { (char *)"HadronScatterPair_i2_set", _wrap_HadronScatterPair_i2_set, METH_VARARGS, NULL},
	 { (char *)"HadronScatterPair_i2_get", _wrap_HadronScatterPair_i2_get, METH_VARARGS, NULL},
	 { (char *)"HadronScatterPair_yt2_set", _wrap_HadronScatterPair_yt2_set, METH_VARARGS, NULL},
	 { (char *)"HadronScatterPair_yt2_get", _wrap_HadronScatterPair_yt2_get, METH_VARARGS, NULL},
	 { (char *)"HadronScatterPair_pt2_set", _wrap_HadronScatterPair_pt2_set, METH_VARARGS, NULL},
	 { (char *)"HadronScatterPair_pt2_get", _wrap_HadronScatterPair_pt2_get, METH_VARARGS, NULL},
	 { (char *)"HadronScatterPair_measure_set", _wrap_HadronScatterPair_measure_set, METH_VARARGS, NULL},
	 { (char *)"HadronScatterPair_measure_get", _wrap_HadronScatterPair_measure_get, METH_VARARGS, NULL},
	 { (char *)"delete_HadronScatterPair", _wrap_delete_HadronScatterPair, METH_VARARGS, NULL},
	 { (char *)"HadronScatterPair_swigregister", HadronScatterPair_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HadronScatter", _wrap_new_HadronScatter, METH_VARARGS, NULL},
	 { (char *)"HadronScatter_init", _wrap_HadronScatter_init, METH_VARARGS, NULL},
	 { (char *)"HadronScatter_scatter", _wrap_HadronScatter_scatter, METH_VARARGS, NULL},
	 { (char *)"HadronScatter_scatterOld", _wrap_HadronScatter_scatterOld, METH_VARARGS, NULL},
	 { (char *)"delete_HadronScatter", _wrap_delete_HadronScatter, METH_VARARGS, NULL},
	 { (char *)"HadronScatter_swigregister", HadronScatter_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Wave4", _wrap_new_Wave4, METH_VARARGS, NULL},
	 { (char *)"delete_Wave4", _wrap_delete_Wave4, METH_VARARGS, NULL},
	 { (char *)"Wave4___call__", _wrap_Wave4___call__, METH_VARARGS, NULL},
	 { (char *)"Wave4___add__", _wrap_Wave4___add__, METH_VARARGS, NULL},
	 { (char *)"Wave4___sub__", _wrap_Wave4___sub__, METH_VARARGS, NULL},
	 { (char *)"Wave4___neg__", _wrap_Wave4___neg__, METH_VARARGS, NULL},
	 { (char *)"Wave4___div__", _wrap_Wave4___div__, METH_VARARGS, NULL},
	 { (char *)"Wave4___str__", _wrap_Wave4___str__, METH_VARARGS, NULL},
	 { (char *)"Wave4___rmul__", _wrap_Wave4___rmul__, METH_VARARGS, NULL},
	 { (char *)"Wave4___mul__", _wrap_Wave4___mul__, METH_VARARGS, NULL},
	 { (char *)"Wave4_swigregister", Wave4_swigregister, METH_VARARGS, NULL},
	 { (char *)"conj", _wrap_conj, METH_VARARGS, NULL},
	 { (char *)"epsilon", _wrap_epsilon, METH_VARARGS, NULL},
	 { (char *)"m2", _wrap_m2, METH_VARARGS, NULL},
	 { (char *)"new_GammaMatrix", _wrap_new_GammaMatrix, METH_VARARGS, NULL},
	 { (char *)"delete_GammaMatrix", _wrap_delete_GammaMatrix, METH_VARARGS, NULL},
	 { (char *)"GammaMatrix___call__", _wrap_GammaMatrix___call__, METH_VARARGS, NULL},
	 { (char *)"GammaMatrix___mul__", _wrap_GammaMatrix___mul__, METH_VARARGS, NULL},
	 { (char *)"GammaMatrix___sub__", _wrap_GammaMatrix___sub__, METH_VARARGS, NULL},
	 { (char *)"GammaMatrix___add__", _wrap_GammaMatrix___add__, METH_VARARGS, NULL},
	 { (char *)"GammaMatrix___str__", _wrap_GammaMatrix___str__, METH_VARARGS, NULL},
	 { (char *)"GammaMatrix___rmul__", _wrap_GammaMatrix___rmul__, METH_VARARGS, NULL},
	 { (char *)"GammaMatrix___rsub__", _wrap_GammaMatrix___rsub__, METH_VARARGS, NULL},
	 { (char *)"GammaMatrix___radd__", _wrap_GammaMatrix___radd__, METH_VARARGS, NULL},
	 { (char *)"GammaMatrix_swigregister", GammaMatrix_swigregister, METH_VARARGS, NULL},
	 { (char *)"__mul__", _wrap___mul__, METH_VARARGS, NULL},
	 { (char *)"__sub__", _wrap___sub__, METH_VARARGS, NULL},
	 { (char *)"__add__", _wrap___add__, METH_VARARGS, NULL},
	 { (char *)"__lshift__", _wrap___lshift__, METH_VARARGS, NULL},
	 { (char *)"new_HelicityParticle", _wrap_new_HelicityParticle, METH_VARARGS, NULL},
	 { (char *)"HelicityParticle_wave", _wrap_HelicityParticle_wave, METH_VARARGS, NULL},
	 { (char *)"HelicityParticle_waveBar", _wrap_HelicityParticle_waveBar, METH_VARARGS, NULL},
	 { (char *)"HelicityParticle_normalize", _wrap_HelicityParticle_normalize, METH_VARARGS, NULL},
	 { (char *)"HelicityParticle_spinStates", _wrap_HelicityParticle_spinStates, METH_VARARGS, NULL},
	 { (char *)"HelicityParticle_m", _wrap_HelicityParticle_m, METH_VARARGS, NULL},
	 { (char *)"HelicityParticle_index", _wrap_HelicityParticle_index, METH_VARARGS, NULL},
	 { (char *)"HelicityParticle_direction_set", _wrap_HelicityParticle_direction_set, METH_VARARGS, NULL},
	 { (char *)"HelicityParticle_direction_get", _wrap_HelicityParticle_direction_get, METH_VARARGS, NULL},
	 { (char *)"HelicityParticle_rho_set", _wrap_HelicityParticle_rho_set, METH_VARARGS, NULL},
	 { (char *)"HelicityParticle_rho_get", _wrap_HelicityParticle_rho_get, METH_VARARGS, NULL},
	 { (char *)"HelicityParticle_D_set", _wrap_HelicityParticle_D_set, METH_VARARGS, NULL},
	 { (char *)"HelicityParticle_D_get", _wrap_HelicityParticle_D_get, METH_VARARGS, NULL},
	 { (char *)"delete_HelicityParticle", _wrap_delete_HelicityParticle, METH_VARARGS, NULL},
	 { (char *)"HelicityParticle_swigregister", HelicityParticle_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HelicityMatrixElement", _wrap_new_HelicityMatrixElement, METH_VARARGS, NULL},
	 { (char *)"delete_HelicityMatrixElement", _wrap_delete_HelicityMatrixElement, METH_VARARGS, NULL},
	 { (char *)"HelicityMatrixElement_initPointers", _wrap_HelicityMatrixElement_initPointers, METH_VARARGS, NULL},
	 { (char *)"HelicityMatrixElement_initChannel", _wrap_HelicityMatrixElement_initChannel, METH_VARARGS, NULL},
	 { (char *)"HelicityMatrixElement_decayWeight", _wrap_HelicityMatrixElement_decayWeight, METH_VARARGS, NULL},
	 { (char *)"HelicityMatrixElement_decayWeightMax", _wrap_HelicityMatrixElement_decayWeightMax, METH_VARARGS, NULL},
	 { (char *)"HelicityMatrixElement_calculateME", _wrap_HelicityMatrixElement_calculateME, METH_VARARGS, NULL},
	 { (char *)"HelicityMatrixElement_calculateD", _wrap_HelicityMatrixElement_calculateD, METH_VARARGS, NULL},
	 { (char *)"HelicityMatrixElement_calculateRho", _wrap_HelicityMatrixElement_calculateRho, METH_VARARGS, NULL},
	 { (char *)"HelicityMatrixElement_setFermionLine", _wrap_HelicityMatrixElement_setFermionLine, METH_VARARGS, NULL},
	 { (char *)"HelicityMatrixElement_breitWigner", _wrap_HelicityMatrixElement_breitWigner, METH_VARARGS, NULL},
	 { (char *)"HelicityMatrixElement_sBreitWigner", _wrap_HelicityMatrixElement_sBreitWigner, METH_VARARGS, NULL},
	 { (char *)"HelicityMatrixElement_pBreitWigner", _wrap_HelicityMatrixElement_pBreitWigner, METH_VARARGS, NULL},
	 { (char *)"HelicityMatrixElement_dBreitWigner", _wrap_HelicityMatrixElement_dBreitWigner, METH_VARARGS, NULL},
	 { (char *)"HelicityMatrixElement_swigregister", HelicityMatrixElement_swigregister, METH_VARARGS, NULL},
	 { (char *)"HMETwoFermions2W2TwoFermions_initConstants", _wrap_HMETwoFermions2W2TwoFermions_initConstants, METH_VARARGS, NULL},
	 { (char *)"HMETwoFermions2W2TwoFermions_initWaves", _wrap_HMETwoFermions2W2TwoFermions_initWaves, METH_VARARGS, NULL},
	 { (char *)"HMETwoFermions2W2TwoFermions_calculateME", _wrap_HMETwoFermions2W2TwoFermions_calculateME, METH_VARARGS, NULL},
	 { (char *)"new_HMETwoFermions2W2TwoFermions", _wrap_new_HMETwoFermions2W2TwoFermions, METH_VARARGS, NULL},
	 { (char *)"delete_HMETwoFermions2W2TwoFermions", _wrap_delete_HMETwoFermions2W2TwoFermions, METH_VARARGS, NULL},
	 { (char *)"HMETwoFermions2W2TwoFermions_swigregister", HMETwoFermions2W2TwoFermions_swigregister, METH_VARARGS, NULL},
	 { (char *)"HMETwoFermions2GammaZ2TwoFermions_initConstants", _wrap_HMETwoFermions2GammaZ2TwoFermions_initConstants, METH_VARARGS, NULL},
	 { (char *)"HMETwoFermions2GammaZ2TwoFermions_initWaves", _wrap_HMETwoFermions2GammaZ2TwoFermions_initWaves, METH_VARARGS, NULL},
	 { (char *)"HMETwoFermions2GammaZ2TwoFermions_calculateME", _wrap_HMETwoFermions2GammaZ2TwoFermions_calculateME, METH_VARARGS, NULL},
	 { (char *)"new_HMETwoFermions2GammaZ2TwoFermions", _wrap_new_HMETwoFermions2GammaZ2TwoFermions, METH_VARARGS, NULL},
	 { (char *)"delete_HMETwoFermions2GammaZ2TwoFermions", _wrap_delete_HMETwoFermions2GammaZ2TwoFermions, METH_VARARGS, NULL},
	 { (char *)"HMETwoFermions2GammaZ2TwoFermions_swigregister", HMETwoFermions2GammaZ2TwoFermions_swigregister, METH_VARARGS, NULL},
	 { (char *)"HMEX2TwoFermions_initWaves", _wrap_HMEX2TwoFermions_initWaves, METH_VARARGS, NULL},
	 { (char *)"new_HMEX2TwoFermions", _wrap_new_HMEX2TwoFermions, METH_VARARGS, NULL},
	 { (char *)"delete_HMEX2TwoFermions", _wrap_delete_HMEX2TwoFermions, METH_VARARGS, NULL},
	 { (char *)"HMEX2TwoFermions_swigregister", HMEX2TwoFermions_swigregister, METH_VARARGS, NULL},
	 { (char *)"HMEW2TwoFermions_initConstants", _wrap_HMEW2TwoFermions_initConstants, METH_VARARGS, NULL},
	 { (char *)"HMEW2TwoFermions_calculateME", _wrap_HMEW2TwoFermions_calculateME, METH_VARARGS, NULL},
	 { (char *)"new_HMEW2TwoFermions", _wrap_new_HMEW2TwoFermions, METH_VARARGS, NULL},
	 { (char *)"delete_HMEW2TwoFermions", _wrap_delete_HMEW2TwoFermions, METH_VARARGS, NULL},
	 { (char *)"HMEW2TwoFermions_swigregister", HMEW2TwoFermions_swigregister, METH_VARARGS, NULL},
	 { (char *)"HMEGamma2TwoFermions_calculateME", _wrap_HMEGamma2TwoFermions_calculateME, METH_VARARGS, NULL},
	 { (char *)"new_HMEGamma2TwoFermions", _wrap_new_HMEGamma2TwoFermions, METH_VARARGS, NULL},
	 { (char *)"delete_HMEGamma2TwoFermions", _wrap_delete_HMEGamma2TwoFermions, METH_VARARGS, NULL},
	 { (char *)"HMEGamma2TwoFermions_swigregister", HMEGamma2TwoFermions_swigregister, METH_VARARGS, NULL},
	 { (char *)"HMEZ2TwoFermions_initConstants", _wrap_HMEZ2TwoFermions_initConstants, METH_VARARGS, NULL},
	 { (char *)"HMEZ2TwoFermions_calculateME", _wrap_HMEZ2TwoFermions_calculateME, METH_VARARGS, NULL},
	 { (char *)"new_HMEZ2TwoFermions", _wrap_new_HMEZ2TwoFermions, METH_VARARGS, NULL},
	 { (char *)"delete_HMEZ2TwoFermions", _wrap_delete_HMEZ2TwoFermions, METH_VARARGS, NULL},
	 { (char *)"HMEZ2TwoFermions_swigregister", HMEZ2TwoFermions_swigregister, METH_VARARGS, NULL},
	 { (char *)"HMEHiggs2TwoFermions_initConstants", _wrap_HMEHiggs2TwoFermions_initConstants, METH_VARARGS, NULL},
	 { (char *)"HMEHiggs2TwoFermions_initWaves", _wrap_HMEHiggs2TwoFermions_initWaves, METH_VARARGS, NULL},
	 { (char *)"HMEHiggs2TwoFermions_calculateME", _wrap_HMEHiggs2TwoFermions_calculateME, METH_VARARGS, NULL},
	 { (char *)"new_HMEHiggs2TwoFermions", _wrap_new_HMEHiggs2TwoFermions, METH_VARARGS, NULL},
	 { (char *)"delete_HMEHiggs2TwoFermions", _wrap_delete_HMEHiggs2TwoFermions, METH_VARARGS, NULL},
	 { (char *)"HMEHiggs2TwoFermions_swigregister", HMEHiggs2TwoFermions_swigregister, METH_VARARGS, NULL},
	 { (char *)"HMETauDecay_initWaves", _wrap_HMETauDecay_initWaves, METH_VARARGS, NULL},
	 { (char *)"HMETauDecay_calculateME", _wrap_HMETauDecay_calculateME, METH_VARARGS, NULL},
	 { (char *)"HMETauDecay_decayWeightMax", _wrap_HMETauDecay_decayWeightMax, METH_VARARGS, NULL},
	 { (char *)"new_HMETauDecay", _wrap_new_HMETauDecay, METH_VARARGS, NULL},
	 { (char *)"delete_HMETauDecay", _wrap_delete_HMETauDecay, METH_VARARGS, NULL},
	 { (char *)"HMETauDecay_swigregister", HMETauDecay_swigregister, METH_VARARGS, NULL},
	 { (char *)"HMETau2Meson_initConstants", _wrap_HMETau2Meson_initConstants, METH_VARARGS, NULL},
	 { (char *)"HMETau2Meson_initHadronicCurrent", _wrap_HMETau2Meson_initHadronicCurrent, METH_VARARGS, NULL},
	 { (char *)"new_HMETau2Meson", _wrap_new_HMETau2Meson, METH_VARARGS, NULL},
	 { (char *)"delete_HMETau2Meson", _wrap_delete_HMETau2Meson, METH_VARARGS, NULL},
	 { (char *)"HMETau2Meson_swigregister", HMETau2Meson_swigregister, METH_VARARGS, NULL},
	 { (char *)"HMETau2TwoLeptons_initConstants", _wrap_HMETau2TwoLeptons_initConstants, METH_VARARGS, NULL},
	 { (char *)"HMETau2TwoLeptons_initWaves", _wrap_HMETau2TwoLeptons_initWaves, METH_VARARGS, NULL},
	 { (char *)"HMETau2TwoLeptons_calculateME", _wrap_HMETau2TwoLeptons_calculateME, METH_VARARGS, NULL},
	 { (char *)"new_HMETau2TwoLeptons", _wrap_new_HMETau2TwoLeptons, METH_VARARGS, NULL},
	 { (char *)"delete_HMETau2TwoLeptons", _wrap_delete_HMETau2TwoLeptons, METH_VARARGS, NULL},
	 { (char *)"HMETau2TwoLeptons_swigregister", HMETau2TwoLeptons_swigregister, METH_VARARGS, NULL},
	 { (char *)"HMETau2TwoMesonsViaVector_initConstants", _wrap_HMETau2TwoMesonsViaVector_initConstants, METH_VARARGS, NULL},
	 { (char *)"HMETau2TwoMesonsViaVector_initHadronicCurrent", _wrap_HMETau2TwoMesonsViaVector_initHadronicCurrent, METH_VARARGS, NULL},
	 { (char *)"new_HMETau2TwoMesonsViaVector", _wrap_new_HMETau2TwoMesonsViaVector, METH_VARARGS, NULL},
	 { (char *)"delete_HMETau2TwoMesonsViaVector", _wrap_delete_HMETau2TwoMesonsViaVector, METH_VARARGS, NULL},
	 { (char *)"HMETau2TwoMesonsViaVector_swigregister", HMETau2TwoMesonsViaVector_swigregister, METH_VARARGS, NULL},
	 { (char *)"HMETau2TwoMesonsViaVectorScalar_initConstants", _wrap_HMETau2TwoMesonsViaVectorScalar_initConstants, METH_VARARGS, NULL},
	 { (char *)"HMETau2TwoMesonsViaVectorScalar_initHadronicCurrent", _wrap_HMETau2TwoMesonsViaVectorScalar_initHadronicCurrent, METH_VARARGS, NULL},
	 { (char *)"new_HMETau2TwoMesonsViaVectorScalar", _wrap_new_HMETau2TwoMesonsViaVectorScalar, METH_VARARGS, NULL},
	 { (char *)"delete_HMETau2TwoMesonsViaVectorScalar", _wrap_delete_HMETau2TwoMesonsViaVectorScalar, METH_VARARGS, NULL},
	 { (char *)"HMETau2TwoMesonsViaVectorScalar_swigregister", HMETau2TwoMesonsViaVectorScalar_swigregister, METH_VARARGS, NULL},
	 { (char *)"HMETau2ThreeMesons_initConstants", _wrap_HMETau2ThreeMesons_initConstants, METH_VARARGS, NULL},
	 { (char *)"HMETau2ThreeMesons_initHadronicCurrent", _wrap_HMETau2ThreeMesons_initHadronicCurrent, METH_VARARGS, NULL},
	 { (char *)"new_HMETau2ThreeMesons", _wrap_new_HMETau2ThreeMesons, METH_VARARGS, NULL},
	 { (char *)"delete_HMETau2ThreeMesons", _wrap_delete_HMETau2ThreeMesons, METH_VARARGS, NULL},
	 { (char *)"HMETau2ThreeMesons_swigregister", HMETau2ThreeMesons_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HMETau2ThreePions", _wrap_new_HMETau2ThreePions, METH_VARARGS, NULL},
	 { (char *)"delete_HMETau2ThreePions", _wrap_delete_HMETau2ThreePions, METH_VARARGS, NULL},
	 { (char *)"HMETau2ThreePions_swigregister", HMETau2ThreePions_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HMETau2ThreeMesonsWithKaons", _wrap_new_HMETau2ThreeMesonsWithKaons, METH_VARARGS, NULL},
	 { (char *)"delete_HMETau2ThreeMesonsWithKaons", _wrap_delete_HMETau2ThreeMesonsWithKaons, METH_VARARGS, NULL},
	 { (char *)"HMETau2ThreeMesonsWithKaons_swigregister", HMETau2ThreeMesonsWithKaons_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HMETau2ThreeMesonsGeneric", _wrap_new_HMETau2ThreeMesonsGeneric, METH_VARARGS, NULL},
	 { (char *)"delete_HMETau2ThreeMesonsGeneric", _wrap_delete_HMETau2ThreeMesonsGeneric, METH_VARARGS, NULL},
	 { (char *)"HMETau2ThreeMesonsGeneric_swigregister", HMETau2ThreeMesonsGeneric_swigregister, METH_VARARGS, NULL},
	 { (char *)"HMETau2TwoPionsGamma_initConstants", _wrap_HMETau2TwoPionsGamma_initConstants, METH_VARARGS, NULL},
	 { (char *)"HMETau2TwoPionsGamma_initWaves", _wrap_HMETau2TwoPionsGamma_initWaves, METH_VARARGS, NULL},
	 { (char *)"HMETau2TwoPionsGamma_calculateME", _wrap_HMETau2TwoPionsGamma_calculateME, METH_VARARGS, NULL},
	 { (char *)"new_HMETau2TwoPionsGamma", _wrap_new_HMETau2TwoPionsGamma, METH_VARARGS, NULL},
	 { (char *)"delete_HMETau2TwoPionsGamma", _wrap_delete_HMETau2TwoPionsGamma, METH_VARARGS, NULL},
	 { (char *)"HMETau2TwoPionsGamma_swigregister", HMETau2TwoPionsGamma_swigregister, METH_VARARGS, NULL},
	 { (char *)"HMETau2FourPions_initConstants", _wrap_HMETau2FourPions_initConstants, METH_VARARGS, NULL},
	 { (char *)"HMETau2FourPions_initHadronicCurrent", _wrap_HMETau2FourPions_initHadronicCurrent, METH_VARARGS, NULL},
	 { (char *)"new_HMETau2FourPions", _wrap_new_HMETau2FourPions, METH_VARARGS, NULL},
	 { (char *)"delete_HMETau2FourPions", _wrap_delete_HMETau2FourPions, METH_VARARGS, NULL},
	 { (char *)"HMETau2FourPions_swigregister", HMETau2FourPions_swigregister, METH_VARARGS, NULL},
	 { (char *)"HMETau2FivePions_initConstants", _wrap_HMETau2FivePions_initConstants, METH_VARARGS, NULL},
	 { (char *)"HMETau2FivePions_initHadronicCurrent", _wrap_HMETau2FivePions_initHadronicCurrent, METH_VARARGS, NULL},
	 { (char *)"new_HMETau2FivePions", _wrap_new_HMETau2FivePions, METH_VARARGS, NULL},
	 { (char *)"delete_HMETau2FivePions", _wrap_delete_HMETau2FivePions, METH_VARARGS, NULL},
	 { (char *)"HMETau2FivePions_swigregister", HMETau2FivePions_swigregister, METH_VARARGS, NULL},
	 { (char *)"HMETau2PhaseSpace_initWaves", _wrap_HMETau2PhaseSpace_initWaves, METH_VARARGS, NULL},
	 { (char *)"HMETau2PhaseSpace_calculateME", _wrap_HMETau2PhaseSpace_calculateME, METH_VARARGS, NULL},
	 { (char *)"HMETau2PhaseSpace_calculateD", _wrap_HMETau2PhaseSpace_calculateD, METH_VARARGS, NULL},
	 { (char *)"HMETau2PhaseSpace_calculateRho", _wrap_HMETau2PhaseSpace_calculateRho, METH_VARARGS, NULL},
	 { (char *)"HMETau2PhaseSpace_decayWeight", _wrap_HMETau2PhaseSpace_decayWeight, METH_VARARGS, NULL},
	 { (char *)"HMETau2PhaseSpace_decayWeightMax", _wrap_HMETau2PhaseSpace_decayWeightMax, METH_VARARGS, NULL},
	 { (char *)"new_HMETau2PhaseSpace", _wrap_new_HMETau2PhaseSpace, METH_VARARGS, NULL},
	 { (char *)"delete_HMETau2PhaseSpace", _wrap_delete_HMETau2PhaseSpace, METH_VARARGS, NULL},
	 { (char *)"HMETau2PhaseSpace_swigregister", HMETau2PhaseSpace_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LHAProcess", _wrap_new_LHAProcess, METH_VARARGS, NULL},
	 { (char *)"LHAProcess_idProc_set", _wrap_LHAProcess_idProc_set, METH_VARARGS, NULL},
	 { (char *)"LHAProcess_idProc_get", _wrap_LHAProcess_idProc_get, METH_VARARGS, NULL},
	 { (char *)"LHAProcess_xSecProc_set", _wrap_LHAProcess_xSecProc_set, METH_VARARGS, NULL},
	 { (char *)"LHAProcess_xSecProc_get", _wrap_LHAProcess_xSecProc_get, METH_VARARGS, NULL},
	 { (char *)"LHAProcess_xErrProc_set", _wrap_LHAProcess_xErrProc_set, METH_VARARGS, NULL},
	 { (char *)"LHAProcess_xErrProc_get", _wrap_LHAProcess_xErrProc_get, METH_VARARGS, NULL},
	 { (char *)"LHAProcess_xMaxProc_set", _wrap_LHAProcess_xMaxProc_set, METH_VARARGS, NULL},
	 { (char *)"LHAProcess_xMaxProc_get", _wrap_LHAProcess_xMaxProc_get, METH_VARARGS, NULL},
	 { (char *)"delete_LHAProcess", _wrap_delete_LHAProcess, METH_VARARGS, NULL},
	 { (char *)"LHAProcess_swigregister", LHAProcess_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LHAParticle", _wrap_new_LHAParticle, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_idPart_set", _wrap_LHAParticle_idPart_set, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_idPart_get", _wrap_LHAParticle_idPart_get, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_statusPart_set", _wrap_LHAParticle_statusPart_set, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_statusPart_get", _wrap_LHAParticle_statusPart_get, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_mother1Part_set", _wrap_LHAParticle_mother1Part_set, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_mother1Part_get", _wrap_LHAParticle_mother1Part_get, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_mother2Part_set", _wrap_LHAParticle_mother2Part_set, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_mother2Part_get", _wrap_LHAParticle_mother2Part_get, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_col1Part_set", _wrap_LHAParticle_col1Part_set, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_col1Part_get", _wrap_LHAParticle_col1Part_get, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_col2Part_set", _wrap_LHAParticle_col2Part_set, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_col2Part_get", _wrap_LHAParticle_col2Part_get, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_pxPart_set", _wrap_LHAParticle_pxPart_set, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_pxPart_get", _wrap_LHAParticle_pxPart_get, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_pyPart_set", _wrap_LHAParticle_pyPart_set, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_pyPart_get", _wrap_LHAParticle_pyPart_get, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_pzPart_set", _wrap_LHAParticle_pzPart_set, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_pzPart_get", _wrap_LHAParticle_pzPart_get, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_ePart_set", _wrap_LHAParticle_ePart_set, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_ePart_get", _wrap_LHAParticle_ePart_get, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_mPart_set", _wrap_LHAParticle_mPart_set, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_mPart_get", _wrap_LHAParticle_mPart_get, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_tauPart_set", _wrap_LHAParticle_tauPart_set, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_tauPart_get", _wrap_LHAParticle_tauPart_get, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_spinPart_set", _wrap_LHAParticle_spinPart_set, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_spinPart_get", _wrap_LHAParticle_spinPart_get, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_scalePart_set", _wrap_LHAParticle_scalePart_set, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_scalePart_get", _wrap_LHAParticle_scalePart_get, METH_VARARGS, NULL},
	 { (char *)"delete_LHAParticle", _wrap_delete_LHAParticle, METH_VARARGS, NULL},
	 { (char *)"LHAParticle_swigregister", LHAParticle_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_LHAup", _wrap_delete_LHAup, METH_VARARGS, NULL},
	 { (char *)"LHAup_setPtr", _wrap_LHAup_setPtr, METH_VARARGS, NULL},
	 { (char *)"LHAup_newEventFile", _wrap_LHAup_newEventFile, METH_VARARGS, NULL},
	 { (char *)"LHAup_fileFound", _wrap_LHAup_fileFound, METH_VARARGS, NULL},
	 { (char *)"LHAup_useExternal", _wrap_LHAup_useExternal, METH_VARARGS, NULL},
	 { (char *)"LHAup_setInit", _wrap_LHAup_setInit, METH_VARARGS, NULL},
	 { (char *)"LHAup_idBeamA", _wrap_LHAup_idBeamA, METH_VARARGS, NULL},
	 { (char *)"LHAup_idBeamB", _wrap_LHAup_idBeamB, METH_VARARGS, NULL},
	 { (char *)"LHAup_eBeamA", _wrap_LHAup_eBeamA, METH_VARARGS, NULL},
	 { (char *)"LHAup_eBeamB", _wrap_LHAup_eBeamB, METH_VARARGS, NULL},
	 { (char *)"LHAup_pdfGroupBeamA", _wrap_LHAup_pdfGroupBeamA, METH_VARARGS, NULL},
	 { (char *)"LHAup_pdfGroupBeamB", _wrap_LHAup_pdfGroupBeamB, METH_VARARGS, NULL},
	 { (char *)"LHAup_pdfSetBeamA", _wrap_LHAup_pdfSetBeamA, METH_VARARGS, NULL},
	 { (char *)"LHAup_pdfSetBeamB", _wrap_LHAup_pdfSetBeamB, METH_VARARGS, NULL},
	 { (char *)"LHAup_strategy", _wrap_LHAup_strategy, METH_VARARGS, NULL},
	 { (char *)"LHAup_sizeProc", _wrap_LHAup_sizeProc, METH_VARARGS, NULL},
	 { (char *)"LHAup_xSec", _wrap_LHAup_xSec, METH_VARARGS, NULL},
	 { (char *)"LHAup_xErr", _wrap_LHAup_xErr, METH_VARARGS, NULL},
	 { (char *)"LHAup_xMax", _wrap_LHAup_xMax, METH_VARARGS, NULL},
	 { (char *)"LHAup_xSecSum", _wrap_LHAup_xSecSum, METH_VARARGS, NULL},
	 { (char *)"LHAup_xErrSum", _wrap_LHAup_xErrSum, METH_VARARGS, NULL},
	 { (char *)"LHAup_listInit", _wrap_LHAup_listInit, METH_VARARGS, NULL},
	 { (char *)"LHAup_setEvent", _wrap_LHAup_setEvent, METH_VARARGS, NULL},
	 { (char *)"LHAup_idProcess", _wrap_LHAup_idProcess, METH_VARARGS, NULL},
	 { (char *)"LHAup_weight", _wrap_LHAup_weight, METH_VARARGS, NULL},
	 { (char *)"LHAup_alphaQED", _wrap_LHAup_alphaQED, METH_VARARGS, NULL},
	 { (char *)"LHAup_alphaQCD", _wrap_LHAup_alphaQCD, METH_VARARGS, NULL},
	 { (char *)"LHAup_sizePart", _wrap_LHAup_sizePart, METH_VARARGS, NULL},
	 { (char *)"LHAup_id", _wrap_LHAup_id, METH_VARARGS, NULL},
	 { (char *)"LHAup_status", _wrap_LHAup_status, METH_VARARGS, NULL},
	 { (char *)"LHAup_mother1", _wrap_LHAup_mother1, METH_VARARGS, NULL},
	 { (char *)"LHAup_mother2", _wrap_LHAup_mother2, METH_VARARGS, NULL},
	 { (char *)"LHAup_col1", _wrap_LHAup_col1, METH_VARARGS, NULL},
	 { (char *)"LHAup_col2", _wrap_LHAup_col2, METH_VARARGS, NULL},
	 { (char *)"LHAup_px", _wrap_LHAup_px, METH_VARARGS, NULL},
	 { (char *)"LHAup_py", _wrap_LHAup_py, METH_VARARGS, NULL},
	 { (char *)"LHAup_pz", _wrap_LHAup_pz, METH_VARARGS, NULL},
	 { (char *)"LHAup_e", _wrap_LHAup_e, METH_VARARGS, NULL},
	 { (char *)"LHAup_m", _wrap_LHAup_m, METH_VARARGS, NULL},
	 { (char *)"LHAup_tau", _wrap_LHAup_tau, METH_VARARGS, NULL},
	 { (char *)"LHAup_spin", _wrap_LHAup_spin, METH_VARARGS, NULL},
	 { (char *)"LHAup_scale", _wrap_LHAup_scale, METH_VARARGS, NULL},
	 { (char *)"LHAup_id1", _wrap_LHAup_id1, METH_VARARGS, NULL},
	 { (char *)"LHAup_id2", _wrap_LHAup_id2, METH_VARARGS, NULL},
	 { (char *)"LHAup_x1", _wrap_LHAup_x1, METH_VARARGS, NULL},
	 { (char *)"LHAup_x2", _wrap_LHAup_x2, METH_VARARGS, NULL},
	 { (char *)"LHAup_pdfIsSet", _wrap_LHAup_pdfIsSet, METH_VARARGS, NULL},
	 { (char *)"LHAup_id1pdf", _wrap_LHAup_id1pdf, METH_VARARGS, NULL},
	 { (char *)"LHAup_id2pdf", _wrap_LHAup_id2pdf, METH_VARARGS, NULL},
	 { (char *)"LHAup_x1pdf", _wrap_LHAup_x1pdf, METH_VARARGS, NULL},
	 { (char *)"LHAup_x2pdf", _wrap_LHAup_x2pdf, METH_VARARGS, NULL},
	 { (char *)"LHAup_scalePDF", _wrap_LHAup_scalePDF, METH_VARARGS, NULL},
	 { (char *)"LHAup_pdf1", _wrap_LHAup_pdf1, METH_VARARGS, NULL},
	 { (char *)"LHAup_pdf2", _wrap_LHAup_pdf2, METH_VARARGS, NULL},
	 { (char *)"LHAup_listEvent", _wrap_LHAup_listEvent, METH_VARARGS, NULL},
	 { (char *)"LHAup_skipEvent", _wrap_LHAup_skipEvent, METH_VARARGS, NULL},
	 { (char *)"LHAup_openLHEF", _wrap_LHAup_openLHEF, METH_VARARGS, NULL},
	 { (char *)"LHAup_closeLHEF", _wrap_LHAup_closeLHEF, METH_VARARGS, NULL},
	 { (char *)"LHAup_initLHEF", _wrap_LHAup_initLHEF, METH_VARARGS, NULL},
	 { (char *)"LHAup_eventLHEF", _wrap_LHAup_eventLHEF, METH_VARARGS, NULL},
	 { (char *)"LHAup_getFileName", _wrap_LHAup_getFileName, METH_VARARGS, NULL},
	 { (char *)"new_LHAup", _wrap_new_LHAup, METH_VARARGS, NULL},
	 { (char *)"LHAup_infoPtr_set", _wrap_LHAup_infoPtr_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_infoPtr_get", _wrap_LHAup_infoPtr_get, METH_VARARGS, NULL},
	 { (char *)"LHAup_setBeamA", _wrap_LHAup_setBeamA, METH_VARARGS, NULL},
	 { (char *)"LHAup_setBeamB", _wrap_LHAup_setBeamB, METH_VARARGS, NULL},
	 { (char *)"LHAup_setStrategy", _wrap_LHAup_setStrategy, METH_VARARGS, NULL},
	 { (char *)"LHAup_addProcess", _wrap_LHAup_addProcess, METH_VARARGS, NULL},
	 { (char *)"LHAup_setXSec", _wrap_LHAup_setXSec, METH_VARARGS, NULL},
	 { (char *)"LHAup_setXErr", _wrap_LHAup_setXErr, METH_VARARGS, NULL},
	 { (char *)"LHAup_setXMax", _wrap_LHAup_setXMax, METH_VARARGS, NULL},
	 { (char *)"LHAup_setProcess", _wrap_LHAup_setProcess, METH_VARARGS, NULL},
	 { (char *)"LHAup_addParticle", _wrap_LHAup_addParticle, METH_VARARGS, NULL},
	 { (char *)"LHAup_setIdX", _wrap_LHAup_setIdX, METH_VARARGS, NULL},
	 { (char *)"LHAup_setPdf", _wrap_LHAup_setPdf, METH_VARARGS, NULL},
	 { (char *)"LHAup_setInitLHEF", _wrap_LHAup_setInitLHEF, METH_VARARGS, NULL},
	 { (char *)"LHAup_setNewEventLHEF", _wrap_LHAup_setNewEventLHEF, METH_VARARGS, NULL},
	 { (char *)"LHAup_setOldEventLHEF", _wrap_LHAup_setOldEventLHEF, METH_VARARGS, NULL},
	 { (char *)"LHAup_openFile", _wrap_LHAup_openFile, METH_VARARGS, NULL},
	 { (char *)"LHAup_closeFile", _wrap_LHAup_closeFile, METH_VARARGS, NULL},
	 { (char *)"LHAup_setInfoHeader", _wrap_LHAup_setInfoHeader, METH_VARARGS, NULL},
	 { (char *)"LHAup_nupSave_set", _wrap_LHAup_nupSave_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_nupSave_get", _wrap_LHAup_nupSave_get, METH_VARARGS, NULL},
	 { (char *)"LHAup_idprupSave_set", _wrap_LHAup_idprupSave_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_idprupSave_get", _wrap_LHAup_idprupSave_get, METH_VARARGS, NULL},
	 { (char *)"LHAup_xwgtupSave_set", _wrap_LHAup_xwgtupSave_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_xwgtupSave_get", _wrap_LHAup_xwgtupSave_get, METH_VARARGS, NULL},
	 { (char *)"LHAup_scalupSave_set", _wrap_LHAup_scalupSave_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_scalupSave_get", _wrap_LHAup_scalupSave_get, METH_VARARGS, NULL},
	 { (char *)"LHAup_aqedupSave_set", _wrap_LHAup_aqedupSave_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_aqedupSave_get", _wrap_LHAup_aqedupSave_get, METH_VARARGS, NULL},
	 { (char *)"LHAup_aqcdupSave_set", _wrap_LHAup_aqcdupSave_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_aqcdupSave_get", _wrap_LHAup_aqcdupSave_get, METH_VARARGS, NULL},
	 { (char *)"LHAup_xSecSumSave_set", _wrap_LHAup_xSecSumSave_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_xSecSumSave_get", _wrap_LHAup_xSecSumSave_get, METH_VARARGS, NULL},
	 { (char *)"LHAup_xErrSumSave_set", _wrap_LHAup_xErrSumSave_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_xErrSumSave_get", _wrap_LHAup_xErrSumSave_get, METH_VARARGS, NULL},
	 { (char *)"LHAup_particlesSave_set", _wrap_LHAup_particlesSave_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_particlesSave_get", _wrap_LHAup_particlesSave_get, METH_VARARGS, NULL},
	 { (char *)"LHAup_getPDFSave_set", _wrap_LHAup_getPDFSave_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_getPDFSave_get", _wrap_LHAup_getPDFSave_get, METH_VARARGS, NULL},
	 { (char *)"LHAup_getScale_set", _wrap_LHAup_getScale_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_getScale_get", _wrap_LHAup_getScale_get, METH_VARARGS, NULL},
	 { (char *)"LHAup_id1InSave_set", _wrap_LHAup_id1InSave_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_id1InSave_get", _wrap_LHAup_id1InSave_get, METH_VARARGS, NULL},
	 { (char *)"LHAup_id2InSave_set", _wrap_LHAup_id2InSave_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_id2InSave_get", _wrap_LHAup_id2InSave_get, METH_VARARGS, NULL},
	 { (char *)"LHAup_id1pdfInSave_set", _wrap_LHAup_id1pdfInSave_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_id1pdfInSave_get", _wrap_LHAup_id1pdfInSave_get, METH_VARARGS, NULL},
	 { (char *)"LHAup_id2pdfInSave_set", _wrap_LHAup_id2pdfInSave_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_id2pdfInSave_get", _wrap_LHAup_id2pdfInSave_get, METH_VARARGS, NULL},
	 { (char *)"LHAup_x1InSave_set", _wrap_LHAup_x1InSave_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_x1InSave_get", _wrap_LHAup_x1InSave_get, METH_VARARGS, NULL},
	 { (char *)"LHAup_x2InSave_set", _wrap_LHAup_x2InSave_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_x2InSave_get", _wrap_LHAup_x2InSave_get, METH_VARARGS, NULL},
	 { (char *)"LHAup_x1pdfInSave_set", _wrap_LHAup_x1pdfInSave_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_x1pdfInSave_get", _wrap_LHAup_x1pdfInSave_get, METH_VARARGS, NULL},
	 { (char *)"LHAup_x2pdfInSave_set", _wrap_LHAup_x2pdfInSave_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_x2pdfInSave_get", _wrap_LHAup_x2pdfInSave_get, METH_VARARGS, NULL},
	 { (char *)"LHAup_scalePDFInSave_set", _wrap_LHAup_scalePDFInSave_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_scalePDFInSave_get", _wrap_LHAup_scalePDFInSave_get, METH_VARARGS, NULL},
	 { (char *)"LHAup_pdf1InSave_set", _wrap_LHAup_pdf1InSave_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_pdf1InSave_get", _wrap_LHAup_pdf1InSave_get, METH_VARARGS, NULL},
	 { (char *)"LHAup_pdf2InSave_set", _wrap_LHAup_pdf2InSave_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_pdf2InSave_get", _wrap_LHAup_pdf2InSave_get, METH_VARARGS, NULL},
	 { (char *)"LHAup_fileName_set", _wrap_LHAup_fileName_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_fileName_get", _wrap_LHAup_fileName_get, METH_VARARGS, NULL},
	 { (char *)"LHAup_dateNow_set", _wrap_LHAup_dateNow_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_dateNow_get", _wrap_LHAup_dateNow_get, METH_VARARGS, NULL},
	 { (char *)"LHAup_timeNow_set", _wrap_LHAup_timeNow_set, METH_VARARGS, NULL},
	 { (char *)"LHAup_timeNow_get", _wrap_LHAup_timeNow_get, METH_VARARGS, NULL},
	 { (char *)"disown_LHAup", _wrap_disown_LHAup, METH_VARARGS, NULL},
	 { (char *)"LHAup_swigregister", LHAup_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LHAupLHEF", _wrap_new_LHAupLHEF, METH_VARARGS, NULL},
	 { (char *)"delete_LHAupLHEF", _wrap_delete_LHAupLHEF, METH_VARARGS, NULL},
	 { (char *)"LHAupLHEF_closeAllFiles", _wrap_LHAupLHEF_closeAllFiles, METH_VARARGS, NULL},
	 { (char *)"LHAupLHEF_newEventFile", _wrap_LHAupLHEF_newEventFile, METH_VARARGS, NULL},
	 { (char *)"LHAupLHEF_fileFound", _wrap_LHAupLHEF_fileFound, METH_VARARGS, NULL},
	 { (char *)"LHAupLHEF_useExternal", _wrap_LHAupLHEF_useExternal, METH_VARARGS, NULL},
	 { (char *)"LHAupLHEF_setInit", _wrap_LHAupLHEF_setInit, METH_VARARGS, NULL},
	 { (char *)"LHAupLHEF_setInitLHEF", _wrap_LHAupLHEF_setInitLHEF, METH_VARARGS, NULL},
	 { (char *)"LHAupLHEF_setEvent", _wrap_LHAupLHEF_setEvent, METH_VARARGS, NULL},
	 { (char *)"LHAupLHEF_skipEvent", _wrap_LHAupLHEF_skipEvent, METH_VARARGS, NULL},
	 { (char *)"LHAupLHEF_setNewEventLHEF", _wrap_LHAupLHEF_setNewEventLHEF, METH_VARARGS, NULL},
	 { (char *)"LHAupLHEF_updateSigma", _wrap_LHAupLHEF_updateSigma, METH_VARARGS, NULL},
	 { (char *)"LHAupLHEF_swigregister", LHAupLHEF_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LHAupFromPYTHIA8", _wrap_new_LHAupFromPYTHIA8, METH_VARARGS, NULL},
	 { (char *)"delete_LHAupFromPYTHIA8", _wrap_delete_LHAupFromPYTHIA8, METH_VARARGS, NULL},
	 { (char *)"LHAupFromPYTHIA8_setInit", _wrap_LHAupFromPYTHIA8_setInit, METH_VARARGS, NULL},
	 { (char *)"LHAupFromPYTHIA8_setEvent", _wrap_LHAupFromPYTHIA8_setEvent, METH_VARARGS, NULL},
	 { (char *)"LHAupFromPYTHIA8_updateSigma", _wrap_LHAupFromPYTHIA8_updateSigma, METH_VARARGS, NULL},
	 { (char *)"LHAupFromPYTHIA8_swigregister", LHAupFromPYTHIA8_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LHEF3FromPythia8", _wrap_new_LHEF3FromPythia8, METH_VARARGS, NULL},
	 { (char *)"LHEF3FromPythia8_setInit", _wrap_LHEF3FromPythia8_setInit, METH_VARARGS, NULL},
	 { (char *)"LHEF3FromPythia8_setEventPtr", _wrap_LHEF3FromPythia8_setEventPtr, METH_VARARGS, NULL},
	 { (char *)"LHEF3FromPythia8_setEvent", _wrap_LHEF3FromPythia8_setEvent, METH_VARARGS, NULL},
	 { (char *)"LHEF3FromPythia8_getEventString", _wrap_LHEF3FromPythia8_getEventString, METH_VARARGS, NULL},
	 { (char *)"LHEF3FromPythia8_openLHEF", _wrap_LHEF3FromPythia8_openLHEF, METH_VARARGS, NULL},
	 { (char *)"LHEF3FromPythia8_closeLHEF", _wrap_LHEF3FromPythia8_closeLHEF, METH_VARARGS, NULL},
	 { (char *)"delete_LHEF3FromPythia8", _wrap_delete_LHEF3FromPythia8, METH_VARARGS, NULL},
	 { (char *)"LHEF3FromPythia8_swigregister", LHEF3FromPythia8_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MiniStringFragmentation", _wrap_new_MiniStringFragmentation, METH_VARARGS, NULL},
	 { (char *)"MiniStringFragmentation_init", _wrap_MiniStringFragmentation_init, METH_VARARGS, NULL},
	 { (char *)"MiniStringFragmentation_fragment", _wrap_MiniStringFragmentation_fragment, METH_VARARGS, NULL},
	 { (char *)"delete_MiniStringFragmentation", _wrap_delete_MiniStringFragmentation, METH_VARARGS, NULL},
	 { (char *)"MiniStringFragmentation_swigregister", MiniStringFragmentation_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PartonVertex", _wrap_new_PartonVertex, METH_VARARGS, NULL},
	 { (char *)"delete_PartonVertex", _wrap_delete_PartonVertex, METH_VARARGS, NULL},
	 { (char *)"PartonVertex_initPtr", _wrap_PartonVertex_initPtr, METH_VARARGS, NULL},
	 { (char *)"PartonVertex_init", _wrap_PartonVertex_init, METH_VARARGS, NULL},
	 { (char *)"PartonVertex_vertexBeam", _wrap_PartonVertex_vertexBeam, METH_VARARGS, NULL},
	 { (char *)"PartonVertex_vertexMPI", _wrap_PartonVertex_vertexMPI, METH_VARARGS, NULL},
	 { (char *)"PartonVertex_vertexFSR", _wrap_PartonVertex_vertexFSR, METH_VARARGS, NULL},
	 { (char *)"PartonVertex_vertexISR", _wrap_PartonVertex_vertexISR, METH_VARARGS, NULL},
	 { (char *)"PartonVertex_swigregister", PartonVertex_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceDecays", _wrap_new_ResonanceDecays, METH_VARARGS, NULL},
	 { (char *)"ResonanceDecays_init", _wrap_ResonanceDecays_init, METH_VARARGS, NULL},
	 { (char *)"ResonanceDecays_next", _wrap_ResonanceDecays_next, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceDecays", _wrap_delete_ResonanceDecays, METH_VARARGS, NULL},
	 { (char *)"ResonanceDecays_swigregister", ResonanceDecays_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceS", _wrap_new_ResonanceS, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceS", _wrap_delete_ResonanceS, METH_VARARGS, NULL},
	 { (char *)"ResonanceS_swigregister", ResonanceS_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceZp", _wrap_new_ResonanceZp, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceZp", _wrap_delete_ResonanceZp, METH_VARARGS, NULL},
	 { (char *)"ResonanceZp_swigregister", ResonanceZp_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RHadrons", _wrap_new_RHadrons, METH_VARARGS, NULL},
	 { (char *)"RHadrons_init", _wrap_RHadrons_init, METH_VARARGS, NULL},
	 { (char *)"RHadrons_fragPtrs", _wrap_RHadrons_fragPtrs, METH_VARARGS, NULL},
	 { (char *)"RHadrons_produce", _wrap_RHadrons_produce, METH_VARARGS, NULL},
	 { (char *)"RHadrons_decay", _wrap_RHadrons_decay, METH_VARARGS, NULL},
	 { (char *)"RHadrons_givesRHadron", _wrap_RHadrons_givesRHadron, METH_VARARGS, NULL},
	 { (char *)"RHadrons_exist", _wrap_RHadrons_exist, METH_VARARGS, NULL},
	 { (char *)"RHadrons_trace", _wrap_RHadrons_trace, METH_VARARGS, NULL},
	 { (char *)"delete_RHadrons", _wrap_delete_RHadrons, METH_VARARGS, NULL},
	 { (char *)"RHadrons_swigregister", RHadrons_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RopeDipoleEnd", _wrap_new_RopeDipoleEnd, METH_VARARGS, NULL},
	 { (char *)"RopeDipoleEnd_getParticlePtr", _wrap_RopeDipoleEnd_getParticlePtr, METH_VARARGS, NULL},
	 { (char *)"RopeDipoleEnd_getNe", _wrap_RopeDipoleEnd_getNe, METH_VARARGS, NULL},
	 { (char *)"RopeDipoleEnd_labrap", _wrap_RopeDipoleEnd_labrap, METH_VARARGS, NULL},
	 { (char *)"RopeDipoleEnd_rap", _wrap_RopeDipoleEnd_rap, METH_VARARGS, NULL},
	 { (char *)"delete_RopeDipoleEnd", _wrap_delete_RopeDipoleEnd, METH_VARARGS, NULL},
	 { (char *)"RopeDipoleEnd_swigregister", RopeDipoleEnd_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_OverlappingRopeDipole", _wrap_new_OverlappingRopeDipole, METH_VARARGS, NULL},
	 { (char *)"OverlappingRopeDipole_overlap", _wrap_OverlappingRopeDipole_overlap, METH_VARARGS, NULL},
	 { (char *)"OverlappingRopeDipole_hadronized", _wrap_OverlappingRopeDipole_hadronized, METH_VARARGS, NULL},
	 { (char *)"OverlappingRopeDipole_dir_set", _wrap_OverlappingRopeDipole_dir_set, METH_VARARGS, NULL},
	 { (char *)"OverlappingRopeDipole_dir_get", _wrap_OverlappingRopeDipole_dir_get, METH_VARARGS, NULL},
	 { (char *)"OverlappingRopeDipole_y1_set", _wrap_OverlappingRopeDipole_y1_set, METH_VARARGS, NULL},
	 { (char *)"OverlappingRopeDipole_y1_get", _wrap_OverlappingRopeDipole_y1_get, METH_VARARGS, NULL},
	 { (char *)"OverlappingRopeDipole_y2_set", _wrap_OverlappingRopeDipole_y2_set, METH_VARARGS, NULL},
	 { (char *)"OverlappingRopeDipole_y2_get", _wrap_OverlappingRopeDipole_y2_get, METH_VARARGS, NULL},
	 { (char *)"OverlappingRopeDipole_b1_set", _wrap_OverlappingRopeDipole_b1_set, METH_VARARGS, NULL},
	 { (char *)"OverlappingRopeDipole_b1_get", _wrap_OverlappingRopeDipole_b1_get, METH_VARARGS, NULL},
	 { (char *)"OverlappingRopeDipole_b2_set", _wrap_OverlappingRopeDipole_b2_set, METH_VARARGS, NULL},
	 { (char *)"OverlappingRopeDipole_b2_get", _wrap_OverlappingRopeDipole_b2_get, METH_VARARGS, NULL},
	 { (char *)"delete_OverlappingRopeDipole", _wrap_delete_OverlappingRopeDipole, METH_VARARGS, NULL},
	 { (char *)"OverlappingRopeDipole_swigregister", OverlappingRopeDipole_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RopeDipole", _wrap_new_RopeDipole, METH_VARARGS, NULL},
	 { (char *)"RopeDipole_addExcitation", _wrap_RopeDipole_addExcitation, METH_VARARGS, NULL},
	 { (char *)"RopeDipole_d1Ptr", _wrap_RopeDipole_d1Ptr, METH_VARARGS, NULL},
	 { (char *)"RopeDipole_d2Ptr", _wrap_RopeDipole_d2Ptr, METH_VARARGS, NULL},
	 { (char *)"RopeDipole_getDipoleRestFrame", _wrap_RopeDipole_getDipoleRestFrame, METH_VARARGS, NULL},
	 { (char *)"RopeDipole_getDipoleLabFrame", _wrap_RopeDipole_getDipoleLabFrame, METH_VARARGS, NULL},
	 { (char *)"RopeDipole_dipoleMomentum", _wrap_RopeDipole_dipoleMomentum, METH_VARARGS, NULL},
	 { (char *)"RopeDipole_bInterpolateDip", _wrap_RopeDipole_bInterpolateDip, METH_VARARGS, NULL},
	 { (char *)"RopeDipole_bInterpolateLab", _wrap_RopeDipole_bInterpolateLab, METH_VARARGS, NULL},
	 { (char *)"RopeDipole_bInterpolate", _wrap_RopeDipole_bInterpolate, METH_VARARGS, NULL},
	 { (char *)"RopeDipole_getOverlaps", _wrap_RopeDipole_getOverlaps, METH_VARARGS, NULL},
	 { (char *)"RopeDipole_addOverlappingDipole", _wrap_RopeDipole_addOverlappingDipole, METH_VARARGS, NULL},
	 { (char *)"RopeDipole_maxRapidity", _wrap_RopeDipole_maxRapidity, METH_VARARGS, NULL},
	 { (char *)"RopeDipole_minRapidity", _wrap_RopeDipole_minRapidity, METH_VARARGS, NULL},
	 { (char *)"RopeDipole_propagateInit", _wrap_RopeDipole_propagateInit, METH_VARARGS, NULL},
	 { (char *)"RopeDipole_propagate", _wrap_RopeDipole_propagate, METH_VARARGS, NULL},
	 { (char *)"RopeDipole_splitMomentum", _wrap_RopeDipole_splitMomentum, METH_VARARGS, NULL},
	 { (char *)"RopeDipole_excitationsToString", _wrap_RopeDipole_excitationsToString, METH_VARARGS, NULL},
	 { (char *)"RopeDipole_index", _wrap_RopeDipole_index, METH_VARARGS, NULL},
	 { (char *)"RopeDipole_recoil", _wrap_RopeDipole_recoil, METH_VARARGS, NULL},
	 { (char *)"RopeDipole_hadronized", _wrap_RopeDipole_hadronized, METH_VARARGS, NULL},
	 { (char *)"RopeDipole_nExcitations", _wrap_RopeDipole_nExcitations, METH_VARARGS, NULL},
	 { (char *)"delete_RopeDipole", _wrap_delete_RopeDipole, METH_VARARGS, NULL},
	 { (char *)"RopeDipole_swigregister", RopeDipole_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Ropewalk", _wrap_new_Ropewalk, METH_VARARGS, NULL},
	 { (char *)"Ropewalk_init", _wrap_Ropewalk_init, METH_VARARGS, NULL},
	 { (char *)"Ropewalk_extractDipoles", _wrap_Ropewalk_extractDipoles, METH_VARARGS, NULL},
	 { (char *)"Ropewalk_calculateOverlaps", _wrap_Ropewalk_calculateOverlaps, METH_VARARGS, NULL},
	 { (char *)"Ropewalk_getKappaHere", _wrap_Ropewalk_getKappaHere, METH_VARARGS, NULL},
	 { (char *)"Ropewalk_multiplicity", _wrap_Ropewalk_multiplicity, METH_VARARGS, NULL},
	 { (char *)"Ropewalk_averageKappa", _wrap_Ropewalk_averageKappa, METH_VARARGS, NULL},
	 { (char *)"Ropewalk_select", _wrap_Ropewalk_select, METH_VARARGS, NULL},
	 { (char *)"Ropewalk_shoveTheDipoles", _wrap_Ropewalk_shoveTheDipoles, METH_VARARGS, NULL},
	 { (char *)"delete_Ropewalk", _wrap_delete_Ropewalk, METH_VARARGS, NULL},
	 { (char *)"Ropewalk_swigregister", Ropewalk_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_RopeFragPars", _wrap_new_RopeFragPars, METH_VARARGS, NULL},
	 { (char *)"RopeFragPars_init", _wrap_RopeFragPars_init, METH_VARARGS, NULL},
	 { (char *)"RopeFragPars_getEffectiveParameters", _wrap_RopeFragPars_getEffectiveParameters, METH_VARARGS, NULL},
	 { (char *)"delete_RopeFragPars", _wrap_delete_RopeFragPars, METH_VARARGS, NULL},
	 { (char *)"RopeFragPars_swigregister", RopeFragPars_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_FlavourRope", _wrap_new_FlavourRope, METH_VARARGS, NULL},
	 { (char *)"FlavourRope_init", _wrap_FlavourRope_init, METH_VARARGS, NULL},
	 { (char *)"FlavourRope_doChangeFragPar", _wrap_FlavourRope_doChangeFragPar, METH_VARARGS, NULL},
	 { (char *)"FlavourRope_setEnhancement", _wrap_FlavourRope_setEnhancement, METH_VARARGS, NULL},
	 { (char *)"FlavourRope_setEventPtr", _wrap_FlavourRope_setEventPtr, METH_VARARGS, NULL},
	 { (char *)"delete_FlavourRope", _wrap_delete_FlavourRope, METH_VARARGS, NULL},
	 { (char *)"FlavourRope_swigregister", FlavourRope_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SUSYResonanceWidths", _wrap_new_SUSYResonanceWidths, METH_VARARGS, NULL},
	 { (char *)"delete_SUSYResonanceWidths", _wrap_delete_SUSYResonanceWidths, METH_VARARGS, NULL},
	 { (char *)"SUSYResonanceWidths_swigregister", SUSYResonanceWidths_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceSquark", _wrap_new_ResonanceSquark, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceSquark", _wrap_delete_ResonanceSquark, METH_VARARGS, NULL},
	 { (char *)"ResonanceSquark_swigregister", ResonanceSquark_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceGluino", _wrap_new_ResonanceGluino, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceGluino", _wrap_delete_ResonanceGluino, METH_VARARGS, NULL},
	 { (char *)"ResonanceGluino_swigregister", ResonanceGluino_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceNeut", _wrap_new_ResonanceNeut, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceNeut", _wrap_delete_ResonanceNeut, METH_VARARGS, NULL},
	 { (char *)"ResonanceNeut_swigregister", ResonanceNeut_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceChar", _wrap_new_ResonanceChar, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceChar", _wrap_delete_ResonanceChar, METH_VARARGS, NULL},
	 { (char *)"ResonanceChar_swigregister", ResonanceChar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResonanceSlepton", _wrap_new_ResonanceSlepton, METH_VARARGS, NULL},
	 { (char *)"delete_ResonanceSlepton", _wrap_delete_ResonanceSlepton, METH_VARARGS, NULL},
	 { (char *)"ResonanceSlepton_swigregister", ResonanceSlepton_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TauDecays", _wrap_new_TauDecays, METH_VARARGS, NULL},
	 { (char *)"delete_TauDecays", _wrap_delete_TauDecays, METH_VARARGS, NULL},
	 { (char *)"TauDecays_init", _wrap_TauDecays_init, METH_VARARGS, NULL},
	 { (char *)"TauDecays_decay", _wrap_TauDecays_decay, METH_VARARGS, NULL},
	 { (char *)"TauDecays_internalMechanism", _wrap_TauDecays_internalMechanism, METH_VARARGS, NULL},
	 { (char *)"TauDecays_externalMechanism", _wrap_TauDecays_externalMechanism, METH_VARARGS, NULL},
	 { (char *)"TauDecays_createChildren", _wrap_TauDecays_createChildren, METH_VARARGS, NULL},
	 { (char *)"TauDecays_isotropicDecay", _wrap_TauDecays_isotropicDecay, METH_VARARGS, NULL},
	 { (char *)"TauDecays_writeDecay", _wrap_TauDecays_writeDecay, METH_VARARGS, NULL},
	 { (char *)"TauDecays_swigregister", TauDecays_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sphericity", _wrap_new_Sphericity, METH_VARARGS, NULL},
	 { (char *)"Sphericity_analyze", _wrap_Sphericity_analyze, METH_VARARGS, NULL},
	 { (char *)"Sphericity_sphericity", _wrap_Sphericity_sphericity, METH_VARARGS, NULL},
	 { (char *)"Sphericity_aplanarity", _wrap_Sphericity_aplanarity, METH_VARARGS, NULL},
	 { (char *)"Sphericity_eigenValue", _wrap_Sphericity_eigenValue, METH_VARARGS, NULL},
	 { (char *)"Sphericity_eventAxis", _wrap_Sphericity_eventAxis, METH_VARARGS, NULL},
	 { (char *)"Sphericity_nError", _wrap_Sphericity_nError, METH_VARARGS, NULL},
	 { (char *)"Sphericity___str__", _wrap_Sphericity___str__, METH_VARARGS, NULL},
	 { (char *)"delete_Sphericity", _wrap_delete_Sphericity, METH_VARARGS, NULL},
	 { (char *)"Sphericity_swigregister", Sphericity_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Thrust", _wrap_new_Thrust, METH_VARARGS, NULL},
	 { (char *)"Thrust_analyze", _wrap_Thrust_analyze, METH_VARARGS, NULL},
	 { (char *)"Thrust_thrust", _wrap_Thrust_thrust, METH_VARARGS, NULL},
	 { (char *)"Thrust_tMajor", _wrap_Thrust_tMajor, METH_VARARGS, NULL},
	 { (char *)"Thrust_tMinor", _wrap_Thrust_tMinor, METH_VARARGS, NULL},
	 { (char *)"Thrust_oblateness", _wrap_Thrust_oblateness, METH_VARARGS, NULL},
	 { (char *)"Thrust_eventAxis", _wrap_Thrust_eventAxis, METH_VARARGS, NULL},
	 { (char *)"Thrust_nError", _wrap_Thrust_nError, METH_VARARGS, NULL},
	 { (char *)"Thrust___str__", _wrap_Thrust___str__, METH_VARARGS, NULL},
	 { (char *)"delete_Thrust", _wrap_delete_Thrust, METH_VARARGS, NULL},
	 { (char *)"Thrust_swigregister", Thrust_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SingleClusterJet", _wrap_new_SingleClusterJet, METH_VARARGS, NULL},
	 { (char *)"SingleClusterJet_pJet_set", _wrap_SingleClusterJet_pJet_set, METH_VARARGS, NULL},
	 { (char *)"SingleClusterJet_pJet_get", _wrap_SingleClusterJet_pJet_get, METH_VARARGS, NULL},
	 { (char *)"SingleClusterJet_mother_set", _wrap_SingleClusterJet_mother_set, METH_VARARGS, NULL},
	 { (char *)"SingleClusterJet_mother_get", _wrap_SingleClusterJet_mother_get, METH_VARARGS, NULL},
	 { (char *)"SingleClusterJet_daughter_set", _wrap_SingleClusterJet_daughter_set, METH_VARARGS, NULL},
	 { (char *)"SingleClusterJet_daughter_get", _wrap_SingleClusterJet_daughter_get, METH_VARARGS, NULL},
	 { (char *)"SingleClusterJet_multiplicity_set", _wrap_SingleClusterJet_multiplicity_set, METH_VARARGS, NULL},
	 { (char *)"SingleClusterJet_multiplicity_get", _wrap_SingleClusterJet_multiplicity_get, METH_VARARGS, NULL},
	 { (char *)"SingleClusterJet_isAssigned_set", _wrap_SingleClusterJet_isAssigned_set, METH_VARARGS, NULL},
	 { (char *)"SingleClusterJet_isAssigned_get", _wrap_SingleClusterJet_isAssigned_get, METH_VARARGS, NULL},
	 { (char *)"SingleClusterJet_pAbs_set", _wrap_SingleClusterJet_pAbs_set, METH_VARARGS, NULL},
	 { (char *)"SingleClusterJet_pAbs_get", _wrap_SingleClusterJet_pAbs_get, METH_VARARGS, NULL},
	 { (char *)"SingleClusterJet_pTemp_set", _wrap_SingleClusterJet_pTemp_set, METH_VARARGS, NULL},
	 { (char *)"SingleClusterJet_pTemp_get", _wrap_SingleClusterJet_pTemp_get, METH_VARARGS, NULL},
	 { (char *)"delete_SingleClusterJet", _wrap_delete_SingleClusterJet, METH_VARARGS, NULL},
	 { (char *)"SingleClusterJet_swigregister", SingleClusterJet_swigregister, METH_VARARGS, NULL},
	 { (char *)"dist2Fun", _wrap_dist2Fun, METH_VARARGS, NULL},
	 { (char *)"new_ClusterJet", _wrap_new_ClusterJet, METH_VARARGS, NULL},
	 { (char *)"ClusterJet_analyze", _wrap_ClusterJet_analyze, METH_VARARGS, NULL},
	 { (char *)"ClusterJet_size", _wrap_ClusterJet_size, METH_VARARGS, NULL},
	 { (char *)"ClusterJet_p", _wrap_ClusterJet_p, METH_VARARGS, NULL},
	 { (char *)"ClusterJet_mult", _wrap_ClusterJet_mult, METH_VARARGS, NULL},
	 { (char *)"ClusterJet_jetAssignment", _wrap_ClusterJet_jetAssignment, METH_VARARGS, NULL},
	 { (char *)"ClusterJet_distanceSize", _wrap_ClusterJet_distanceSize, METH_VARARGS, NULL},
	 { (char *)"ClusterJet_distance", _wrap_ClusterJet_distance, METH_VARARGS, NULL},
	 { (char *)"ClusterJet_nError", _wrap_ClusterJet_nError, METH_VARARGS, NULL},
	 { (char *)"ClusterJet___str__", _wrap_ClusterJet___str__, METH_VARARGS, NULL},
	 { (char *)"delete_ClusterJet", _wrap_delete_ClusterJet, METH_VARARGS, NULL},
	 { (char *)"ClusterJet_swigregister", ClusterJet_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SingleCell", _wrap_new_SingleCell, METH_VARARGS, NULL},
	 { (char *)"SingleCell_iCell_set", _wrap_SingleCell_iCell_set, METH_VARARGS, NULL},
	 { (char *)"SingleCell_iCell_get", _wrap_SingleCell_iCell_get, METH_VARARGS, NULL},
	 { (char *)"SingleCell_etaCell_set", _wrap_SingleCell_etaCell_set, METH_VARARGS, NULL},
	 { (char *)"SingleCell_etaCell_get", _wrap_SingleCell_etaCell_get, METH_VARARGS, NULL},
	 { (char *)"SingleCell_phiCell_set", _wrap_SingleCell_phiCell_set, METH_VARARGS, NULL},
	 { (char *)"SingleCell_phiCell_get", _wrap_SingleCell_phiCell_get, METH_VARARGS, NULL},
	 { (char *)"SingleCell_eTcell_set", _wrap_SingleCell_eTcell_set, METH_VARARGS, NULL},
	 { (char *)"SingleCell_eTcell_get", _wrap_SingleCell_eTcell_get, METH_VARARGS, NULL},
	 { (char *)"SingleCell_multiplicity_set", _wrap_SingleCell_multiplicity_set, METH_VARARGS, NULL},
	 { (char *)"SingleCell_multiplicity_get", _wrap_SingleCell_multiplicity_get, METH_VARARGS, NULL},
	 { (char *)"SingleCell_canBeSeed_set", _wrap_SingleCell_canBeSeed_set, METH_VARARGS, NULL},
	 { (char *)"SingleCell_canBeSeed_get", _wrap_SingleCell_canBeSeed_get, METH_VARARGS, NULL},
	 { (char *)"SingleCell_isUsed_set", _wrap_SingleCell_isUsed_set, METH_VARARGS, NULL},
	 { (char *)"SingleCell_isUsed_get", _wrap_SingleCell_isUsed_get, METH_VARARGS, NULL},
	 { (char *)"SingleCell_isAssigned_set", _wrap_SingleCell_isAssigned_set, METH_VARARGS, NULL},
	 { (char *)"SingleCell_isAssigned_get", _wrap_SingleCell_isAssigned_get, METH_VARARGS, NULL},
	 { (char *)"delete_SingleCell", _wrap_delete_SingleCell, METH_VARARGS, NULL},
	 { (char *)"SingleCell_swigregister", SingleCell_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SingleCellJet", _wrap_new_SingleCellJet, METH_VARARGS, NULL},
	 { (char *)"SingleCellJet_eTjet_set", _wrap_SingleCellJet_eTjet_set, METH_VARARGS, NULL},
	 { (char *)"SingleCellJet_eTjet_get", _wrap_SingleCellJet_eTjet_get, METH_VARARGS, NULL},
	 { (char *)"SingleCellJet_etaCenter_set", _wrap_SingleCellJet_etaCenter_set, METH_VARARGS, NULL},
	 { (char *)"SingleCellJet_etaCenter_get", _wrap_SingleCellJet_etaCenter_get, METH_VARARGS, NULL},
	 { (char *)"SingleCellJet_phiCenter_set", _wrap_SingleCellJet_phiCenter_set, METH_VARARGS, NULL},
	 { (char *)"SingleCellJet_phiCenter_get", _wrap_SingleCellJet_phiCenter_get, METH_VARARGS, NULL},
	 { (char *)"SingleCellJet_etaWeighted_set", _wrap_SingleCellJet_etaWeighted_set, METH_VARARGS, NULL},
	 { (char *)"SingleCellJet_etaWeighted_get", _wrap_SingleCellJet_etaWeighted_get, METH_VARARGS, NULL},
	 { (char *)"SingleCellJet_phiWeighted_set", _wrap_SingleCellJet_phiWeighted_set, METH_VARARGS, NULL},
	 { (char *)"SingleCellJet_phiWeighted_get", _wrap_SingleCellJet_phiWeighted_get, METH_VARARGS, NULL},
	 { (char *)"SingleCellJet_multiplicity_set", _wrap_SingleCellJet_multiplicity_set, METH_VARARGS, NULL},
	 { (char *)"SingleCellJet_multiplicity_get", _wrap_SingleCellJet_multiplicity_get, METH_VARARGS, NULL},
	 { (char *)"SingleCellJet_pMassive_set", _wrap_SingleCellJet_pMassive_set, METH_VARARGS, NULL},
	 { (char *)"SingleCellJet_pMassive_get", _wrap_SingleCellJet_pMassive_get, METH_VARARGS, NULL},
	 { (char *)"delete_SingleCellJet", _wrap_delete_SingleCellJet, METH_VARARGS, NULL},
	 { (char *)"SingleCellJet_swigregister", SingleCellJet_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CellJet", _wrap_new_CellJet, METH_VARARGS, NULL},
	 { (char *)"CellJet_analyze", _wrap_CellJet_analyze, METH_VARARGS, NULL},
	 { (char *)"CellJet_size", _wrap_CellJet_size, METH_VARARGS, NULL},
	 { (char *)"CellJet_eT", _wrap_CellJet_eT, METH_VARARGS, NULL},
	 { (char *)"CellJet_etaCenter", _wrap_CellJet_etaCenter, METH_VARARGS, NULL},
	 { (char *)"CellJet_phiCenter", _wrap_CellJet_phiCenter, METH_VARARGS, NULL},
	 { (char *)"CellJet_etaWeighted", _wrap_CellJet_etaWeighted, METH_VARARGS, NULL},
	 { (char *)"CellJet_phiWeighted", _wrap_CellJet_phiWeighted, METH_VARARGS, NULL},
	 { (char *)"CellJet_multiplicity", _wrap_CellJet_multiplicity, METH_VARARGS, NULL},
	 { (char *)"CellJet_pMassless", _wrap_CellJet_pMassless, METH_VARARGS, NULL},
	 { (char *)"CellJet_pMassive", _wrap_CellJet_pMassive, METH_VARARGS, NULL},
	 { (char *)"CellJet_m", _wrap_CellJet_m, METH_VARARGS, NULL},
	 { (char *)"CellJet_nError", _wrap_CellJet_nError, METH_VARARGS, NULL},
	 { (char *)"CellJet___str__", _wrap_CellJet___str__, METH_VARARGS, NULL},
	 { (char *)"delete_CellJet", _wrap_delete_CellJet, METH_VARARGS, NULL},
	 { (char *)"CellJet_swigregister", CellJet_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_SlowJetHook", _wrap_delete_SlowJetHook, METH_VARARGS, NULL},
	 { (char *)"SlowJetHook_include", _wrap_SlowJetHook_include, METH_VARARGS, NULL},
	 { (char *)"SlowJetHook_swigregister", SlowJetHook_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SingleSlowJet", _wrap_new_SingleSlowJet, METH_VARARGS, NULL},
	 { (char *)"SingleSlowJet_p_set", _wrap_SingleSlowJet_p_set, METH_VARARGS, NULL},
	 { (char *)"SingleSlowJet_p_get", _wrap_SingleSlowJet_p_get, METH_VARARGS, NULL},
	 { (char *)"SingleSlowJet_pT2_set", _wrap_SingleSlowJet_pT2_set, METH_VARARGS, NULL},
	 { (char *)"SingleSlowJet_pT2_get", _wrap_SingleSlowJet_pT2_get, METH_VARARGS, NULL},
	 { (char *)"SingleSlowJet_y_set", _wrap_SingleSlowJet_y_set, METH_VARARGS, NULL},
	 { (char *)"SingleSlowJet_y_get", _wrap_SingleSlowJet_y_get, METH_VARARGS, NULL},
	 { (char *)"SingleSlowJet_phi_set", _wrap_SingleSlowJet_phi_set, METH_VARARGS, NULL},
	 { (char *)"SingleSlowJet_phi_get", _wrap_SingleSlowJet_phi_get, METH_VARARGS, NULL},
	 { (char *)"SingleSlowJet_mult_set", _wrap_SingleSlowJet_mult_set, METH_VARARGS, NULL},
	 { (char *)"SingleSlowJet_mult_get", _wrap_SingleSlowJet_mult_get, METH_VARARGS, NULL},
	 { (char *)"SingleSlowJet_idx_set", _wrap_SingleSlowJet_idx_set, METH_VARARGS, NULL},
	 { (char *)"SingleSlowJet_idx_get", _wrap_SingleSlowJet_idx_get, METH_VARARGS, NULL},
	 { (char *)"delete_SingleSlowJet", _wrap_delete_SingleSlowJet, METH_VARARGS, NULL},
	 { (char *)"SingleSlowJet_swigregister", SingleSlowJet_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SlowJet", _wrap_new_SlowJet, METH_VARARGS, NULL},
	 { (char *)"delete_SlowJet", _wrap_delete_SlowJet, METH_VARARGS, NULL},
	 { (char *)"SlowJet_analyze", _wrap_SlowJet_analyze, METH_VARARGS, NULL},
	 { (char *)"SlowJet_setup", _wrap_SlowJet_setup, METH_VARARGS, NULL},
	 { (char *)"SlowJet_doStep", _wrap_SlowJet_doStep, METH_VARARGS, NULL},
	 { (char *)"SlowJet_doNSteps", _wrap_SlowJet_doNSteps, METH_VARARGS, NULL},
	 { (char *)"SlowJet_stopAtN", _wrap_SlowJet_stopAtN, METH_VARARGS, NULL},
	 { (char *)"SlowJet_sizeOrig", _wrap_SlowJet_sizeOrig, METH_VARARGS, NULL},
	 { (char *)"SlowJet_sizeJet", _wrap_SlowJet_sizeJet, METH_VARARGS, NULL},
	 { (char *)"SlowJet_sizeAll", _wrap_SlowJet_sizeAll, METH_VARARGS, NULL},
	 { (char *)"SlowJet_pT", _wrap_SlowJet_pT, METH_VARARGS, NULL},
	 { (char *)"SlowJet_y", _wrap_SlowJet_y, METH_VARARGS, NULL},
	 { (char *)"SlowJet_phi", _wrap_SlowJet_phi, METH_VARARGS, NULL},
	 { (char *)"SlowJet_p", _wrap_SlowJet_p, METH_VARARGS, NULL},
	 { (char *)"SlowJet_m", _wrap_SlowJet_m, METH_VARARGS, NULL},
	 { (char *)"SlowJet_multiplicity", _wrap_SlowJet_multiplicity, METH_VARARGS, NULL},
	 { (char *)"SlowJet_iNext", _wrap_SlowJet_iNext, METH_VARARGS, NULL},
	 { (char *)"SlowJet_jNext", _wrap_SlowJet_jNext, METH_VARARGS, NULL},
	 { (char *)"SlowJet_dNext", _wrap_SlowJet_dNext, METH_VARARGS, NULL},
	 { (char *)"SlowJet_constituents", _wrap_SlowJet_constituents, METH_VARARGS, NULL},
	 { (char *)"SlowJet_clusConstituents", _wrap_SlowJet_clusConstituents, METH_VARARGS, NULL},
	 { (char *)"SlowJet_jetAssignment", _wrap_SlowJet_jetAssignment, METH_VARARGS, NULL},
	 { (char *)"SlowJet_removeJet", _wrap_SlowJet_removeJet, METH_VARARGS, NULL},
	 { (char *)"SlowJet___str__", _wrap_SlowJet___str__, METH_VARARGS, NULL},
	 { (char *)"SlowJet_swigregister", SlowJet_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ResolvedParton", _wrap_new_ResolvedParton, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_update", _wrap_ResolvedParton_update, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_cols", _wrap_ResolvedParton_cols, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_scalePT", _wrap_ResolvedParton_scalePT, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_scaleX", _wrap_ResolvedParton_scaleX, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_iPos", _wrap_ResolvedParton_iPos, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_id", _wrap_ResolvedParton_id, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_x", _wrap_ResolvedParton_x, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_companion", _wrap_ResolvedParton_companion, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_isValence", _wrap_ResolvedParton_isValence, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_isUnmatched", _wrap_ResolvedParton_isUnmatched, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_isCompanion", _wrap_ResolvedParton_isCompanion, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_isFromBeam", _wrap_ResolvedParton_isFromBeam, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_xqCompanion", _wrap_ResolvedParton_xqCompanion, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_p", _wrap_ResolvedParton_p, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_px", _wrap_ResolvedParton_px, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_py", _wrap_ResolvedParton_py, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_pz", _wrap_ResolvedParton_pz, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_e", _wrap_ResolvedParton_e, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_m", _wrap_ResolvedParton_m, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_pT", _wrap_ResolvedParton_pT, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_mT2", _wrap_ResolvedParton_mT2, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_pPos", _wrap_ResolvedParton_pPos, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_pNeg", _wrap_ResolvedParton_pNeg, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_col", _wrap_ResolvedParton_col, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_acol", _wrap_ResolvedParton_acol, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_pTfactor", _wrap_ResolvedParton_pTfactor, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_hasCol", _wrap_ResolvedParton_hasCol, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_hasAcol", _wrap_ResolvedParton_hasAcol, METH_VARARGS, NULL},
	 { (char *)"delete_ResolvedParton", _wrap_delete_ResolvedParton, METH_VARARGS, NULL},
	 { (char *)"ResolvedParton_swigregister", ResolvedParton_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BeamParticle", _wrap_new_BeamParticle, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_init", _wrap_BeamParticle_init, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_initPDFPtr", _wrap_BeamParticle_initPDFPtr, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_initUnres", _wrap_BeamParticle_initUnres, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_newValenceContent", _wrap_BeamParticle_newValenceContent, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_newPzE", _wrap_BeamParticle_newPzE, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_newM", _wrap_BeamParticle_newM, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_id", _wrap_BeamParticle_id, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_idVMD", _wrap_BeamParticle_idVMD, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_p", _wrap_BeamParticle_p, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_px", _wrap_BeamParticle_px, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_py", _wrap_BeamParticle_py, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_pz", _wrap_BeamParticle_pz, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_e", _wrap_BeamParticle_e, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_m", _wrap_BeamParticle_m, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_mVMD", _wrap_BeamParticle_mVMD, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_scaleVMD", _wrap_BeamParticle_scaleVMD, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_isLepton", _wrap_BeamParticle_isLepton, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_isUnresolved", _wrap_BeamParticle_isUnresolved, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_isHadron", _wrap_BeamParticle_isHadron, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_isMeson", _wrap_BeamParticle_isMeson, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_isBaryon", _wrap_BeamParticle_isBaryon, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_isGamma", _wrap_BeamParticle_isGamma, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_hasResGamma", _wrap_BeamParticle_hasResGamma, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_hasVMDstate", _wrap_BeamParticle_hasVMDstate, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_xMax", _wrap_BeamParticle_xMax, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_xfHard", _wrap_BeamParticle_xfHard, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_xfMax", _wrap_BeamParticle_xfMax, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_xfFlux", _wrap_BeamParticle_xfFlux, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_xfApprox", _wrap_BeamParticle_xfApprox, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_xfGamma", _wrap_BeamParticle_xfGamma, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_xfSame", _wrap_BeamParticle_xfSame, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_xf", _wrap_BeamParticle_xf, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_xfVal", _wrap_BeamParticle_xfVal, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_xfSea", _wrap_BeamParticle_xfSea, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_xfMPI", _wrap_BeamParticle_xfMPI, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_xfISR", _wrap_BeamParticle_xfISR, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_insideBounds", _wrap_BeamParticle_insideBounds, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_alphaS", _wrap_BeamParticle_alphaS, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_mQuarkPDF", _wrap_BeamParticle_mQuarkPDF, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_nMembers", _wrap_BeamParticle_nMembers, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_calcPDFEnvelope", _wrap_BeamParticle_calcPDFEnvelope, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_getPDFEnvelope", _wrap_BeamParticle_getPDFEnvelope, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_pickValSeaComp", _wrap_BeamParticle_pickValSeaComp, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_initBeamKind", _wrap_BeamParticle_initBeamKind, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_size", _wrap_BeamParticle_size, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_sizeInit", _wrap_BeamParticle_sizeInit, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_clear", _wrap_BeamParticle_clear, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_resetGamma", _wrap_BeamParticle_resetGamma, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_resetGammaInLepton", _wrap_BeamParticle_resetGammaInLepton, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_append", _wrap_BeamParticle_append, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_popBack", _wrap_BeamParticle_popBack, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_nValenceKinds", _wrap_BeamParticle_nValenceKinds, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_nValence", _wrap_BeamParticle_nValence, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_isUnresolvedLepton", _wrap_BeamParticle_isUnresolvedLepton, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_remnantFlavours", _wrap_BeamParticle_remnantFlavours, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_remnantColours", _wrap_BeamParticle_remnantColours, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_xRemnant", _wrap_BeamParticle_xRemnant, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_hasJunction", _wrap_BeamParticle_hasJunction, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_junctionCol", _wrap_BeamParticle_junctionCol, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_pickGluon", _wrap_BeamParticle_pickGluon, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_pickValence", _wrap_BeamParticle_pickValence, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_pickRemnant", _wrap_BeamParticle_pickRemnant, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_zShare", _wrap_BeamParticle_zShare, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_pxShare", _wrap_BeamParticle_pxShare, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_pyShare", _wrap_BeamParticle_pyShare, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_remnantFlavoursNew", _wrap_BeamParticle_remnantFlavoursNew, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_findColSetup", _wrap_BeamParticle_findColSetup, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_setInitialCol", _wrap_BeamParticle_setInitialCol, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_updateCol", _wrap_BeamParticle_updateCol, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_getColUpdates", _wrap_BeamParticle_getColUpdates, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_gammaInitiatorIsVal", _wrap_BeamParticle_gammaInitiatorIsVal, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_getGammaValFlavour", _wrap_BeamParticle_getGammaValFlavour, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_gammaValSeaComp", _wrap_BeamParticle_gammaValSeaComp, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_posVal", _wrap_BeamParticle_posVal, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_gamVal", _wrap_BeamParticle_gamVal, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_resolvedGamma", _wrap_BeamParticle_resolvedGamma, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_setGammaMode", _wrap_BeamParticle_setGammaMode, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_getGammaMode", _wrap_BeamParticle_getGammaMode, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_isResolvedUnresolved", _wrap_BeamParticle_isResolvedUnresolved, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_setVMDstate", _wrap_BeamParticle_setVMDstate, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_pT2gamma2qqbar", _wrap_BeamParticle_pT2gamma2qqbar, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_pTMPI", _wrap_BeamParticle_pTMPI, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_roomFor1Remnant", _wrap_BeamParticle_roomFor1Remnant, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_roomFor2Remnants", _wrap_BeamParticle_roomFor2Remnants, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_roomForRemnants", _wrap_BeamParticle_roomForRemnants, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_remnantMass", _wrap_BeamParticle_remnantMass, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_gammaPDFxDependence", _wrap_BeamParticle_gammaPDFxDependence, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_gammaPDFRefScale", _wrap_BeamParticle_gammaPDFRefScale, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_xIntegratedPDFs", _wrap_BeamParticle_xIntegratedPDFs, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_xGammaPDF", _wrap_BeamParticle_xGammaPDF, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_newGammaKTPhi", _wrap_BeamParticle_newGammaKTPhi, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_Q2minPDF", _wrap_BeamParticle_Q2minPDF, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_xGammaMin", _wrap_BeamParticle_xGammaMin, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_xGammaHadr", _wrap_BeamParticle_xGammaHadr, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_gammaFluxNorm", _wrap_BeamParticle_gammaFluxNorm, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_xGamma", _wrap_BeamParticle_xGamma, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_Q2Gamma", _wrap_BeamParticle_Q2Gamma, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_gammaKTx", _wrap_BeamParticle_gammaKTx, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_gammaKTy", _wrap_BeamParticle_gammaKTy, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_gammaKT", _wrap_BeamParticle_gammaKT, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_gammaPhi", _wrap_BeamParticle_gammaPhi, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_xPom", _wrap_BeamParticle_xPom, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_sampleXgamma", _wrap_BeamParticle_sampleXgamma, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_sampleQ2gamma", _wrap_BeamParticle_sampleQ2gamma, METH_VARARGS, NULL},
	 { (char *)"BeamParticle___str__", _wrap_BeamParticle___str__, METH_VARARGS, NULL},
	 { (char *)"BeamParticle___getitem__", _wrap_BeamParticle___getitem__, METH_VARARGS, NULL},
	 { (char *)"delete_BeamParticle", _wrap_delete_BeamParticle, METH_VARARGS, NULL},
	 { (char *)"BeamParticle_swigregister", BeamParticle_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BoseEinsteinHadron", _wrap_new_BoseEinsteinHadron, METH_VARARGS, NULL},
	 { (char *)"BoseEinsteinHadron_id_set", _wrap_BoseEinsteinHadron_id_set, METH_VARARGS, NULL},
	 { (char *)"BoseEinsteinHadron_id_get", _wrap_BoseEinsteinHadron_id_get, METH_VARARGS, NULL},
	 { (char *)"BoseEinsteinHadron_iPos_set", _wrap_BoseEinsteinHadron_iPos_set, METH_VARARGS, NULL},
	 { (char *)"BoseEinsteinHadron_iPos_get", _wrap_BoseEinsteinHadron_iPos_get, METH_VARARGS, NULL},
	 { (char *)"BoseEinsteinHadron_p_set", _wrap_BoseEinsteinHadron_p_set, METH_VARARGS, NULL},
	 { (char *)"BoseEinsteinHadron_p_get", _wrap_BoseEinsteinHadron_p_get, METH_VARARGS, NULL},
	 { (char *)"BoseEinsteinHadron_pShift_set", _wrap_BoseEinsteinHadron_pShift_set, METH_VARARGS, NULL},
	 { (char *)"BoseEinsteinHadron_pShift_get", _wrap_BoseEinsteinHadron_pShift_get, METH_VARARGS, NULL},
	 { (char *)"BoseEinsteinHadron_pComp_set", _wrap_BoseEinsteinHadron_pComp_set, METH_VARARGS, NULL},
	 { (char *)"BoseEinsteinHadron_pComp_get", _wrap_BoseEinsteinHadron_pComp_get, METH_VARARGS, NULL},
	 { (char *)"BoseEinsteinHadron_m2_set", _wrap_BoseEinsteinHadron_m2_set, METH_VARARGS, NULL},
	 { (char *)"BoseEinsteinHadron_m2_get", _wrap_BoseEinsteinHadron_m2_get, METH_VARARGS, NULL},
	 { (char *)"delete_BoseEinsteinHadron", _wrap_delete_BoseEinsteinHadron, METH_VARARGS, NULL},
	 { (char *)"BoseEinsteinHadron_swigregister", BoseEinsteinHadron_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BoseEinstein", _wrap_new_BoseEinstein, METH_VARARGS, NULL},
	 { (char *)"BoseEinstein_init", _wrap_BoseEinstein_init, METH_VARARGS, NULL},
	 { (char *)"BoseEinstein_shiftEvent", _wrap_BoseEinstein_shiftEvent, METH_VARARGS, NULL},
	 { (char *)"delete_BoseEinstein", _wrap_delete_BoseEinstein, METH_VARARGS, NULL},
	 { (char *)"BoseEinstein_swigregister", BoseEinstein_swigregister, METH_VARARGS, NULL},
	 { (char *)"ColourTracing_init", _wrap_ColourTracing_init, METH_VARARGS, NULL},
	 { (char *)"ColourTracing_setupColList", _wrap_ColourTracing_setupColList, METH_VARARGS, NULL},
	 { (char *)"ColourTracing_traceFromAcol", _wrap_ColourTracing_traceFromAcol, METH_VARARGS, NULL},
	 { (char *)"ColourTracing_traceFromCol", _wrap_ColourTracing_traceFromCol, METH_VARARGS, NULL},
	 { (char *)"ColourTracing_traceInLoop", _wrap_ColourTracing_traceInLoop, METH_VARARGS, NULL},
	 { (char *)"ColourTracing_finished", _wrap_ColourTracing_finished, METH_VARARGS, NULL},
	 { (char *)"ColourTracing_colFinished", _wrap_ColourTracing_colFinished, METH_VARARGS, NULL},
	 { (char *)"ColourTracing_getJunChains", _wrap_ColourTracing_getJunChains, METH_VARARGS, NULL},
	 { (char *)"new_ColourTracing", _wrap_new_ColourTracing, METH_VARARGS, NULL},
	 { (char *)"delete_ColourTracing", _wrap_delete_ColourTracing, METH_VARARGS, NULL},
	 { (char *)"ColourTracing_swigregister", ColourTracing_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_GammaKinematics", _wrap_new_GammaKinematics, METH_VARARGS, NULL},
	 { (char *)"GammaKinematics_init", _wrap_GammaKinematics_init, METH_VARARGS, NULL},
	 { (char *)"GammaKinematics_sampleKTgamma", _wrap_GammaKinematics_sampleKTgamma, METH_VARARGS, NULL},
	 { (char *)"GammaKinematics_deriveKin", _wrap_GammaKinematics_deriveKin, METH_VARARGS, NULL},
	 { (char *)"GammaKinematics_finalize", _wrap_GammaKinematics_finalize, METH_VARARGS, NULL},
	 { (char *)"GammaKinematics_fluxWeight", _wrap_GammaKinematics_fluxWeight, METH_VARARGS, NULL},
	 { (char *)"GammaKinematics_calcNewSHat", _wrap_GammaKinematics_calcNewSHat, METH_VARARGS, NULL},
	 { (char *)"GammaKinematics_getQ2gamma1", _wrap_GammaKinematics_getQ2gamma1, METH_VARARGS, NULL},
	 { (char *)"GammaKinematics_getQ2gamma2", _wrap_GammaKinematics_getQ2gamma2, METH_VARARGS, NULL},
	 { (char *)"GammaKinematics_getQ2min1", _wrap_GammaKinematics_getQ2min1, METH_VARARGS, NULL},
	 { (char *)"GammaKinematics_getQ2min2", _wrap_GammaKinematics_getQ2min2, METH_VARARGS, NULL},
	 { (char *)"GammaKinematics_getPhi1", _wrap_GammaKinematics_getPhi1, METH_VARARGS, NULL},
	 { (char *)"GammaKinematics_getPhi2", _wrap_GammaKinematics_getPhi2, METH_VARARGS, NULL},
	 { (char *)"GammaKinematics_getKT1", _wrap_GammaKinematics_getKT1, METH_VARARGS, NULL},
	 { (char *)"GammaKinematics_getKT2", _wrap_GammaKinematics_getKT2, METH_VARARGS, NULL},
	 { (char *)"GammaKinematics_eCMsub", _wrap_GammaKinematics_eCMsub, METH_VARARGS, NULL},
	 { (char *)"delete_GammaKinematics", _wrap_delete_GammaKinematics, METH_VARARGS, NULL},
	 { (char *)"GammaKinematics_swigregister", GammaKinematics_swigregister, METH_VARARGS, NULL},
	 { (char *)"HardProcess_hardIncoming1_set", _wrap_HardProcess_hardIncoming1_set, METH_VARARGS, NULL},
	 { (char *)"HardProcess_hardIncoming1_get", _wrap_HardProcess_hardIncoming1_get, METH_VARARGS, NULL},
	 { (char *)"HardProcess_hardIncoming2_set", _wrap_HardProcess_hardIncoming2_set, METH_VARARGS, NULL},
	 { (char *)"HardProcess_hardIncoming2_get", _wrap_HardProcess_hardIncoming2_get, METH_VARARGS, NULL},
	 { (char *)"HardProcess_hardOutgoing1_set", _wrap_HardProcess_hardOutgoing1_set, METH_VARARGS, NULL},
	 { (char *)"HardProcess_hardOutgoing1_get", _wrap_HardProcess_hardOutgoing1_get, METH_VARARGS, NULL},
	 { (char *)"HardProcess_hardOutgoing2_set", _wrap_HardProcess_hardOutgoing2_set, METH_VARARGS, NULL},
	 { (char *)"HardProcess_hardOutgoing2_get", _wrap_HardProcess_hardOutgoing2_get, METH_VARARGS, NULL},
	 { (char *)"HardProcess_hardIntermediate_set", _wrap_HardProcess_hardIntermediate_set, METH_VARARGS, NULL},
	 { (char *)"HardProcess_hardIntermediate_get", _wrap_HardProcess_hardIntermediate_get, METH_VARARGS, NULL},
	 { (char *)"HardProcess_state_set", _wrap_HardProcess_state_set, METH_VARARGS, NULL},
	 { (char *)"HardProcess_state_get", _wrap_HardProcess_state_get, METH_VARARGS, NULL},
	 { (char *)"HardProcess_PosOutgoing1_set", _wrap_HardProcess_PosOutgoing1_set, METH_VARARGS, NULL},
	 { (char *)"HardProcess_PosOutgoing1_get", _wrap_HardProcess_PosOutgoing1_get, METH_VARARGS, NULL},
	 { (char *)"HardProcess_PosOutgoing2_set", _wrap_HardProcess_PosOutgoing2_set, METH_VARARGS, NULL},
	 { (char *)"HardProcess_PosOutgoing2_get", _wrap_HardProcess_PosOutgoing2_get, METH_VARARGS, NULL},
	 { (char *)"HardProcess_PosIntermediate_set", _wrap_HardProcess_PosIntermediate_set, METH_VARARGS, NULL},
	 { (char *)"HardProcess_PosIntermediate_get", _wrap_HardProcess_PosIntermediate_get, METH_VARARGS, NULL},
	 { (char *)"HardProcess_tms_set", _wrap_HardProcess_tms_set, METH_VARARGS, NULL},
	 { (char *)"HardProcess_tms_get", _wrap_HardProcess_tms_get, METH_VARARGS, NULL},
	 { (char *)"delete_HardProcess", _wrap_delete_HardProcess, METH_VARARGS, NULL},
	 { (char *)"new_HardProcess", _wrap_new_HardProcess, METH_VARARGS, NULL},
	 { (char *)"HardProcess_initOnProcess", _wrap_HardProcess_initOnProcess, METH_VARARGS, NULL},
	 { (char *)"HardProcess_initOnLHEF", _wrap_HardProcess_initOnLHEF, METH_VARARGS, NULL},
	 { (char *)"HardProcess_translateLHEFString", _wrap_HardProcess_translateLHEFString, METH_VARARGS, NULL},
	 { (char *)"HardProcess_translateProcessString", _wrap_HardProcess_translateProcessString, METH_VARARGS, NULL},
	 { (char *)"HardProcess_clear", _wrap_HardProcess_clear, METH_VARARGS, NULL},
	 { (char *)"HardProcess_allowCandidates", _wrap_HardProcess_allowCandidates, METH_VARARGS, NULL},
	 { (char *)"HardProcess_storeCandidates", _wrap_HardProcess_storeCandidates, METH_VARARGS, NULL},
	 { (char *)"HardProcess_matchesAnyOutgoing", _wrap_HardProcess_matchesAnyOutgoing, METH_VARARGS, NULL},
	 { (char *)"HardProcess_findOtherCandidates", _wrap_HardProcess_findOtherCandidates, METH_VARARGS, NULL},
	 { (char *)"HardProcess_exchangeCandidates", _wrap_HardProcess_exchangeCandidates, METH_VARARGS, NULL},
	 { (char *)"HardProcess_nQuarksOut", _wrap_HardProcess_nQuarksOut, METH_VARARGS, NULL},
	 { (char *)"HardProcess_nLeptonOut", _wrap_HardProcess_nLeptonOut, METH_VARARGS, NULL},
	 { (char *)"HardProcess_nBosonsOut", _wrap_HardProcess_nBosonsOut, METH_VARARGS, NULL},
	 { (char *)"HardProcess_nQuarksIn", _wrap_HardProcess_nQuarksIn, METH_VARARGS, NULL},
	 { (char *)"HardProcess_nLeptonIn", _wrap_HardProcess_nLeptonIn, METH_VARARGS, NULL},
	 { (char *)"HardProcess_hasResInCurrent", _wrap_HardProcess_hasResInCurrent, METH_VARARGS, NULL},
	 { (char *)"HardProcess_nResInCurrent", _wrap_HardProcess_nResInCurrent, METH_VARARGS, NULL},
	 { (char *)"HardProcess_hasResInProc", _wrap_HardProcess_hasResInProc, METH_VARARGS, NULL},
	 { (char *)"HardProcess_listCandidates", _wrap_HardProcess_listCandidates, METH_VARARGS, NULL},
	 { (char *)"HardProcess___str__", _wrap_HardProcess___str__, METH_VARARGS, NULL},
	 { (char *)"HardProcess_swigregister", HardProcess_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MergingHooks", _wrap_new_MergingHooks, METH_VARARGS, NULL},
	 { (char *)"delete_MergingHooks", _wrap_delete_MergingHooks, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_tmsDefinition", _wrap_MergingHooks_tmsDefinition, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_dampenIfFailCuts", _wrap_MergingHooks_dampenIfFailCuts, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_canCutOnRecState", _wrap_MergingHooks_canCutOnRecState, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doCutOnRecState", _wrap_MergingHooks_doCutOnRecState, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_canVetoTrialEmission", _wrap_MergingHooks_canVetoTrialEmission, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doVetoTrialEmission", _wrap_MergingHooks_doVetoTrialEmission, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_hardProcessME", _wrap_MergingHooks_hardProcessME, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_init", _wrap_MergingHooks_init, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_initPtr", _wrap_MergingHooks_initPtr, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_tmsCut", _wrap_MergingHooks_tmsCut, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_tms", _wrap_MergingHooks_tms, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_dRijMS", _wrap_MergingHooks_dRijMS, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_pTiMS", _wrap_MergingHooks_pTiMS, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_QijMS", _wrap_MergingHooks_QijMS, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nMaxJets", _wrap_MergingHooks_nMaxJets, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nMaxJetsNLO", _wrap_MergingHooks_nMaxJetsNLO, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_getProcessString", _wrap_MergingHooks_getProcessString, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nHardOutPartons", _wrap_MergingHooks_nHardOutPartons, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nHardOutLeptons", _wrap_MergingHooks_nHardOutLeptons, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nHardOutBosons", _wrap_MergingHooks_nHardOutBosons, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nHardInPartons", _wrap_MergingHooks_nHardInPartons, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nHardInLeptons", _wrap_MergingHooks_nHardInLeptons, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nResInCurrent", _wrap_MergingHooks_nResInCurrent, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doUserMerging", _wrap_MergingHooks_doUserMerging, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doMGMerging", _wrap_MergingHooks_doMGMerging, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doKTMerging", _wrap_MergingHooks_doKTMerging, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doPTLundMerging", _wrap_MergingHooks_doPTLundMerging, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doCutBasedMerging", _wrap_MergingHooks_doCutBasedMerging, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doCKKWLMerging", _wrap_MergingHooks_doCKKWLMerging, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doUMEPSTree", _wrap_MergingHooks_doUMEPSTree, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doUMEPSSubt", _wrap_MergingHooks_doUMEPSSubt, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doUMEPSMerging", _wrap_MergingHooks_doUMEPSMerging, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doNL3Tree", _wrap_MergingHooks_doNL3Tree, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doNL3Loop", _wrap_MergingHooks_doNL3Loop, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doNL3Subt", _wrap_MergingHooks_doNL3Subt, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doNL3Merging", _wrap_MergingHooks_doNL3Merging, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doUNLOPSTree", _wrap_MergingHooks_doUNLOPSTree, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doUNLOPSLoop", _wrap_MergingHooks_doUNLOPSLoop, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doUNLOPSSubt", _wrap_MergingHooks_doUNLOPSSubt, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doUNLOPSSubtNLO", _wrap_MergingHooks_doUNLOPSSubtNLO, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doUNLOPSMerging", _wrap_MergingHooks_doUNLOPSMerging, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nRecluster", _wrap_MergingHooks_nRecluster, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nRequested", _wrap_MergingHooks_nRequested, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_isFirstEmission", _wrap_MergingHooks_isFirstEmission, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_hasEffectiveG2EW", _wrap_MergingHooks_hasEffectiveG2EW, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_allowEffectiveVertex", _wrap_MergingHooks_allowEffectiveVertex, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_bareEvent", _wrap_MergingHooks_bareEvent, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_reattachResonanceDecays", _wrap_MergingHooks_reattachResonanceDecays, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_isInHard", _wrap_MergingHooks_isInHard, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_getNumberOfClusteringSteps", _wrap_MergingHooks_getNumberOfClusteringSteps, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_orderHistories", _wrap_MergingHooks_orderHistories, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_allowCutOnRecState", _wrap_MergingHooks_allowCutOnRecState, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doWeakClustering", _wrap_MergingHooks_doWeakClustering, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_checkAgainstCut", _wrap_MergingHooks_checkAgainstCut, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_rhoms", _wrap_MergingHooks_rhoms, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_kTms", _wrap_MergingHooks_kTms, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_cutbasedms", _wrap_MergingHooks_cutbasedms, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doIgnoreEmissions", _wrap_MergingHooks_doIgnoreEmissions, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_canVetoEmission", _wrap_MergingHooks_canVetoEmission, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doVetoEmission", _wrap_MergingHooks_doVetoEmission, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_useShowerPluginSave_set", _wrap_MergingHooks_useShowerPluginSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_useShowerPluginSave_get", _wrap_MergingHooks_useShowerPluginSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_useShowerPlugin", _wrap_MergingHooks_useShowerPlugin, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_includeWGTinXSEC", _wrap_MergingHooks_includeWGTinXSEC, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nHardNow", _wrap_MergingHooks_nHardNow, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_tmsHardNow", _wrap_MergingHooks_tmsHardNow, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nJetsNow", _wrap_MergingHooks_nJetsNow, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_tmsNow", _wrap_MergingHooks_tmsNow, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_setHardProcessPtr", _wrap_MergingHooks_setHardProcessPtr, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_useOwnHardProcess_set", _wrap_MergingHooks_useOwnHardProcess_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_useOwnHardProcess_get", _wrap_MergingHooks_useOwnHardProcess_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_hardProcess_set", _wrap_MergingHooks_hardProcess_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_hardProcess_get", _wrap_MergingHooks_hardProcess_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_infoPtr_set", _wrap_MergingHooks_infoPtr_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_infoPtr_get", _wrap_MergingHooks_infoPtr_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_settingsPtr_set", _wrap_MergingHooks_settingsPtr_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_settingsPtr_get", _wrap_MergingHooks_settingsPtr_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_particleDataPtr_set", _wrap_MergingHooks_particleDataPtr_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_particleDataPtr_get", _wrap_MergingHooks_particleDataPtr_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_partonSystemsPtr_set", _wrap_MergingHooks_partonSystemsPtr_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_partonSystemsPtr_get", _wrap_MergingHooks_partonSystemsPtr_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_showers_set", _wrap_MergingHooks_showers_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_showers_get", _wrap_MergingHooks_showers_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_setShowerPointer", _wrap_MergingHooks_setShowerPointer, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_AlphaS_FSRSave_set", _wrap_MergingHooks_AlphaS_FSRSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_AlphaS_FSRSave_get", _wrap_MergingHooks_AlphaS_FSRSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_AlphaS_ISRSave_set", _wrap_MergingHooks_AlphaS_ISRSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_AlphaS_ISRSave_get", _wrap_MergingHooks_AlphaS_ISRSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_AlphaEM_FSRSave_set", _wrap_MergingHooks_AlphaEM_FSRSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_AlphaEM_FSRSave_get", _wrap_MergingHooks_AlphaEM_FSRSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_AlphaEM_ISRSave_set", _wrap_MergingHooks_AlphaEM_ISRSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_AlphaEM_ISRSave_get", _wrap_MergingHooks_AlphaEM_ISRSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_lheInputFile_set", _wrap_MergingHooks_lheInputFile_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_lheInputFile_get", _wrap_MergingHooks_lheInputFile_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doUserMergingSave_set", _wrap_MergingHooks_doUserMergingSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doUserMergingSave_get", _wrap_MergingHooks_doUserMergingSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doMGMergingSave_set", _wrap_MergingHooks_doMGMergingSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doMGMergingSave_get", _wrap_MergingHooks_doMGMergingSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doKTMergingSave_set", _wrap_MergingHooks_doKTMergingSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doKTMergingSave_get", _wrap_MergingHooks_doKTMergingSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doPTLundMergingSave_set", _wrap_MergingHooks_doPTLundMergingSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doPTLundMergingSave_get", _wrap_MergingHooks_doPTLundMergingSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doCutBasedMergingSave_set", _wrap_MergingHooks_doCutBasedMergingSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doCutBasedMergingSave_get", _wrap_MergingHooks_doCutBasedMergingSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_includeMassiveSave_set", _wrap_MergingHooks_includeMassiveSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_includeMassiveSave_get", _wrap_MergingHooks_includeMassiveSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_enforceStrongOrderingSave_set", _wrap_MergingHooks_enforceStrongOrderingSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_enforceStrongOrderingSave_get", _wrap_MergingHooks_enforceStrongOrderingSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_orderInRapiditySave_set", _wrap_MergingHooks_orderInRapiditySave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_orderInRapiditySave_get", _wrap_MergingHooks_orderInRapiditySave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_pickByFullPSave_set", _wrap_MergingHooks_pickByFullPSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_pickByFullPSave_get", _wrap_MergingHooks_pickByFullPSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_pickByPoPT2Save_set", _wrap_MergingHooks_pickByPoPT2Save_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_pickByPoPT2Save_get", _wrap_MergingHooks_pickByPoPT2Save_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_includeRedundantSave_set", _wrap_MergingHooks_includeRedundantSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_includeRedundantSave_get", _wrap_MergingHooks_includeRedundantSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_pickBySumPTSave_set", _wrap_MergingHooks_pickBySumPTSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_pickBySumPTSave_get", _wrap_MergingHooks_pickBySumPTSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_allowColourShufflingSave_set", _wrap_MergingHooks_allowColourShufflingSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_allowColourShufflingSave_get", _wrap_MergingHooks_allowColourShufflingSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_resetHardQRenSave_set", _wrap_MergingHooks_resetHardQRenSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_resetHardQRenSave_get", _wrap_MergingHooks_resetHardQRenSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_resetHardQFacSave_set", _wrap_MergingHooks_resetHardQFacSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_resetHardQFacSave_get", _wrap_MergingHooks_resetHardQFacSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_unorderedScalePrescipSave_set", _wrap_MergingHooks_unorderedScalePrescipSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_unorderedScalePrescipSave_get", _wrap_MergingHooks_unorderedScalePrescipSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_unorderedASscalePrescipSave_set", _wrap_MergingHooks_unorderedASscalePrescipSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_unorderedASscalePrescipSave_get", _wrap_MergingHooks_unorderedASscalePrescipSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_unorderedPDFscalePrescipSave_set", _wrap_MergingHooks_unorderedPDFscalePrescipSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_unorderedPDFscalePrescipSave_get", _wrap_MergingHooks_unorderedPDFscalePrescipSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_incompleteScalePrescipSave_set", _wrap_MergingHooks_incompleteScalePrescipSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_incompleteScalePrescipSave_get", _wrap_MergingHooks_incompleteScalePrescipSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_ktTypeSave_set", _wrap_MergingHooks_ktTypeSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_ktTypeSave_get", _wrap_MergingHooks_ktTypeSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nReclusterSave_set", _wrap_MergingHooks_nReclusterSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nReclusterSave_get", _wrap_MergingHooks_nReclusterSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nQuarksMergeSave_set", _wrap_MergingHooks_nQuarksMergeSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nQuarksMergeSave_get", _wrap_MergingHooks_nQuarksMergeSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nRequestedSave_set", _wrap_MergingHooks_nRequestedSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nRequestedSave_get", _wrap_MergingHooks_nRequestedSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_scaleSeparationFactorSave_set", _wrap_MergingHooks_scaleSeparationFactorSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_scaleSeparationFactorSave_get", _wrap_MergingHooks_scaleSeparationFactorSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nonJoinedNormSave_set", _wrap_MergingHooks_nonJoinedNormSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nonJoinedNormSave_get", _wrap_MergingHooks_nonJoinedNormSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_fsrInRecNormSave_set", _wrap_MergingHooks_fsrInRecNormSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_fsrInRecNormSave_get", _wrap_MergingHooks_fsrInRecNormSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_herwigAcollFSRSave_set", _wrap_MergingHooks_herwigAcollFSRSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_herwigAcollFSRSave_get", _wrap_MergingHooks_herwigAcollFSRSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_herwigAcollISRSave_set", _wrap_MergingHooks_herwigAcollISRSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_herwigAcollISRSave_get", _wrap_MergingHooks_herwigAcollISRSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_pT0ISRSave_set", _wrap_MergingHooks_pT0ISRSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_pT0ISRSave_get", _wrap_MergingHooks_pT0ISRSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_pTcutSave_set", _wrap_MergingHooks_pTcutSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_pTcutSave_get", _wrap_MergingHooks_pTcutSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doNL3TreeSave_set", _wrap_MergingHooks_doNL3TreeSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doNL3TreeSave_get", _wrap_MergingHooks_doNL3TreeSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doNL3LoopSave_set", _wrap_MergingHooks_doNL3LoopSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doNL3LoopSave_get", _wrap_MergingHooks_doNL3LoopSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doNL3SubtSave_set", _wrap_MergingHooks_doNL3SubtSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doNL3SubtSave_get", _wrap_MergingHooks_doNL3SubtSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doUNLOPSTreeSave_set", _wrap_MergingHooks_doUNLOPSTreeSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doUNLOPSTreeSave_get", _wrap_MergingHooks_doUNLOPSTreeSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doUNLOPSLoopSave_set", _wrap_MergingHooks_doUNLOPSLoopSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doUNLOPSLoopSave_get", _wrap_MergingHooks_doUNLOPSLoopSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doUNLOPSSubtSave_set", _wrap_MergingHooks_doUNLOPSSubtSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doUNLOPSSubtSave_get", _wrap_MergingHooks_doUNLOPSSubtSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doUNLOPSSubtNLOSave_set", _wrap_MergingHooks_doUNLOPSSubtNLOSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doUNLOPSSubtNLOSave_get", _wrap_MergingHooks_doUNLOPSSubtNLOSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doUMEPSTreeSave_set", _wrap_MergingHooks_doUMEPSTreeSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doUMEPSTreeSave_get", _wrap_MergingHooks_doUMEPSTreeSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doUMEPSSubtSave_set", _wrap_MergingHooks_doUMEPSSubtSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doUMEPSSubtSave_get", _wrap_MergingHooks_doUMEPSSubtSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doEstimateXSection_set", _wrap_MergingHooks_doEstimateXSection_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doEstimateXSection_get", _wrap_MergingHooks_doEstimateXSection_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_applyVeto_set", _wrap_MergingHooks_applyVeto_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_applyVeto_get", _wrap_MergingHooks_applyVeto_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_inputEvent_set", _wrap_MergingHooks_inputEvent_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_inputEvent_get", _wrap_MergingHooks_inputEvent_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_resonances_set", _wrap_MergingHooks_resonances_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_resonances_get", _wrap_MergingHooks_resonances_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doRemoveDecayProducts_set", _wrap_MergingHooks_doRemoveDecayProducts_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doRemoveDecayProducts_get", _wrap_MergingHooks_doRemoveDecayProducts_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_muMISave_set", _wrap_MergingHooks_muMISave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_muMISave_get", _wrap_MergingHooks_muMISave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_kFactor0jSave_set", _wrap_MergingHooks_kFactor0jSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_kFactor0jSave_get", _wrap_MergingHooks_kFactor0jSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_kFactor1jSave_set", _wrap_MergingHooks_kFactor1jSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_kFactor1jSave_get", _wrap_MergingHooks_kFactor1jSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_kFactor2jSave_set", _wrap_MergingHooks_kFactor2jSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_kFactor2jSave_get", _wrap_MergingHooks_kFactor2jSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_tmsValueSave_set", _wrap_MergingHooks_tmsValueSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_tmsValueSave_get", _wrap_MergingHooks_tmsValueSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_tmsValueNow_set", _wrap_MergingHooks_tmsValueNow_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_tmsValueNow_get", _wrap_MergingHooks_tmsValueNow_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_DparameterSave_set", _wrap_MergingHooks_DparameterSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_DparameterSave_get", _wrap_MergingHooks_DparameterSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nJetMaxSave_set", _wrap_MergingHooks_nJetMaxSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nJetMaxSave_get", _wrap_MergingHooks_nJetMaxSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nJetMaxNLOSave_set", _wrap_MergingHooks_nJetMaxNLOSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nJetMaxNLOSave_get", _wrap_MergingHooks_nJetMaxNLOSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_processSave_set", _wrap_MergingHooks_processSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_processSave_get", _wrap_MergingHooks_processSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_tmsListSave_set", _wrap_MergingHooks_tmsListSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_tmsListSave_get", _wrap_MergingHooks_tmsListSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doOrderHistoriesSave_set", _wrap_MergingHooks_doOrderHistoriesSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doOrderHistoriesSave_get", _wrap_MergingHooks_doOrderHistoriesSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doCutOnRecStateSave_set", _wrap_MergingHooks_doCutOnRecStateSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doCutOnRecStateSave_get", _wrap_MergingHooks_doCutOnRecStateSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doWeakClusteringSave_set", _wrap_MergingHooks_doWeakClusteringSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doWeakClusteringSave_get", _wrap_MergingHooks_doWeakClusteringSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doSQCDClusteringSave_set", _wrap_MergingHooks_doSQCDClusteringSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doSQCDClusteringSave_get", _wrap_MergingHooks_doSQCDClusteringSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_muFSave_set", _wrap_MergingHooks_muFSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_muFSave_get", _wrap_MergingHooks_muFSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_muRSave_set", _wrap_MergingHooks_muRSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_muRSave_get", _wrap_MergingHooks_muRSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_muFinMESave_set", _wrap_MergingHooks_muFinMESave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_muFinMESave_get", _wrap_MergingHooks_muFinMESave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_muRinMESave_set", _wrap_MergingHooks_muRinMESave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_muRinMESave_get", _wrap_MergingHooks_muRinMESave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doIgnoreEmissionsSave_set", _wrap_MergingHooks_doIgnoreEmissionsSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doIgnoreEmissionsSave_get", _wrap_MergingHooks_doIgnoreEmissionsSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doIgnoreStepSave_set", _wrap_MergingHooks_doIgnoreStepSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doIgnoreStepSave_get", _wrap_MergingHooks_doIgnoreStepSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_pTsave_set", _wrap_MergingHooks_pTsave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_pTsave_get", _wrap_MergingHooks_pTsave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_weightCKKWL1Save_set", _wrap_MergingHooks_weightCKKWL1Save_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_weightCKKWL1Save_get", _wrap_MergingHooks_weightCKKWL1Save_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_weightCKKWL2Save_set", _wrap_MergingHooks_weightCKKWL2Save_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_weightCKKWL2Save_get", _wrap_MergingHooks_weightCKKWL2Save_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nMinMPISave_set", _wrap_MergingHooks_nMinMPISave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nMinMPISave_get", _wrap_MergingHooks_nMinMPISave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_weightCKKWLSave_set", _wrap_MergingHooks_weightCKKWLSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_weightCKKWLSave_get", _wrap_MergingHooks_weightCKKWLSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_weightFIRSTSave_set", _wrap_MergingHooks_weightFIRSTSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_weightFIRSTSave_get", _wrap_MergingHooks_weightFIRSTSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nJetMaxLocal_set", _wrap_MergingHooks_nJetMaxLocal_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nJetMaxLocal_get", _wrap_MergingHooks_nJetMaxLocal_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nJetMaxNLOLocal_set", _wrap_MergingHooks_nJetMaxNLOLocal_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nJetMaxNLOLocal_get", _wrap_MergingHooks_nJetMaxNLOLocal_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_hasJetMaxLocal_set", _wrap_MergingHooks_hasJetMaxLocal_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_hasJetMaxLocal_get", _wrap_MergingHooks_hasJetMaxLocal_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_includeWGTinXSECSave_set", _wrap_MergingHooks_includeWGTinXSECSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_includeWGTinXSECSave_get", _wrap_MergingHooks_includeWGTinXSECSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nHardNowSave_set", _wrap_MergingHooks_nHardNowSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nHardNowSave_get", _wrap_MergingHooks_nHardNowSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nJetNowSave_set", _wrap_MergingHooks_nJetNowSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nJetNowSave_get", _wrap_MergingHooks_nJetNowSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_tmsHardNowSave_set", _wrap_MergingHooks_tmsHardNowSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_tmsHardNowSave_get", _wrap_MergingHooks_tmsHardNowSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_tmsNowSave_set", _wrap_MergingHooks_tmsNowSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_tmsNowSave_get", _wrap_MergingHooks_tmsNowSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_storeHardProcessCandidates", _wrap_MergingHooks_storeHardProcessCandidates, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_setLHEInputFile", _wrap_MergingHooks_setLHEInputFile, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_AlphaS_FSR", _wrap_MergingHooks_AlphaS_FSR, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_AlphaS_ISR", _wrap_MergingHooks_AlphaS_ISR, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_AlphaEM_FSR", _wrap_MergingHooks_AlphaEM_FSR, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_AlphaEM_ISR", _wrap_MergingHooks_AlphaEM_ISR, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_includeMassive", _wrap_MergingHooks_includeMassive, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_enforceStrongOrdering", _wrap_MergingHooks_enforceStrongOrdering, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_orderInRapidity", _wrap_MergingHooks_orderInRapidity, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_pickByFull", _wrap_MergingHooks_pickByFull, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_pickByPoPT2", _wrap_MergingHooks_pickByPoPT2, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_includeRedundant", _wrap_MergingHooks_includeRedundant, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_pickBySumPT", _wrap_MergingHooks_pickBySumPT, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_unorderedScalePrescip", _wrap_MergingHooks_unorderedScalePrescip, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_unorderedASscalePrescip", _wrap_MergingHooks_unorderedASscalePrescip, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_unorderedPDFscalePrescip", _wrap_MergingHooks_unorderedPDFscalePrescip, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_incompleteScalePrescip", _wrap_MergingHooks_incompleteScalePrescip, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_allowColourShuffling", _wrap_MergingHooks_allowColourShuffling, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_resetHardQRen", _wrap_MergingHooks_resetHardQRen, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_resetHardQFac", _wrap_MergingHooks_resetHardQFac, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_scaleSeparationFactor", _wrap_MergingHooks_scaleSeparationFactor, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nonJoinedNorm", _wrap_MergingHooks_nonJoinedNorm, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_fsrInRecNorm", _wrap_MergingHooks_fsrInRecNorm, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_herwigAcollFSR", _wrap_MergingHooks_herwigAcollFSR, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_herwigAcollISR", _wrap_MergingHooks_herwigAcollISR, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_pT0ISR", _wrap_MergingHooks_pT0ISR, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_pTcut", _wrap_MergingHooks_pTcut, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_muMI", _wrap_MergingHooks_muMI, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_kFactor", _wrap_MergingHooks_kFactor, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_k1Factor", _wrap_MergingHooks_k1Factor, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_getOrderHistories", _wrap_MergingHooks_getOrderHistories, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_getAllowCutOnRecState", _wrap_MergingHooks_getAllowCutOnRecState, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_getDoWeakClustering", _wrap_MergingHooks_getDoWeakClustering, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doSQCDClustering", _wrap_MergingHooks_doSQCDClustering, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_muF", _wrap_MergingHooks_muF, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_muR", _wrap_MergingHooks_muR, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_muFinME", _wrap_MergingHooks_muFinME, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_muRinME", _wrap_MergingHooks_muRinME, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doIgnoreStep", _wrap_MergingHooks_doIgnoreStep, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_canVetoStep", _wrap_MergingHooks_canVetoStep, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_storeWeights", _wrap_MergingHooks_storeWeights, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_doVetoStep", _wrap_MergingHooks_doVetoStep, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_setShowerStartingScales", _wrap_MergingHooks_setShowerStartingScales, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_stopScaleSave_set", _wrap_MergingHooks_stopScaleSave_set, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_stopScaleSave_get", _wrap_MergingHooks_stopScaleSave_get, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_setShowerStoppingScale", _wrap_MergingHooks_setShowerStoppingScale, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_getShowerStoppingScale", _wrap_MergingHooks_getShowerStoppingScale, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_nMinMPI", _wrap_MergingHooks_nMinMPI, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_kTdurham", _wrap_MergingHooks_kTdurham, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_rhoPythia", _wrap_MergingHooks_rhoPythia, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_findColour", _wrap_MergingHooks_findColour, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_deltaRij", _wrap_MergingHooks_deltaRij, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_getWeightNLO", _wrap_MergingHooks_getWeightNLO, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_getWeightCKKWL", _wrap_MergingHooks_getWeightCKKWL, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_getWeightFIRST", _wrap_MergingHooks_getWeightFIRST, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_setWeightCKKWL", _wrap_MergingHooks_setWeightCKKWL, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_setWeightFIRST", _wrap_MergingHooks_setWeightFIRST, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_setEventVetoInfo", _wrap_MergingHooks_setEventVetoInfo, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_setHardProcessInfo", _wrap_MergingHooks_setHardProcessInfo, METH_VARARGS, NULL},
	 { (char *)"disown_MergingHooks", _wrap_disown_MergingHooks, METH_VARARGS, NULL},
	 { (char *)"MergingHooks_swigregister", MergingHooks_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_InBeam", _wrap_new_InBeam, METH_VARARGS, NULL},
	 { (char *)"InBeam_id_set", _wrap_InBeam_id_set, METH_VARARGS, NULL},
	 { (char *)"InBeam_id_get", _wrap_InBeam_id_get, METH_VARARGS, NULL},
	 { (char *)"InBeam_pdf_set", _wrap_InBeam_pdf_set, METH_VARARGS, NULL},
	 { (char *)"InBeam_pdf_get", _wrap_InBeam_pdf_get, METH_VARARGS, NULL},
	 { (char *)"delete_InBeam", _wrap_delete_InBeam, METH_VARARGS, NULL},
	 { (char *)"InBeam_swigregister", InBeam_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_InPair", _wrap_new_InPair, METH_VARARGS, NULL},
	 { (char *)"InPair_idA_set", _wrap_InPair_idA_set, METH_VARARGS, NULL},
	 { (char *)"InPair_idA_get", _wrap_InPair_idA_get, METH_VARARGS, NULL},
	 { (char *)"InPair_idB_set", _wrap_InPair_idB_set, METH_VARARGS, NULL},
	 { (char *)"InPair_idB_get", _wrap_InPair_idB_get, METH_VARARGS, NULL},
	 { (char *)"InPair_pdfA_set", _wrap_InPair_pdfA_set, METH_VARARGS, NULL},
	 { (char *)"InPair_pdfA_get", _wrap_InPair_pdfA_get, METH_VARARGS, NULL},
	 { (char *)"InPair_pdfB_set", _wrap_InPair_pdfB_set, METH_VARARGS, NULL},
	 { (char *)"InPair_pdfB_get", _wrap_InPair_pdfB_get, METH_VARARGS, NULL},
	 { (char *)"InPair_pdfSigma_set", _wrap_InPair_pdfSigma_set, METH_VARARGS, NULL},
	 { (char *)"InPair_pdfSigma_get", _wrap_InPair_pdfSigma_get, METH_VARARGS, NULL},
	 { (char *)"delete_InPair", _wrap_delete_InPair, METH_VARARGS, NULL},
	 { (char *)"InPair_swigregister", InPair_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_SigmaProcess", _wrap_delete_SigmaProcess, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_init", _wrap_SigmaProcess_init, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_setLHAPtr", _wrap_SigmaProcess_setLHAPtr, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_initProc", _wrap_SigmaProcess_initProc, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_initFlux", _wrap_SigmaProcess_initFlux, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_set1Kin", _wrap_SigmaProcess_set1Kin, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_set2Kin", _wrap_SigmaProcess_set2Kin, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_set2KinMPI", _wrap_SigmaProcess_set2KinMPI, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_set3Kin", _wrap_SigmaProcess_set3Kin, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_sigmaKin", _wrap_SigmaProcess_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_sigmaHat", _wrap_SigmaProcess_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_sigmaHatWrap", _wrap_SigmaProcess_sigmaHatWrap, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_sigmaPDF", _wrap_SigmaProcess_sigmaPDF, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_pickInState", _wrap_SigmaProcess_pickInState, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_setIdColAcol", _wrap_SigmaProcess_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_final2KinMPI", _wrap_SigmaProcess_final2KinMPI, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_weightDecayFlav", _wrap_SigmaProcess_weightDecayFlav, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_weightDecay", _wrap_SigmaProcess_weightDecay, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_setScale", _wrap_SigmaProcess_setScale, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_name", _wrap_SigmaProcess_name, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_code", _wrap_SigmaProcess_code, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_nFinal", _wrap_SigmaProcess_nFinal, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_inFlux", _wrap_SigmaProcess_inFlux, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_convert2mb", _wrap_SigmaProcess_convert2mb, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_convertM2", _wrap_SigmaProcess_convertM2, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_isLHA", _wrap_SigmaProcess_isLHA, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_isNonDiff", _wrap_SigmaProcess_isNonDiff, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_isResolved", _wrap_SigmaProcess_isResolved, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_isDiffA", _wrap_SigmaProcess_isDiffA, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_isDiffB", _wrap_SigmaProcess_isDiffB, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_isDiffC", _wrap_SigmaProcess_isDiffC, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_isSUSY", _wrap_SigmaProcess_isSUSY, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_allowNegativeSigma", _wrap_SigmaProcess_allowNegativeSigma, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_id3Mass", _wrap_SigmaProcess_id3Mass, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_id4Mass", _wrap_SigmaProcess_id4Mass, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_id5Mass", _wrap_SigmaProcess_id5Mass, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_resonanceA", _wrap_SigmaProcess_resonanceA, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_resonanceB", _wrap_SigmaProcess_resonanceB, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_isSChannel", _wrap_SigmaProcess_isSChannel, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_idSChannel", _wrap_SigmaProcess_idSChannel, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_isQCD3body", _wrap_SigmaProcess_isQCD3body, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_idTchan1", _wrap_SigmaProcess_idTchan1, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_idTchan2", _wrap_SigmaProcess_idTchan2, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_tChanFracPow1", _wrap_SigmaProcess_tChanFracPow1, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_tChanFracPow2", _wrap_SigmaProcess_tChanFracPow2, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_useMirrorWeight", _wrap_SigmaProcess_useMirrorWeight, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_gmZmode", _wrap_SigmaProcess_gmZmode, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_swappedTU", _wrap_SigmaProcess_swappedTU, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_id", _wrap_SigmaProcess_id, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_col", _wrap_SigmaProcess_col, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_acol", _wrap_SigmaProcess_acol, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_m", _wrap_SigmaProcess_m, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_getParton", _wrap_SigmaProcess_getParton, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_Q2Ren", _wrap_SigmaProcess_Q2Ren, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_alphaEMRen", _wrap_SigmaProcess_alphaEMRen, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_alphaSRen", _wrap_SigmaProcess_alphaSRen, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_Q2Fac", _wrap_SigmaProcess_Q2Fac, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_pdf1", _wrap_SigmaProcess_pdf1, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_pdf2", _wrap_SigmaProcess_pdf2, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_thetaMPI", _wrap_SigmaProcess_thetaMPI, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_phiMPI", _wrap_SigmaProcess_phiMPI, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_sHBetaMPI", _wrap_SigmaProcess_sHBetaMPI, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_pT2MPI", _wrap_SigmaProcess_pT2MPI, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_pTMPIFin", _wrap_SigmaProcess_pTMPIFin, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_saveKin", _wrap_SigmaProcess_saveKin, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_loadKin", _wrap_SigmaProcess_loadKin, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_swapKin", _wrap_SigmaProcess_swapKin, METH_VARARGS, NULL},
	 { (char *)"new_SigmaProcess", _wrap_new_SigmaProcess, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_infoPtr_set", _wrap_SigmaProcess_infoPtr_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_infoPtr_get", _wrap_SigmaProcess_infoPtr_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_settingsPtr_set", _wrap_SigmaProcess_settingsPtr_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_settingsPtr_get", _wrap_SigmaProcess_settingsPtr_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_particleDataPtr_set", _wrap_SigmaProcess_particleDataPtr_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_particleDataPtr_get", _wrap_SigmaProcess_particleDataPtr_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_rndmPtr_set", _wrap_SigmaProcess_rndmPtr_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_rndmPtr_get", _wrap_SigmaProcess_rndmPtr_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_beamAPtr_set", _wrap_SigmaProcess_beamAPtr_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_beamAPtr_get", _wrap_SigmaProcess_beamAPtr_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_beamBPtr_set", _wrap_SigmaProcess_beamBPtr_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_beamBPtr_get", _wrap_SigmaProcess_beamBPtr_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_couplingsPtr_set", _wrap_SigmaProcess_couplingsPtr_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_couplingsPtr_get", _wrap_SigmaProcess_couplingsPtr_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_sigmaTotPtr_set", _wrap_SigmaProcess_sigmaTotPtr_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_sigmaTotPtr_get", _wrap_SigmaProcess_sigmaTotPtr_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_slhaPtr_set", _wrap_SigmaProcess_slhaPtr_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_slhaPtr_get", _wrap_SigmaProcess_slhaPtr_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_lhaUpPtr_set", _wrap_SigmaProcess_lhaUpPtr_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_lhaUpPtr_get", _wrap_SigmaProcess_lhaUpPtr_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_nQuarkIn_set", _wrap_SigmaProcess_nQuarkIn_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_nQuarkIn_get", _wrap_SigmaProcess_nQuarkIn_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_renormScale1_set", _wrap_SigmaProcess_renormScale1_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_renormScale1_get", _wrap_SigmaProcess_renormScale1_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_renormScale2_set", _wrap_SigmaProcess_renormScale2_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_renormScale2_get", _wrap_SigmaProcess_renormScale2_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_renormScale3_set", _wrap_SigmaProcess_renormScale3_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_renormScale3_get", _wrap_SigmaProcess_renormScale3_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_renormScale3VV_set", _wrap_SigmaProcess_renormScale3VV_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_renormScale3VV_get", _wrap_SigmaProcess_renormScale3VV_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_factorScale1_set", _wrap_SigmaProcess_factorScale1_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_factorScale1_get", _wrap_SigmaProcess_factorScale1_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_factorScale2_set", _wrap_SigmaProcess_factorScale2_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_factorScale2_get", _wrap_SigmaProcess_factorScale2_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_factorScale3_set", _wrap_SigmaProcess_factorScale3_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_factorScale3_get", _wrap_SigmaProcess_factorScale3_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_factorScale3VV_set", _wrap_SigmaProcess_factorScale3VV_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_factorScale3VV_get", _wrap_SigmaProcess_factorScale3VV_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_Kfactor_set", _wrap_SigmaProcess_Kfactor_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_Kfactor_get", _wrap_SigmaProcess_Kfactor_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_mcME_set", _wrap_SigmaProcess_mcME_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_mcME_get", _wrap_SigmaProcess_mcME_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_mbME_set", _wrap_SigmaProcess_mbME_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_mbME_get", _wrap_SigmaProcess_mbME_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_mmuME_set", _wrap_SigmaProcess_mmuME_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_mmuME_get", _wrap_SigmaProcess_mmuME_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_mtauME_set", _wrap_SigmaProcess_mtauME_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_mtauME_get", _wrap_SigmaProcess_mtauME_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_renormMultFac_set", _wrap_SigmaProcess_renormMultFac_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_renormMultFac_get", _wrap_SigmaProcess_renormMultFac_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_renormFixScale_set", _wrap_SigmaProcess_renormFixScale_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_renormFixScale_get", _wrap_SigmaProcess_renormFixScale_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_factorMultFac_set", _wrap_SigmaProcess_factorMultFac_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_factorMultFac_get", _wrap_SigmaProcess_factorMultFac_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_factorFixScale_set", _wrap_SigmaProcess_factorFixScale_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_factorFixScale_get", _wrap_SigmaProcess_factorFixScale_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_higgsH1parity_set", _wrap_SigmaProcess_higgsH1parity_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_higgsH1parity_get", _wrap_SigmaProcess_higgsH1parity_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_higgsH2parity_set", _wrap_SigmaProcess_higgsH2parity_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_higgsH2parity_get", _wrap_SigmaProcess_higgsH2parity_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_higgsA3parity_set", _wrap_SigmaProcess_higgsA3parity_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_higgsA3parity_get", _wrap_SigmaProcess_higgsA3parity_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_higgsH1eta_set", _wrap_SigmaProcess_higgsH1eta_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_higgsH1eta_get", _wrap_SigmaProcess_higgsH1eta_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_higgsH2eta_set", _wrap_SigmaProcess_higgsH2eta_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_higgsH2eta_get", _wrap_SigmaProcess_higgsH2eta_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_higgsA3eta_set", _wrap_SigmaProcess_higgsA3eta_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_higgsA3eta_get", _wrap_SigmaProcess_higgsA3eta_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_higgsH1phi_set", _wrap_SigmaProcess_higgsH1phi_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_higgsH1phi_get", _wrap_SigmaProcess_higgsH1phi_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_higgsH2phi_set", _wrap_SigmaProcess_higgsH2phi_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_higgsH2phi_get", _wrap_SigmaProcess_higgsH2phi_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_higgsA3phi_set", _wrap_SigmaProcess_higgsA3phi_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_higgsA3phi_get", _wrap_SigmaProcess_higgsA3phi_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_idA_set", _wrap_SigmaProcess_idA_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_idA_get", _wrap_SigmaProcess_idA_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_idB_set", _wrap_SigmaProcess_idB_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_idB_get", _wrap_SigmaProcess_idB_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_mA_set", _wrap_SigmaProcess_mA_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_mA_get", _wrap_SigmaProcess_mA_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_mB_set", _wrap_SigmaProcess_mB_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_mB_get", _wrap_SigmaProcess_mB_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_isLeptonA_set", _wrap_SigmaProcess_isLeptonA_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_isLeptonA_get", _wrap_SigmaProcess_isLeptonA_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_isLeptonB_set", _wrap_SigmaProcess_isLeptonB_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_isLeptonB_get", _wrap_SigmaProcess_isLeptonB_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_hasLeptonBeams_set", _wrap_SigmaProcess_hasLeptonBeams_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_hasLeptonBeams_get", _wrap_SigmaProcess_hasLeptonBeams_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_lepton2gammaA_set", _wrap_SigmaProcess_lepton2gammaA_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_lepton2gammaA_get", _wrap_SigmaProcess_lepton2gammaA_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_lepton2gammaB_set", _wrap_SigmaProcess_lepton2gammaB_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_lepton2gammaB_get", _wrap_SigmaProcess_lepton2gammaB_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_inBeamA_set", _wrap_SigmaProcess_inBeamA_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_inBeamA_get", _wrap_SigmaProcess_inBeamA_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_inBeamB_set", _wrap_SigmaProcess_inBeamB_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_inBeamB_get", _wrap_SigmaProcess_inBeamB_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_addBeamA", _wrap_SigmaProcess_addBeamA, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_addBeamB", _wrap_SigmaProcess_addBeamB, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_sizeBeamA", _wrap_SigmaProcess_sizeBeamA, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_sizeBeamB", _wrap_SigmaProcess_sizeBeamB, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_inPair_set", _wrap_SigmaProcess_inPair_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_inPair_get", _wrap_SigmaProcess_inPair_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_addPair", _wrap_SigmaProcess_addPair, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_sizePair", _wrap_SigmaProcess_sizePair, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_mH_set", _wrap_SigmaProcess_mH_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_mH_get", _wrap_SigmaProcess_mH_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_sH_set", _wrap_SigmaProcess_sH_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_sH_get", _wrap_SigmaProcess_sH_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_sH2_set", _wrap_SigmaProcess_sH2_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_sH2_get", _wrap_SigmaProcess_sH2_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_Q2RenSave_set", _wrap_SigmaProcess_Q2RenSave_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_Q2RenSave_get", _wrap_SigmaProcess_Q2RenSave_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_alpEM_set", _wrap_SigmaProcess_alpEM_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_alpEM_get", _wrap_SigmaProcess_alpEM_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_alpS_set", _wrap_SigmaProcess_alpS_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_alpS_get", _wrap_SigmaProcess_alpS_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_Q2FacSave_set", _wrap_SigmaProcess_Q2FacSave_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_Q2FacSave_get", _wrap_SigmaProcess_Q2FacSave_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_x1Save_set", _wrap_SigmaProcess_x1Save_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_x1Save_get", _wrap_SigmaProcess_x1Save_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_x2Save_set", _wrap_SigmaProcess_x2Save_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_x2Save_get", _wrap_SigmaProcess_x2Save_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_pdf1Save_set", _wrap_SigmaProcess_pdf1Save_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_pdf1Save_get", _wrap_SigmaProcess_pdf1Save_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_pdf2Save_set", _wrap_SigmaProcess_pdf2Save_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_pdf2Save_get", _wrap_SigmaProcess_pdf2Save_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_sigmaSumSave_set", _wrap_SigmaProcess_sigmaSumSave_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_sigmaSumSave_get", _wrap_SigmaProcess_sigmaSumSave_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_id1_set", _wrap_SigmaProcess_id1_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_id1_get", _wrap_SigmaProcess_id1_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_id2_set", _wrap_SigmaProcess_id2_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_id2_get", _wrap_SigmaProcess_id2_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_id3_set", _wrap_SigmaProcess_id3_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_id3_get", _wrap_SigmaProcess_id3_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_id4_set", _wrap_SigmaProcess_id4_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_id4_get", _wrap_SigmaProcess_id4_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_id5_set", _wrap_SigmaProcess_id5_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_id5_get", _wrap_SigmaProcess_id5_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_idSave_set", _wrap_SigmaProcess_idSave_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_idSave_get", _wrap_SigmaProcess_idSave_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_colSave_set", _wrap_SigmaProcess_colSave_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_colSave_get", _wrap_SigmaProcess_colSave_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_acolSave_set", _wrap_SigmaProcess_acolSave_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_acolSave_get", _wrap_SigmaProcess_acolSave_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_mSave_set", _wrap_SigmaProcess_mSave_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_mSave_get", _wrap_SigmaProcess_mSave_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_cosTheta_set", _wrap_SigmaProcess_cosTheta_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_cosTheta_get", _wrap_SigmaProcess_cosTheta_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_sinTheta_set", _wrap_SigmaProcess_sinTheta_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_sinTheta_get", _wrap_SigmaProcess_sinTheta_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_phi_set", _wrap_SigmaProcess_phi_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_phi_get", _wrap_SigmaProcess_phi_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_sHMass_set", _wrap_SigmaProcess_sHMass_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_sHMass_get", _wrap_SigmaProcess_sHMass_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_sHBeta_set", _wrap_SigmaProcess_sHBeta_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_sHBeta_get", _wrap_SigmaProcess_sHBeta_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_pT2Mass_set", _wrap_SigmaProcess_pT2Mass_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_pT2Mass_get", _wrap_SigmaProcess_pT2Mass_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_pTFin_set", _wrap_SigmaProcess_pTFin_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_pTFin_get", _wrap_SigmaProcess_pTFin_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_parton_set", _wrap_SigmaProcess_parton_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_parton_get", _wrap_SigmaProcess_parton_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_partonT_set", _wrap_SigmaProcess_partonT_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_partonT_get", _wrap_SigmaProcess_partonT_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_mSaveT_set", _wrap_SigmaProcess_mSaveT_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_mSaveT_get", _wrap_SigmaProcess_mSaveT_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_pTFinT_set", _wrap_SigmaProcess_pTFinT_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_pTFinT_get", _wrap_SigmaProcess_pTFinT_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_cosThetaT_set", _wrap_SigmaProcess_cosThetaT_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_cosThetaT_get", _wrap_SigmaProcess_cosThetaT_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_sinThetaT_set", _wrap_SigmaProcess_sinThetaT_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_sinThetaT_get", _wrap_SigmaProcess_sinThetaT_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_phiT_set", _wrap_SigmaProcess_phiT_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_phiT_get", _wrap_SigmaProcess_phiT_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_setupForME", _wrap_SigmaProcess_setupForME, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_setupForMEin", _wrap_SigmaProcess_setupForMEin, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_mME_set", _wrap_SigmaProcess_mME_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_mME_get", _wrap_SigmaProcess_mME_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_pME_set", _wrap_SigmaProcess_pME_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_pME_get", _wrap_SigmaProcess_pME_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_swapTU_set", _wrap_SigmaProcess_swapTU_set, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_swapTU_get", _wrap_SigmaProcess_swapTU_get, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_setId", _wrap_SigmaProcess_setId, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_setColAcol", _wrap_SigmaProcess_setColAcol, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_swapColAcol", _wrap_SigmaProcess_swapColAcol, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_swapCol1234", _wrap_SigmaProcess_swapCol1234, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_swapCol12", _wrap_SigmaProcess_swapCol12, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_swapCol34", _wrap_SigmaProcess_swapCol34, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_weightTopDecay", _wrap_SigmaProcess_weightTopDecay, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_weightHiggsDecay", _wrap_SigmaProcess_weightHiggsDecay, METH_VARARGS, NULL},
	 { (char *)"disown_SigmaProcess", _wrap_disown_SigmaProcess, METH_VARARGS, NULL},
	 { (char *)"SigmaProcess_swigregister", SigmaProcess_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma0Process", _wrap_delete_Sigma0Process, METH_VARARGS, NULL},
	 { (char *)"Sigma0Process_nFinal", _wrap_Sigma0Process_nFinal, METH_VARARGS, NULL},
	 { (char *)"Sigma0Process_initFlux", _wrap_Sigma0Process_initFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma0Process_sigmaHat", _wrap_Sigma0Process_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma0Process_sigmaPDF", _wrap_Sigma0Process_sigmaPDF, METH_VARARGS, NULL},
	 { (char *)"Sigma0Process_convert2mb", _wrap_Sigma0Process_convert2mb, METH_VARARGS, NULL},
	 { (char *)"Sigma0Process_swigregister", Sigma0Process_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma1Process", _wrap_delete_Sigma1Process, METH_VARARGS, NULL},
	 { (char *)"Sigma1Process_nFinal", _wrap_Sigma1Process_nFinal, METH_VARARGS, NULL},
	 { (char *)"Sigma1Process_set1Kin", _wrap_Sigma1Process_set1Kin, METH_VARARGS, NULL},
	 { (char *)"Sigma1Process_sigmaHat", _wrap_Sigma1Process_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma1Process_sigmaHatWrap", _wrap_Sigma1Process_sigmaHatWrap, METH_VARARGS, NULL},
	 { (char *)"Sigma1Process_swigregister", Sigma1Process_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2Process", _wrap_delete_Sigma2Process, METH_VARARGS, NULL},
	 { (char *)"Sigma2Process_nFinal", _wrap_Sigma2Process_nFinal, METH_VARARGS, NULL},
	 { (char *)"Sigma2Process_set2Kin", _wrap_Sigma2Process_set2Kin, METH_VARARGS, NULL},
	 { (char *)"Sigma2Process_set2KinMPI", _wrap_Sigma2Process_set2KinMPI, METH_VARARGS, NULL},
	 { (char *)"Sigma2Process_sigmaHat", _wrap_Sigma2Process_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2Process_sigmaHatWrap", _wrap_Sigma2Process_sigmaHatWrap, METH_VARARGS, NULL},
	 { (char *)"Sigma2Process_final2KinMPI", _wrap_Sigma2Process_final2KinMPI, METH_VARARGS, NULL},
	 { (char *)"Sigma2Process_swigregister", Sigma2Process_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma3Process", _wrap_delete_Sigma3Process, METH_VARARGS, NULL},
	 { (char *)"Sigma3Process_nFinal", _wrap_Sigma3Process_nFinal, METH_VARARGS, NULL},
	 { (char *)"Sigma3Process_set3Kin", _wrap_Sigma3Process_set3Kin, METH_VARARGS, NULL},
	 { (char *)"Sigma3Process_sigmaHat", _wrap_Sigma3Process_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma3Process_swigregister", Sigma3Process_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SigmaLHAProcess", _wrap_new_SigmaLHAProcess, METH_VARARGS, NULL},
	 { (char *)"delete_SigmaLHAProcess", _wrap_delete_SigmaLHAProcess, METH_VARARGS, NULL},
	 { (char *)"SigmaLHAProcess_initFlux", _wrap_SigmaLHAProcess_initFlux, METH_VARARGS, NULL},
	 { (char *)"SigmaLHAProcess_sigmaPDF", _wrap_SigmaLHAProcess_sigmaPDF, METH_VARARGS, NULL},
	 { (char *)"SigmaLHAProcess_weightDecay", _wrap_SigmaLHAProcess_weightDecay, METH_VARARGS, NULL},
	 { (char *)"SigmaLHAProcess_setScale", _wrap_SigmaLHAProcess_setScale, METH_VARARGS, NULL},
	 { (char *)"SigmaLHAProcess_name", _wrap_SigmaLHAProcess_name, METH_VARARGS, NULL},
	 { (char *)"SigmaLHAProcess_code", _wrap_SigmaLHAProcess_code, METH_VARARGS, NULL},
	 { (char *)"SigmaLHAProcess_nFinal", _wrap_SigmaLHAProcess_nFinal, METH_VARARGS, NULL},
	 { (char *)"SigmaLHAProcess_convert2mb", _wrap_SigmaLHAProcess_convert2mb, METH_VARARGS, NULL},
	 { (char *)"SigmaLHAProcess_isLHA", _wrap_SigmaLHAProcess_isLHA, METH_VARARGS, NULL},
	 { (char *)"SigmaLHAProcess_allowNegativeSigma", _wrap_SigmaLHAProcess_allowNegativeSigma, METH_VARARGS, NULL},
	 { (char *)"SigmaLHAProcess_swigregister", SigmaLHAProcess_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma0nonDiffractive", _wrap_new_Sigma0nonDiffractive, METH_VARARGS, NULL},
	 { (char *)"Sigma0nonDiffractive_sigmaHat", _wrap_Sigma0nonDiffractive_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma0nonDiffractive_setIdColAcol", _wrap_Sigma0nonDiffractive_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma0nonDiffractive_name", _wrap_Sigma0nonDiffractive_name, METH_VARARGS, NULL},
	 { (char *)"Sigma0nonDiffractive_code", _wrap_Sigma0nonDiffractive_code, METH_VARARGS, NULL},
	 { (char *)"Sigma0nonDiffractive_isNonDiff", _wrap_Sigma0nonDiffractive_isNonDiff, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma0nonDiffractive", _wrap_delete_Sigma0nonDiffractive, METH_VARARGS, NULL},
	 { (char *)"Sigma0nonDiffractive_swigregister", Sigma0nonDiffractive_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma0AB2AB", _wrap_new_Sigma0AB2AB, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2AB_sigmaHat", _wrap_Sigma0AB2AB_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2AB_setIdColAcol", _wrap_Sigma0AB2AB_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2AB_name", _wrap_Sigma0AB2AB_name, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2AB_code", _wrap_Sigma0AB2AB_code, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2AB_isResolved", _wrap_Sigma0AB2AB_isResolved, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma0AB2AB", _wrap_delete_Sigma0AB2AB, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2AB_swigregister", Sigma0AB2AB_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma0AB2XB", _wrap_new_Sigma0AB2XB, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2XB_sigmaHat", _wrap_Sigma0AB2XB_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2XB_setIdColAcol", _wrap_Sigma0AB2XB_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2XB_name", _wrap_Sigma0AB2XB_name, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2XB_code", _wrap_Sigma0AB2XB_code, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2XB_isResolved", _wrap_Sigma0AB2XB_isResolved, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2XB_isDiffA", _wrap_Sigma0AB2XB_isDiffA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma0AB2XB", _wrap_delete_Sigma0AB2XB, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2XB_swigregister", Sigma0AB2XB_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma0AB2AX", _wrap_new_Sigma0AB2AX, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2AX_sigmaHat", _wrap_Sigma0AB2AX_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2AX_setIdColAcol", _wrap_Sigma0AB2AX_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2AX_name", _wrap_Sigma0AB2AX_name, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2AX_code", _wrap_Sigma0AB2AX_code, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2AX_isResolved", _wrap_Sigma0AB2AX_isResolved, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2AX_isDiffB", _wrap_Sigma0AB2AX_isDiffB, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma0AB2AX", _wrap_delete_Sigma0AB2AX, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2AX_swigregister", Sigma0AB2AX_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma0AB2XX", _wrap_new_Sigma0AB2XX, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2XX_sigmaHat", _wrap_Sigma0AB2XX_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2XX_setIdColAcol", _wrap_Sigma0AB2XX_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2XX_name", _wrap_Sigma0AB2XX_name, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2XX_code", _wrap_Sigma0AB2XX_code, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2XX_isResolved", _wrap_Sigma0AB2XX_isResolved, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2XX_isDiffA", _wrap_Sigma0AB2XX_isDiffA, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2XX_isDiffB", _wrap_Sigma0AB2XX_isDiffB, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma0AB2XX", _wrap_delete_Sigma0AB2XX, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2XX_swigregister", Sigma0AB2XX_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma0AB2AXB", _wrap_new_Sigma0AB2AXB, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2AXB_sigmaHat", _wrap_Sigma0AB2AXB_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2AXB_setIdColAcol", _wrap_Sigma0AB2AXB_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2AXB_name", _wrap_Sigma0AB2AXB_name, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2AXB_code", _wrap_Sigma0AB2AXB_code, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2AXB_nFinal", _wrap_Sigma0AB2AXB_nFinal, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2AXB_isResolved", _wrap_Sigma0AB2AXB_isResolved, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2AXB_isDiffC", _wrap_Sigma0AB2AXB_isDiffC, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma0AB2AXB", _wrap_delete_Sigma0AB2AXB, METH_VARARGS, NULL},
	 { (char *)"Sigma0AB2AXB_swigregister", Sigma0AB2AXB_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2gg2gg", _wrap_new_Sigma2gg2gg, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gg_sigmaKin", _wrap_Sigma2gg2gg_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gg_sigmaHat", _wrap_Sigma2gg2gg_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gg_setIdColAcol", _wrap_Sigma2gg2gg_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gg_name", _wrap_Sigma2gg2gg_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gg_code", _wrap_Sigma2gg2gg_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gg_inFlux", _wrap_Sigma2gg2gg_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2gg2gg", _wrap_delete_Sigma2gg2gg, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gg_swigregister", Sigma2gg2gg_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2gg2qqbar", _wrap_new_Sigma2gg2qqbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2qqbar_initProc", _wrap_Sigma2gg2qqbar_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2qqbar_sigmaKin", _wrap_Sigma2gg2qqbar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2qqbar_sigmaHat", _wrap_Sigma2gg2qqbar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2qqbar_setIdColAcol", _wrap_Sigma2gg2qqbar_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2qqbar_name", _wrap_Sigma2gg2qqbar_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2qqbar_code", _wrap_Sigma2gg2qqbar_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2qqbar_inFlux", _wrap_Sigma2gg2qqbar_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2gg2qqbar", _wrap_delete_Sigma2gg2qqbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2qqbar_swigregister", Sigma2gg2qqbar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qg2qg", _wrap_new_Sigma2qg2qg, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2qg_sigmaKin", _wrap_Sigma2qg2qg_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2qg_sigmaHat", _wrap_Sigma2qg2qg_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2qg_setIdColAcol", _wrap_Sigma2qg2qg_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2qg_name", _wrap_Sigma2qg2qg_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2qg_code", _wrap_Sigma2qg2qg_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2qg_inFlux", _wrap_Sigma2qg2qg_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qg2qg", _wrap_delete_Sigma2qg2qg, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2qg_swigregister", Sigma2qg2qg_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qq2qq", _wrap_new_Sigma2qq2qq, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2qq_sigmaKin", _wrap_Sigma2qq2qq_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2qq_sigmaHat", _wrap_Sigma2qq2qq_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2qq_setIdColAcol", _wrap_Sigma2qq2qq_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2qq_name", _wrap_Sigma2qq2qq_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2qq_code", _wrap_Sigma2qq2qq_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2qq_inFlux", _wrap_Sigma2qq2qq_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qq2qq", _wrap_delete_Sigma2qq2qq, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2qq_swigregister", Sigma2qq2qq_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2gg", _wrap_new_Sigma2qqbar2gg, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gg_sigmaKin", _wrap_Sigma2qqbar2gg_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gg_sigmaHat", _wrap_Sigma2qqbar2gg_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gg_setIdColAcol", _wrap_Sigma2qqbar2gg_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gg_name", _wrap_Sigma2qqbar2gg_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gg_code", _wrap_Sigma2qqbar2gg_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gg_inFlux", _wrap_Sigma2qqbar2gg_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2gg", _wrap_delete_Sigma2qqbar2gg, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gg_swigregister", Sigma2qqbar2gg_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2qqbarNew", _wrap_new_Sigma2qqbar2qqbarNew, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2qqbarNew_initProc", _wrap_Sigma2qqbar2qqbarNew_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2qqbarNew_sigmaKin", _wrap_Sigma2qqbar2qqbarNew_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2qqbarNew_sigmaHat", _wrap_Sigma2qqbar2qqbarNew_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2qqbarNew_setIdColAcol", _wrap_Sigma2qqbar2qqbarNew_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2qqbarNew_name", _wrap_Sigma2qqbar2qqbarNew_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2qqbarNew_code", _wrap_Sigma2qqbar2qqbarNew_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2qqbarNew_inFlux", _wrap_Sigma2qqbar2qqbarNew_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2qqbarNew", _wrap_delete_Sigma2qqbar2qqbarNew, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2qqbarNew_swigregister", Sigma2qqbar2qqbarNew_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2gg2QQbar", _wrap_new_Sigma2gg2QQbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar_initProc", _wrap_Sigma2gg2QQbar_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar_sigmaKin", _wrap_Sigma2gg2QQbar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar_sigmaHat", _wrap_Sigma2gg2QQbar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar_setIdColAcol", _wrap_Sigma2gg2QQbar_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar_weightDecay", _wrap_Sigma2gg2QQbar_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar_name", _wrap_Sigma2gg2QQbar_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar_code", _wrap_Sigma2gg2QQbar_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar_inFlux", _wrap_Sigma2gg2QQbar_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar_id3Mass", _wrap_Sigma2gg2QQbar_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar_id4Mass", _wrap_Sigma2gg2QQbar_id4Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2gg2QQbar", _wrap_delete_Sigma2gg2QQbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar_swigregister", Sigma2gg2QQbar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2QQbar", _wrap_new_Sigma2qqbar2QQbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbar_initProc", _wrap_Sigma2qqbar2QQbar_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbar_sigmaKin", _wrap_Sigma2qqbar2QQbar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbar_sigmaHat", _wrap_Sigma2qqbar2QQbar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbar_setIdColAcol", _wrap_Sigma2qqbar2QQbar_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbar_weightDecay", _wrap_Sigma2qqbar2QQbar_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbar_name", _wrap_Sigma2qqbar2QQbar_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbar_code", _wrap_Sigma2qqbar2QQbar_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbar_inFlux", _wrap_Sigma2qqbar2QQbar_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbar_id3Mass", _wrap_Sigma2qqbar2QQbar_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbar_id4Mass", _wrap_Sigma2qqbar2QQbar_id4Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2QQbar", _wrap_delete_Sigma2qqbar2QQbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbar_swigregister", Sigma2qqbar2QQbar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma3gg2ggg", _wrap_new_Sigma3gg2ggg, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2ggg_sigmaKin", _wrap_Sigma3gg2ggg_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2ggg_sigmaHat", _wrap_Sigma3gg2ggg_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2ggg_setIdColAcol", _wrap_Sigma3gg2ggg_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2ggg_name", _wrap_Sigma3gg2ggg_name, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2ggg_code", _wrap_Sigma3gg2ggg_code, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2ggg_nFinal", _wrap_Sigma3gg2ggg_nFinal, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2ggg_inFlux", _wrap_Sigma3gg2ggg_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2ggg_isQCD3body", _wrap_Sigma3gg2ggg_isQCD3body, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma3gg2ggg", _wrap_delete_Sigma3gg2ggg, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2ggg_swigregister", Sigma3gg2ggg_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma3qqbar2ggg", _wrap_new_Sigma3qqbar2ggg, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2ggg_sigmaKin", _wrap_Sigma3qqbar2ggg_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2ggg_sigmaHat", _wrap_Sigma3qqbar2ggg_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2ggg_setIdColAcol", _wrap_Sigma3qqbar2ggg_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2ggg_name", _wrap_Sigma3qqbar2ggg_name, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2ggg_code", _wrap_Sigma3qqbar2ggg_code, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2ggg_nFinal", _wrap_Sigma3qqbar2ggg_nFinal, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2ggg_inFlux", _wrap_Sigma3qqbar2ggg_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2ggg_isQCD3body", _wrap_Sigma3qqbar2ggg_isQCD3body, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma3qqbar2ggg", _wrap_delete_Sigma3qqbar2ggg, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2ggg_swigregister", Sigma3qqbar2ggg_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma3qg2qgg", _wrap_new_Sigma3qg2qgg, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qgg_sigmaKin", _wrap_Sigma3qg2qgg_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qgg_sigmaHat", _wrap_Sigma3qg2qgg_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qgg_setIdColAcol", _wrap_Sigma3qg2qgg_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qgg_name", _wrap_Sigma3qg2qgg_name, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qgg_code", _wrap_Sigma3qg2qgg_code, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qgg_nFinal", _wrap_Sigma3qg2qgg_nFinal, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qgg_inFlux", _wrap_Sigma3qg2qgg_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qgg_isQCD3body", _wrap_Sigma3qg2qgg_isQCD3body, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma3qg2qgg", _wrap_delete_Sigma3qg2qgg, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qgg_swigregister", Sigma3qg2qgg_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma3gg2qqbarg", _wrap_new_Sigma3gg2qqbarg, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2qqbarg_initProc", _wrap_Sigma3gg2qqbarg_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2qqbarg_sigmaKin", _wrap_Sigma3gg2qqbarg_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2qqbarg_setIdColAcol", _wrap_Sigma3gg2qqbarg_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2qqbarg_name", _wrap_Sigma3gg2qqbarg_name, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2qqbarg_code", _wrap_Sigma3gg2qqbarg_code, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2qqbarg_nFinal", _wrap_Sigma3gg2qqbarg_nFinal, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2qqbarg_inFlux", _wrap_Sigma3gg2qqbarg_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2qqbarg_isQCD3body", _wrap_Sigma3gg2qqbarg_isQCD3body, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma3gg2qqbarg", _wrap_delete_Sigma3gg2qqbarg, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2qqbarg_swigregister", Sigma3gg2qqbarg_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma3qq2qqgDiff", _wrap_new_Sigma3qq2qqgDiff, METH_VARARGS, NULL},
	 { (char *)"Sigma3qq2qqgDiff_sigmaKin", _wrap_Sigma3qq2qqgDiff_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma3qq2qqgDiff_sigmaHat", _wrap_Sigma3qq2qqgDiff_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma3qq2qqgDiff_setIdColAcol", _wrap_Sigma3qq2qqgDiff_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma3qq2qqgDiff_name", _wrap_Sigma3qq2qqgDiff_name, METH_VARARGS, NULL},
	 { (char *)"Sigma3qq2qqgDiff_code", _wrap_Sigma3qq2qqgDiff_code, METH_VARARGS, NULL},
	 { (char *)"Sigma3qq2qqgDiff_nFinal", _wrap_Sigma3qq2qqgDiff_nFinal, METH_VARARGS, NULL},
	 { (char *)"Sigma3qq2qqgDiff_inFlux", _wrap_Sigma3qq2qqgDiff_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma3qq2qqgDiff_isQCD3body", _wrap_Sigma3qq2qqgDiff_isQCD3body, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma3qq2qqgDiff", _wrap_delete_Sigma3qq2qqgDiff, METH_VARARGS, NULL},
	 { (char *)"Sigma3qq2qqgDiff_swigregister", Sigma3qq2qqgDiff_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma3qqbar2qqbargDiff", _wrap_new_Sigma3qqbar2qqbargDiff, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2qqbargDiff_initProc", _wrap_Sigma3qqbar2qqbargDiff_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2qqbargDiff_sigmaKin", _wrap_Sigma3qqbar2qqbargDiff_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2qqbargDiff_sigmaHat", _wrap_Sigma3qqbar2qqbargDiff_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2qqbargDiff_setIdColAcol", _wrap_Sigma3qqbar2qqbargDiff_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2qqbargDiff_name", _wrap_Sigma3qqbar2qqbargDiff_name, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2qqbargDiff_code", _wrap_Sigma3qqbar2qqbargDiff_code, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2qqbargDiff_nFinal", _wrap_Sigma3qqbar2qqbargDiff_nFinal, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2qqbargDiff_inFlux", _wrap_Sigma3qqbar2qqbargDiff_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2qqbargDiff_isQCD3body", _wrap_Sigma3qqbar2qqbargDiff_isQCD3body, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma3qqbar2qqbargDiff", _wrap_delete_Sigma3qqbar2qqbargDiff, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2qqbargDiff_swigregister", Sigma3qqbar2qqbargDiff_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma3qg2qqqbarDiff", _wrap_new_Sigma3qg2qqqbarDiff, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qqqbarDiff_initProc", _wrap_Sigma3qg2qqqbarDiff_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qqqbarDiff_sigmaKin", _wrap_Sigma3qg2qqqbarDiff_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qqqbarDiff_sigmaHat", _wrap_Sigma3qg2qqqbarDiff_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qqqbarDiff_setIdColAcol", _wrap_Sigma3qg2qqqbarDiff_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qqqbarDiff_name", _wrap_Sigma3qg2qqqbarDiff_name, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qqqbarDiff_code", _wrap_Sigma3qg2qqqbarDiff_code, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qqqbarDiff_nFinal", _wrap_Sigma3qg2qqqbarDiff_nFinal, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qqqbarDiff_inFlux", _wrap_Sigma3qg2qqqbarDiff_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qqqbarDiff_isQCD3body", _wrap_Sigma3qg2qqqbarDiff_isQCD3body, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma3qg2qqqbarDiff", _wrap_delete_Sigma3qg2qqqbarDiff, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qqqbarDiff_swigregister", Sigma3qg2qqqbarDiff_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma3qq2qqgSame", _wrap_new_Sigma3qq2qqgSame, METH_VARARGS, NULL},
	 { (char *)"Sigma3qq2qqgSame_sigmaKin", _wrap_Sigma3qq2qqgSame_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma3qq2qqgSame_sigmaHat", _wrap_Sigma3qq2qqgSame_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma3qq2qqgSame_setIdColAcol", _wrap_Sigma3qq2qqgSame_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma3qq2qqgSame_name", _wrap_Sigma3qq2qqgSame_name, METH_VARARGS, NULL},
	 { (char *)"Sigma3qq2qqgSame_code", _wrap_Sigma3qq2qqgSame_code, METH_VARARGS, NULL},
	 { (char *)"Sigma3qq2qqgSame_nFinal", _wrap_Sigma3qq2qqgSame_nFinal, METH_VARARGS, NULL},
	 { (char *)"Sigma3qq2qqgSame_inFlux", _wrap_Sigma3qq2qqgSame_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma3qq2qqgSame_isQCD3body", _wrap_Sigma3qq2qqgSame_isQCD3body, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma3qq2qqgSame", _wrap_delete_Sigma3qq2qqgSame, METH_VARARGS, NULL},
	 { (char *)"Sigma3qq2qqgSame_swigregister", Sigma3qq2qqgSame_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma3qqbar2qqbargSame", _wrap_new_Sigma3qqbar2qqbargSame, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2qqbargSame_sigmaKin", _wrap_Sigma3qqbar2qqbargSame_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2qqbargSame_sigmaHat", _wrap_Sigma3qqbar2qqbargSame_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2qqbargSame_setIdColAcol", _wrap_Sigma3qqbar2qqbargSame_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2qqbargSame_name", _wrap_Sigma3qqbar2qqbargSame_name, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2qqbargSame_code", _wrap_Sigma3qqbar2qqbargSame_code, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2qqbargSame_nFinal", _wrap_Sigma3qqbar2qqbargSame_nFinal, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2qqbargSame_inFlux", _wrap_Sigma3qqbar2qqbargSame_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2qqbargSame_isQCD3body", _wrap_Sigma3qqbar2qqbargSame_isQCD3body, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma3qqbar2qqbargSame", _wrap_delete_Sigma3qqbar2qqbargSame, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2qqbargSame_swigregister", Sigma3qqbar2qqbargSame_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma3qg2qqqbarSame", _wrap_new_Sigma3qg2qqqbarSame, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qqqbarSame_sigmaKin", _wrap_Sigma3qg2qqqbarSame_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qqqbarSame_sigmaHat", _wrap_Sigma3qg2qqqbarSame_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qqqbarSame_setIdColAcol", _wrap_Sigma3qg2qqqbarSame_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qqqbarSame_name", _wrap_Sigma3qg2qqqbarSame_name, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qqqbarSame_code", _wrap_Sigma3qg2qqqbarSame_code, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qqqbarSame_nFinal", _wrap_Sigma3qg2qqqbarSame_nFinal, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qqqbarSame_inFlux", _wrap_Sigma3qg2qqqbarSame_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qqqbarSame_isQCD3body", _wrap_Sigma3qg2qqqbarSame_isQCD3body, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma3qg2qqqbarSame", _wrap_delete_Sigma3qg2qqqbarSame, METH_VARARGS, NULL},
	 { (char *)"Sigma3qg2qqqbarSame_swigregister", Sigma3qg2qqqbarSame_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_UserHooks", _wrap_delete_UserHooks, METH_VARARGS, NULL},
	 { (char *)"UserHooks_initPtr", _wrap_UserHooks_initPtr, METH_VARARGS, NULL},
	 { (char *)"UserHooks_initAfterBeams", _wrap_UserHooks_initAfterBeams, METH_VARARGS, NULL},
	 { (char *)"UserHooks_canModifySigma", _wrap_UserHooks_canModifySigma, METH_VARARGS, NULL},
	 { (char *)"UserHooks_multiplySigmaBy", _wrap_UserHooks_multiplySigmaBy, METH_VARARGS, NULL},
	 { (char *)"UserHooks_canBiasSelection", _wrap_UserHooks_canBiasSelection, METH_VARARGS, NULL},
	 { (char *)"UserHooks_biasSelectionBy", _wrap_UserHooks_biasSelectionBy, METH_VARARGS, NULL},
	 { (char *)"UserHooks_biasedSelectionWeight", _wrap_UserHooks_biasedSelectionWeight, METH_VARARGS, NULL},
	 { (char *)"UserHooks_canVetoProcessLevel", _wrap_UserHooks_canVetoProcessLevel, METH_VARARGS, NULL},
	 { (char *)"UserHooks_doVetoProcessLevel", _wrap_UserHooks_doVetoProcessLevel, METH_VARARGS, NULL},
	 { (char *)"UserHooks_canVetoResonanceDecays", _wrap_UserHooks_canVetoResonanceDecays, METH_VARARGS, NULL},
	 { (char *)"UserHooks_doVetoResonanceDecays", _wrap_UserHooks_doVetoResonanceDecays, METH_VARARGS, NULL},
	 { (char *)"UserHooks_canVetoPT", _wrap_UserHooks_canVetoPT, METH_VARARGS, NULL},
	 { (char *)"UserHooks_scaleVetoPT", _wrap_UserHooks_scaleVetoPT, METH_VARARGS, NULL},
	 { (char *)"UserHooks_doVetoPT", _wrap_UserHooks_doVetoPT, METH_VARARGS, NULL},
	 { (char *)"UserHooks_canVetoStep", _wrap_UserHooks_canVetoStep, METH_VARARGS, NULL},
	 { (char *)"UserHooks_numberVetoStep", _wrap_UserHooks_numberVetoStep, METH_VARARGS, NULL},
	 { (char *)"UserHooks_doVetoStep", _wrap_UserHooks_doVetoStep, METH_VARARGS, NULL},
	 { (char *)"UserHooks_canVetoMPIStep", _wrap_UserHooks_canVetoMPIStep, METH_VARARGS, NULL},
	 { (char *)"UserHooks_numberVetoMPIStep", _wrap_UserHooks_numberVetoMPIStep, METH_VARARGS, NULL},
	 { (char *)"UserHooks_doVetoMPIStep", _wrap_UserHooks_doVetoMPIStep, METH_VARARGS, NULL},
	 { (char *)"UserHooks_canVetoPartonLevelEarly", _wrap_UserHooks_canVetoPartonLevelEarly, METH_VARARGS, NULL},
	 { (char *)"UserHooks_doVetoPartonLevelEarly", _wrap_UserHooks_doVetoPartonLevelEarly, METH_VARARGS, NULL},
	 { (char *)"UserHooks_retryPartonLevel", _wrap_UserHooks_retryPartonLevel, METH_VARARGS, NULL},
	 { (char *)"UserHooks_canVetoPartonLevel", _wrap_UserHooks_canVetoPartonLevel, METH_VARARGS, NULL},
	 { (char *)"UserHooks_doVetoPartonLevel", _wrap_UserHooks_doVetoPartonLevel, METH_VARARGS, NULL},
	 { (char *)"UserHooks_canSetResonanceScale", _wrap_UserHooks_canSetResonanceScale, METH_VARARGS, NULL},
	 { (char *)"UserHooks_scaleResonance", _wrap_UserHooks_scaleResonance, METH_VARARGS, NULL},
	 { (char *)"UserHooks_canVetoISREmission", _wrap_UserHooks_canVetoISREmission, METH_VARARGS, NULL},
	 { (char *)"UserHooks_doVetoISREmission", _wrap_UserHooks_doVetoISREmission, METH_VARARGS, NULL},
	 { (char *)"UserHooks_canVetoFSREmission", _wrap_UserHooks_canVetoFSREmission, METH_VARARGS, NULL},
	 { (char *)"UserHooks_doVetoFSREmission", _wrap_UserHooks_doVetoFSREmission, METH_VARARGS, NULL},
	 { (char *)"UserHooks_canVetoMPIEmission", _wrap_UserHooks_canVetoMPIEmission, METH_VARARGS, NULL},
	 { (char *)"UserHooks_doVetoMPIEmission", _wrap_UserHooks_doVetoMPIEmission, METH_VARARGS, NULL},
	 { (char *)"UserHooks_canReconnectResonanceSystems", _wrap_UserHooks_canReconnectResonanceSystems, METH_VARARGS, NULL},
	 { (char *)"UserHooks_doReconnectResonanceSystems", _wrap_UserHooks_doReconnectResonanceSystems, METH_VARARGS, NULL},
	 { (char *)"UserHooks_canEnhanceEmission", _wrap_UserHooks_canEnhanceEmission, METH_VARARGS, NULL},
	 { (char *)"UserHooks_enhanceFactor", _wrap_UserHooks_enhanceFactor, METH_VARARGS, NULL},
	 { (char *)"UserHooks_vetoProbability", _wrap_UserHooks_vetoProbability, METH_VARARGS, NULL},
	 { (char *)"UserHooks_setEnhancedEventWeight", _wrap_UserHooks_setEnhancedEventWeight, METH_VARARGS, NULL},
	 { (char *)"UserHooks_getEnhancedEventWeight", _wrap_UserHooks_getEnhancedEventWeight, METH_VARARGS, NULL},
	 { (char *)"UserHooks_canEnhanceTrial", _wrap_UserHooks_canEnhanceTrial, METH_VARARGS, NULL},
	 { (char *)"UserHooks_setEnhancedTrial", _wrap_UserHooks_setEnhancedTrial, METH_VARARGS, NULL},
	 { (char *)"UserHooks_getEnhancedTrialPT", _wrap_UserHooks_getEnhancedTrialPT, METH_VARARGS, NULL},
	 { (char *)"UserHooks_getEnhancedTrialWeight", _wrap_UserHooks_getEnhancedTrialWeight, METH_VARARGS, NULL},
	 { (char *)"UserHooks_canChangeFragPar", _wrap_UserHooks_canChangeFragPar, METH_VARARGS, NULL},
	 { (char *)"UserHooks_doChangeFragPar", _wrap_UserHooks_doChangeFragPar, METH_VARARGS, NULL},
	 { (char *)"UserHooks_doVetoFragmentation", _wrap_UserHooks_doVetoFragmentation, METH_VARARGS, NULL},
	 { (char *)"UserHooks_canSetImpactParameter", _wrap_UserHooks_canSetImpactParameter, METH_VARARGS, NULL},
	 { (char *)"UserHooks_doSetImpactParameter", _wrap_UserHooks_doSetImpactParameter, METH_VARARGS, NULL},
	 { (char *)"new_UserHooks", _wrap_new_UserHooks, METH_VARARGS, NULL},
	 { (char *)"UserHooks_infoPtr_set", _wrap_UserHooks_infoPtr_set, METH_VARARGS, NULL},
	 { (char *)"UserHooks_infoPtr_get", _wrap_UserHooks_infoPtr_get, METH_VARARGS, NULL},
	 { (char *)"UserHooks_settingsPtr_set", _wrap_UserHooks_settingsPtr_set, METH_VARARGS, NULL},
	 { (char *)"UserHooks_settingsPtr_get", _wrap_UserHooks_settingsPtr_get, METH_VARARGS, NULL},
	 { (char *)"UserHooks_particleDataPtr_set", _wrap_UserHooks_particleDataPtr_set, METH_VARARGS, NULL},
	 { (char *)"UserHooks_particleDataPtr_get", _wrap_UserHooks_particleDataPtr_get, METH_VARARGS, NULL},
	 { (char *)"UserHooks_rndmPtr_set", _wrap_UserHooks_rndmPtr_set, METH_VARARGS, NULL},
	 { (char *)"UserHooks_rndmPtr_get", _wrap_UserHooks_rndmPtr_get, METH_VARARGS, NULL},
	 { (char *)"UserHooks_beamAPtr_set", _wrap_UserHooks_beamAPtr_set, METH_VARARGS, NULL},
	 { (char *)"UserHooks_beamAPtr_get", _wrap_UserHooks_beamAPtr_get, METH_VARARGS, NULL},
	 { (char *)"UserHooks_beamBPtr_set", _wrap_UserHooks_beamBPtr_set, METH_VARARGS, NULL},
	 { (char *)"UserHooks_beamBPtr_get", _wrap_UserHooks_beamBPtr_get, METH_VARARGS, NULL},
	 { (char *)"UserHooks_beamPomAPtr_set", _wrap_UserHooks_beamPomAPtr_set, METH_VARARGS, NULL},
	 { (char *)"UserHooks_beamPomAPtr_get", _wrap_UserHooks_beamPomAPtr_get, METH_VARARGS, NULL},
	 { (char *)"UserHooks_beamPomBPtr_set", _wrap_UserHooks_beamPomBPtr_set, METH_VARARGS, NULL},
	 { (char *)"UserHooks_beamPomBPtr_get", _wrap_UserHooks_beamPomBPtr_get, METH_VARARGS, NULL},
	 { (char *)"UserHooks_coupSMPtr_set", _wrap_UserHooks_coupSMPtr_set, METH_VARARGS, NULL},
	 { (char *)"UserHooks_coupSMPtr_get", _wrap_UserHooks_coupSMPtr_get, METH_VARARGS, NULL},
	 { (char *)"UserHooks_partonSystemsPtr_set", _wrap_UserHooks_partonSystemsPtr_set, METH_VARARGS, NULL},
	 { (char *)"UserHooks_partonSystemsPtr_get", _wrap_UserHooks_partonSystemsPtr_get, METH_VARARGS, NULL},
	 { (char *)"UserHooks_sigmaTotPtr_set", _wrap_UserHooks_sigmaTotPtr_set, METH_VARARGS, NULL},
	 { (char *)"UserHooks_sigmaTotPtr_get", _wrap_UserHooks_sigmaTotPtr_get, METH_VARARGS, NULL},
	 { (char *)"UserHooks_omitResonanceDecays", _wrap_UserHooks_omitResonanceDecays, METH_VARARGS, NULL},
	 { (char *)"UserHooks_subEvent", _wrap_UserHooks_subEvent, METH_VARARGS, NULL},
	 { (char *)"UserHooks_workEvent_set", _wrap_UserHooks_workEvent_set, METH_VARARGS, NULL},
	 { (char *)"UserHooks_workEvent_get", _wrap_UserHooks_workEvent_get, METH_VARARGS, NULL},
	 { (char *)"UserHooks_selBias_set", _wrap_UserHooks_selBias_set, METH_VARARGS, NULL},
	 { (char *)"UserHooks_selBias_get", _wrap_UserHooks_selBias_get, METH_VARARGS, NULL},
	 { (char *)"UserHooks_enhancedEventWeight_set", _wrap_UserHooks_enhancedEventWeight_set, METH_VARARGS, NULL},
	 { (char *)"UserHooks_enhancedEventWeight_get", _wrap_UserHooks_enhancedEventWeight_get, METH_VARARGS, NULL},
	 { (char *)"UserHooks_pTEnhanced_set", _wrap_UserHooks_pTEnhanced_set, METH_VARARGS, NULL},
	 { (char *)"UserHooks_pTEnhanced_get", _wrap_UserHooks_pTEnhanced_get, METH_VARARGS, NULL},
	 { (char *)"UserHooks_wtEnhanced_set", _wrap_UserHooks_wtEnhanced_set, METH_VARARGS, NULL},
	 { (char *)"UserHooks_wtEnhanced_get", _wrap_UserHooks_wtEnhanced_get, METH_VARARGS, NULL},
	 { (char *)"disown_UserHooks", _wrap_disown_UserHooks, METH_VARARGS, NULL},
	 { (char *)"UserHooks_swigregister", UserHooks_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SuppressSmallPT", _wrap_new_SuppressSmallPT, METH_VARARGS, NULL},
	 { (char *)"SuppressSmallPT_canModifySigma", _wrap_SuppressSmallPT_canModifySigma, METH_VARARGS, NULL},
	 { (char *)"SuppressSmallPT_multiplySigmaBy", _wrap_SuppressSmallPT_multiplySigmaBy, METH_VARARGS, NULL},
	 { (char *)"delete_SuppressSmallPT", _wrap_delete_SuppressSmallPT, METH_VARARGS, NULL},
	 { (char *)"SuppressSmallPT_swigregister", SuppressSmallPT_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_UserHooksVector", _wrap_delete_UserHooksVector, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_initAfterBeams", _wrap_UserHooksVector_initAfterBeams, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_canModifySigma", _wrap_UserHooksVector_canModifySigma, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_multiplySigmaBy", _wrap_UserHooksVector_multiplySigmaBy, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_canBiasSelection", _wrap_UserHooksVector_canBiasSelection, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_biasSelectionBy", _wrap_UserHooksVector_biasSelectionBy, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_biasedSelectionWeight", _wrap_UserHooksVector_biasedSelectionWeight, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_canVetoProcessLevel", _wrap_UserHooksVector_canVetoProcessLevel, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_doVetoProcessLevel", _wrap_UserHooksVector_doVetoProcessLevel, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_canVetoResonanceDecays", _wrap_UserHooksVector_canVetoResonanceDecays, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_doVetoResonanceDecays", _wrap_UserHooksVector_doVetoResonanceDecays, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_canVetoPT", _wrap_UserHooksVector_canVetoPT, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_scaleVetoPT", _wrap_UserHooksVector_scaleVetoPT, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_doVetoPT", _wrap_UserHooksVector_doVetoPT, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_canVetoStep", _wrap_UserHooksVector_canVetoStep, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_numberVetoStep", _wrap_UserHooksVector_numberVetoStep, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_doVetoStep", _wrap_UserHooksVector_doVetoStep, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_canVetoMPIStep", _wrap_UserHooksVector_canVetoMPIStep, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_numberVetoMPIStep", _wrap_UserHooksVector_numberVetoMPIStep, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_doVetoMPIStep", _wrap_UserHooksVector_doVetoMPIStep, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_canVetoPartonLevelEarly", _wrap_UserHooksVector_canVetoPartonLevelEarly, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_doVetoPartonLevelEarly", _wrap_UserHooksVector_doVetoPartonLevelEarly, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_retryPartonLevel", _wrap_UserHooksVector_retryPartonLevel, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_canVetoPartonLevel", _wrap_UserHooksVector_canVetoPartonLevel, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_doVetoPartonLevel", _wrap_UserHooksVector_doVetoPartonLevel, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_canSetResonanceScale", _wrap_UserHooksVector_canSetResonanceScale, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_scaleResonance", _wrap_UserHooksVector_scaleResonance, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_canVetoISREmission", _wrap_UserHooksVector_canVetoISREmission, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_doVetoISREmission", _wrap_UserHooksVector_doVetoISREmission, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_canVetoFSREmission", _wrap_UserHooksVector_canVetoFSREmission, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_doVetoFSREmission", _wrap_UserHooksVector_doVetoFSREmission, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_canVetoMPIEmission", _wrap_UserHooksVector_canVetoMPIEmission, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_doVetoMPIEmission", _wrap_UserHooksVector_doVetoMPIEmission, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_canReconnectResonanceSystems", _wrap_UserHooksVector_canReconnectResonanceSystems, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_doReconnectResonanceSystems", _wrap_UserHooksVector_doReconnectResonanceSystems, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_canEnhanceEmission", _wrap_UserHooksVector_canEnhanceEmission, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_enhanceFactor", _wrap_UserHooksVector_enhanceFactor, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_vetoProbability", _wrap_UserHooksVector_vetoProbability, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_canEnhanceTrial", _wrap_UserHooksVector_canEnhanceTrial, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_canChangeFragPar", _wrap_UserHooksVector_canChangeFragPar, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_canSetImpactParameter", _wrap_UserHooksVector_canSetImpactParameter, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_doSetImpactParameter", _wrap_UserHooksVector_doSetImpactParameter, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_hooks_set", _wrap_UserHooksVector_hooks_set, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_hooks_get", _wrap_UserHooksVector_hooks_get, METH_VARARGS, NULL},
	 { (char *)"UserHooksVector_swigregister", UserHooksVector_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SigmaMultiparton", _wrap_new_SigmaMultiparton, METH_VARARGS, NULL},
	 { (char *)"delete_SigmaMultiparton", _wrap_delete_SigmaMultiparton, METH_VARARGS, NULL},
	 { (char *)"SigmaMultiparton_init", _wrap_SigmaMultiparton_init, METH_VARARGS, NULL},
	 { (char *)"SigmaMultiparton_sigma", _wrap_SigmaMultiparton_sigma, METH_VARARGS, NULL},
	 { (char *)"SigmaMultiparton_pickedOther", _wrap_SigmaMultiparton_pickedOther, METH_VARARGS, NULL},
	 { (char *)"SigmaMultiparton_sigmaSel", _wrap_SigmaMultiparton_sigmaSel, METH_VARARGS, NULL},
	 { (char *)"SigmaMultiparton_swapTU", _wrap_SigmaMultiparton_swapTU, METH_VARARGS, NULL},
	 { (char *)"SigmaMultiparton_nProc", _wrap_SigmaMultiparton_nProc, METH_VARARGS, NULL},
	 { (char *)"SigmaMultiparton_codeProc", _wrap_SigmaMultiparton_codeProc, METH_VARARGS, NULL},
	 { (char *)"SigmaMultiparton_nameProc", _wrap_SigmaMultiparton_nameProc, METH_VARARGS, NULL},
	 { (char *)"SigmaMultiparton_swigregister", SigmaMultiparton_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MultipartonInteractions", _wrap_new_MultipartonInteractions, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_init", _wrap_MultipartonInteractions_init, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_reset", _wrap_MultipartonInteractions_reset, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_pTfirst", _wrap_MultipartonInteractions_pTfirst, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_setupFirstSys", _wrap_MultipartonInteractions_setupFirstSys, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_limitPTmax", _wrap_MultipartonInteractions_limitPTmax, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_scaleLimitPT", _wrap_MultipartonInteractions_scaleLimitPT, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_prepare", _wrap_MultipartonInteractions_prepare, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_pTnext", _wrap_MultipartonInteractions_pTnext, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_scatter", _wrap_MultipartonInteractions_scatter, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_setEmpty", _wrap_MultipartonInteractions_setEmpty, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_Q2Ren", _wrap_MultipartonInteractions_Q2Ren, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_alphaSH", _wrap_MultipartonInteractions_alphaSH, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_alphaEMH", _wrap_MultipartonInteractions_alphaEMH, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_x1H", _wrap_MultipartonInteractions_x1H, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_x2H", _wrap_MultipartonInteractions_x2H, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_Q2Fac", _wrap_MultipartonInteractions_Q2Fac, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_pdf1", _wrap_MultipartonInteractions_pdf1, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_pdf2", _wrap_MultipartonInteractions_pdf2, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_bMPI", _wrap_MultipartonInteractions_bMPI, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_enhanceMPI", _wrap_MultipartonInteractions_enhanceMPI, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_enhanceMPIavg", _wrap_MultipartonInteractions_enhanceMPIavg, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_getVSC1", _wrap_MultipartonInteractions_getVSC1, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_getVSC2", _wrap_MultipartonInteractions_getVSC2, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_getBeamOffset", _wrap_MultipartonInteractions_getBeamOffset, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_setBeamOffset", _wrap_MultipartonInteractions_setBeamOffset, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_accumulate", _wrap_MultipartonInteractions_accumulate, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_statistics", _wrap_MultipartonInteractions_statistics, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_resetStatistics", _wrap_MultipartonInteractions_resetStatistics, METH_VARARGS, NULL},
	 { (char *)"delete_MultipartonInteractions", _wrap_delete_MultipartonInteractions, METH_VARARGS, NULL},
	 { (char *)"MultipartonInteractions_swigregister", MultipartonInteractions_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_PhaseSpace", _wrap_delete_PhaseSpace, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_init", _wrap_PhaseSpace_init, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_newECM", _wrap_PhaseSpace_newECM, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_setLHAPtr", _wrap_PhaseSpace_setLHAPtr, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_setupSampling", _wrap_PhaseSpace_setupSampling, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_trialKin", _wrap_PhaseSpace_trialKin, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_finalKin", _wrap_PhaseSpace_finalKin, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_decayKinematics", _wrap_PhaseSpace_decayKinematics, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sigmaNow", _wrap_PhaseSpace_sigmaNow, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sigmaMax", _wrap_PhaseSpace_sigmaMax, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_biasSelectionWeight", _wrap_PhaseSpace_biasSelectionWeight, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_newSigmaMax", _wrap_PhaseSpace_newSigmaMax, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_setSigmaMax", _wrap_PhaseSpace_setSigmaMax, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sigmaSumSigned", _wrap_PhaseSpace_sigmaSumSigned, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_p", _wrap_PhaseSpace_p, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_m", _wrap_PhaseSpace_m, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_setP", _wrap_PhaseSpace_setP, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_ecm", _wrap_PhaseSpace_ecm, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_x1", _wrap_PhaseSpace_x1, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_x2", _wrap_PhaseSpace_x2, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sHat", _wrap_PhaseSpace_sHat, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_tHat", _wrap_PhaseSpace_tHat, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_uHat", _wrap_PhaseSpace_uHat, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_pTHat", _wrap_PhaseSpace_pTHat, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_thetaHat", _wrap_PhaseSpace_thetaHat, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_phiHat", _wrap_PhaseSpace_phiHat, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_runBW3", _wrap_PhaseSpace_runBW3, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_runBW4", _wrap_PhaseSpace_runBW4, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_runBW5", _wrap_PhaseSpace_runBW5, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_isResolved", _wrap_PhaseSpace_isResolved, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_rescaleSigma", _wrap_PhaseSpace_rescaleSigma, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_rescaleMomenta", _wrap_PhaseSpace_rescaleMomenta, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_weightGammaPDFApprox", _wrap_PhaseSpace_weightGammaPDFApprox, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_setGammaKinPtr", _wrap_PhaseSpace_setGammaKinPtr, METH_VARARGS, NULL},
	 { (char *)"new_PhaseSpace", _wrap_new_PhaseSpace, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sigmaProcessPtr_set", _wrap_PhaseSpace_sigmaProcessPtr_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sigmaProcessPtr_get", _wrap_PhaseSpace_sigmaProcessPtr_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_infoPtr_set", _wrap_PhaseSpace_infoPtr_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_infoPtr_get", _wrap_PhaseSpace_infoPtr_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_settingsPtr_set", _wrap_PhaseSpace_settingsPtr_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_settingsPtr_get", _wrap_PhaseSpace_settingsPtr_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_particleDataPtr_set", _wrap_PhaseSpace_particleDataPtr_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_particleDataPtr_get", _wrap_PhaseSpace_particleDataPtr_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_rndmPtr_set", _wrap_PhaseSpace_rndmPtr_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_rndmPtr_get", _wrap_PhaseSpace_rndmPtr_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_beamAPtr_set", _wrap_PhaseSpace_beamAPtr_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_beamAPtr_get", _wrap_PhaseSpace_beamAPtr_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_beamBPtr_set", _wrap_PhaseSpace_beamBPtr_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_beamBPtr_get", _wrap_PhaseSpace_beamBPtr_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_couplingsPtr_set", _wrap_PhaseSpace_couplingsPtr_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_couplingsPtr_get", _wrap_PhaseSpace_couplingsPtr_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sigmaTotPtr_set", _wrap_PhaseSpace_sigmaTotPtr_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sigmaTotPtr_get", _wrap_PhaseSpace_sigmaTotPtr_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_userHooksPtr_set", _wrap_PhaseSpace_userHooksPtr_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_userHooksPtr_get", _wrap_PhaseSpace_userHooksPtr_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_lhaUpPtr_set", _wrap_PhaseSpace_lhaUpPtr_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_lhaUpPtr_get", _wrap_PhaseSpace_lhaUpPtr_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_useBreitWigners_set", _wrap_PhaseSpace_useBreitWigners_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_useBreitWigners_get", _wrap_PhaseSpace_useBreitWigners_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_doEnergySpread_set", _wrap_PhaseSpace_doEnergySpread_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_doEnergySpread_get", _wrap_PhaseSpace_doEnergySpread_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_showSearch_set", _wrap_PhaseSpace_showSearch_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_showSearch_get", _wrap_PhaseSpace_showSearch_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_showViolation_set", _wrap_PhaseSpace_showViolation_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_showViolation_get", _wrap_PhaseSpace_showViolation_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_increaseMaximum_set", _wrap_PhaseSpace_increaseMaximum_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_increaseMaximum_get", _wrap_PhaseSpace_increaseMaximum_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_hasQ2Min_set", _wrap_PhaseSpace_hasQ2Min_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_hasQ2Min_get", _wrap_PhaseSpace_hasQ2Min_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_gmZmodeGlobal_set", _wrap_PhaseSpace_gmZmodeGlobal_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_gmZmodeGlobal_get", _wrap_PhaseSpace_gmZmodeGlobal_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mHatGlobalMin_set", _wrap_PhaseSpace_mHatGlobalMin_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mHatGlobalMin_get", _wrap_PhaseSpace_mHatGlobalMin_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mHatGlobalMax_set", _wrap_PhaseSpace_mHatGlobalMax_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mHatGlobalMax_get", _wrap_PhaseSpace_mHatGlobalMax_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_pTHatGlobalMin_set", _wrap_PhaseSpace_pTHatGlobalMin_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_pTHatGlobalMin_get", _wrap_PhaseSpace_pTHatGlobalMin_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_pTHatGlobalMax_set", _wrap_PhaseSpace_pTHatGlobalMax_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_pTHatGlobalMax_get", _wrap_PhaseSpace_pTHatGlobalMax_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_Q2GlobalMin_set", _wrap_PhaseSpace_Q2GlobalMin_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_Q2GlobalMin_get", _wrap_PhaseSpace_Q2GlobalMin_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_pTHatMinDiverge_set", _wrap_PhaseSpace_pTHatMinDiverge_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_pTHatMinDiverge_get", _wrap_PhaseSpace_pTHatMinDiverge_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_minWidthBreitWigners_set", _wrap_PhaseSpace_minWidthBreitWigners_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_minWidthBreitWigners_get", _wrap_PhaseSpace_minWidthBreitWigners_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_idA_set", _wrap_PhaseSpace_idA_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_idA_get", _wrap_PhaseSpace_idA_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_idB_set", _wrap_PhaseSpace_idB_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_idB_get", _wrap_PhaseSpace_idB_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mA_set", _wrap_PhaseSpace_mA_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mA_get", _wrap_PhaseSpace_mA_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mB_set", _wrap_PhaseSpace_mB_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mB_get", _wrap_PhaseSpace_mB_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_eCM_set", _wrap_PhaseSpace_eCM_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_eCM_get", _wrap_PhaseSpace_eCM_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_s_set", _wrap_PhaseSpace_s_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_s_get", _wrap_PhaseSpace_s_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_hasLeptonBeamA_set", _wrap_PhaseSpace_hasLeptonBeamA_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_hasLeptonBeamA_get", _wrap_PhaseSpace_hasLeptonBeamA_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_hasLeptonBeamB_set", _wrap_PhaseSpace_hasLeptonBeamB_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_hasLeptonBeamB_get", _wrap_PhaseSpace_hasLeptonBeamB_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_hasOneLeptonBeam_set", _wrap_PhaseSpace_hasOneLeptonBeam_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_hasOneLeptonBeam_get", _wrap_PhaseSpace_hasOneLeptonBeam_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_hasTwoLeptonBeams_set", _wrap_PhaseSpace_hasTwoLeptonBeams_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_hasTwoLeptonBeams_get", _wrap_PhaseSpace_hasTwoLeptonBeams_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_hasPointGammaA_set", _wrap_PhaseSpace_hasPointGammaA_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_hasPointGammaA_get", _wrap_PhaseSpace_hasPointGammaA_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_hasPointGammaB_set", _wrap_PhaseSpace_hasPointGammaB_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_hasPointGammaB_get", _wrap_PhaseSpace_hasPointGammaB_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_hasOnePointParticle_set", _wrap_PhaseSpace_hasOnePointParticle_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_hasOnePointParticle_get", _wrap_PhaseSpace_hasOnePointParticle_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_hasTwoPointParticles_set", _wrap_PhaseSpace_hasTwoPointParticles_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_hasTwoPointParticles_get", _wrap_PhaseSpace_hasTwoPointParticles_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_newSigmaMx_set", _wrap_PhaseSpace_newSigmaMx_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_newSigmaMx_get", _wrap_PhaseSpace_newSigmaMx_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_canModifySigma_set", _wrap_PhaseSpace_canModifySigma_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_canModifySigma_get", _wrap_PhaseSpace_canModifySigma_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_canBiasSelection_set", _wrap_PhaseSpace_canBiasSelection_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_canBiasSelection_get", _wrap_PhaseSpace_canBiasSelection_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_canBias2Sel_set", _wrap_PhaseSpace_canBias2Sel_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_canBias2Sel_get", _wrap_PhaseSpace_canBias2Sel_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_gmZmode_set", _wrap_PhaseSpace_gmZmode_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_gmZmode_get", _wrap_PhaseSpace_gmZmode_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_bias2SelPow_set", _wrap_PhaseSpace_bias2SelPow_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_bias2SelPow_get", _wrap_PhaseSpace_bias2SelPow_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_bias2SelRef_set", _wrap_PhaseSpace_bias2SelRef_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_bias2SelRef_get", _wrap_PhaseSpace_bias2SelRef_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_wtBW_set", _wrap_PhaseSpace_wtBW_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_wtBW_get", _wrap_PhaseSpace_wtBW_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sigmaNw_set", _wrap_PhaseSpace_sigmaNw_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sigmaNw_get", _wrap_PhaseSpace_sigmaNw_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sigmaMx_set", _wrap_PhaseSpace_sigmaMx_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sigmaMx_get", _wrap_PhaseSpace_sigmaMx_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sigmaPos_set", _wrap_PhaseSpace_sigmaPos_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sigmaPos_get", _wrap_PhaseSpace_sigmaPos_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sigmaNeg_set", _wrap_PhaseSpace_sigmaNeg_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sigmaNeg_get", _wrap_PhaseSpace_sigmaNeg_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_biasWt_set", _wrap_PhaseSpace_biasWt_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_biasWt_get", _wrap_PhaseSpace_biasWt_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mHatMin_set", _wrap_PhaseSpace_mHatMin_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mHatMin_get", _wrap_PhaseSpace_mHatMin_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mHatMax_set", _wrap_PhaseSpace_mHatMax_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mHatMax_get", _wrap_PhaseSpace_mHatMax_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sHatMin_set", _wrap_PhaseSpace_sHatMin_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sHatMin_get", _wrap_PhaseSpace_sHatMin_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sHatMax_set", _wrap_PhaseSpace_sHatMax_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sHatMax_get", _wrap_PhaseSpace_sHatMax_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_pTHatMin_set", _wrap_PhaseSpace_pTHatMin_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_pTHatMin_get", _wrap_PhaseSpace_pTHatMin_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_pTHatMax_set", _wrap_PhaseSpace_pTHatMax_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_pTHatMax_get", _wrap_PhaseSpace_pTHatMax_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_pT2HatMin_set", _wrap_PhaseSpace_pT2HatMin_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_pT2HatMin_get", _wrap_PhaseSpace_pT2HatMin_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_pT2HatMax_set", _wrap_PhaseSpace_pT2HatMax_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_pT2HatMax_get", _wrap_PhaseSpace_pT2HatMax_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_x1H_set", _wrap_PhaseSpace_x1H_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_x1H_get", _wrap_PhaseSpace_x1H_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_x2H_set", _wrap_PhaseSpace_x2H_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_x2H_get", _wrap_PhaseSpace_x2H_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_m3_set", _wrap_PhaseSpace_m3_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_m3_get", _wrap_PhaseSpace_m3_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_m4_set", _wrap_PhaseSpace_m4_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_m4_get", _wrap_PhaseSpace_m4_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_m5_set", _wrap_PhaseSpace_m5_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_m5_get", _wrap_PhaseSpace_m5_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_s3_set", _wrap_PhaseSpace_s3_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_s3_get", _wrap_PhaseSpace_s3_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_s4_set", _wrap_PhaseSpace_s4_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_s4_get", _wrap_PhaseSpace_s4_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_s5_set", _wrap_PhaseSpace_s5_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_s5_get", _wrap_PhaseSpace_s5_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mHat_set", _wrap_PhaseSpace_mHat_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mHat_get", _wrap_PhaseSpace_mHat_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sH_set", _wrap_PhaseSpace_sH_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sH_get", _wrap_PhaseSpace_sH_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_tH_set", _wrap_PhaseSpace_tH_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_tH_get", _wrap_PhaseSpace_tH_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_uH_set", _wrap_PhaseSpace_uH_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_uH_get", _wrap_PhaseSpace_uH_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_pAbs_set", _wrap_PhaseSpace_pAbs_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_pAbs_get", _wrap_PhaseSpace_pAbs_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_p2Abs_set", _wrap_PhaseSpace_p2Abs_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_p2Abs_get", _wrap_PhaseSpace_p2Abs_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_pTH_set", _wrap_PhaseSpace_pTH_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_pTH_get", _wrap_PhaseSpace_pTH_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_theta_set", _wrap_PhaseSpace_theta_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_theta_get", _wrap_PhaseSpace_theta_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_phi_set", _wrap_PhaseSpace_phi_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_phi_get", _wrap_PhaseSpace_phi_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_betaZ_set", _wrap_PhaseSpace_betaZ_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_betaZ_get", _wrap_PhaseSpace_betaZ_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_pH_set", _wrap_PhaseSpace_pH_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_pH_get", _wrap_PhaseSpace_pH_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mH_set", _wrap_PhaseSpace_mH_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mH_get", _wrap_PhaseSpace_mH_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_decayKinematicsStep", _wrap_PhaseSpace_decayKinematicsStep, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_setup3Body", _wrap_PhaseSpace_setup3Body, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_setupSampling123", _wrap_PhaseSpace_setupSampling123, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_trialKin123", _wrap_PhaseSpace_trialKin123, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_idResA_set", _wrap_PhaseSpace_idResA_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_idResA_get", _wrap_PhaseSpace_idResA_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_idResB_set", _wrap_PhaseSpace_idResB_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_idResB_get", _wrap_PhaseSpace_idResB_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mResA_set", _wrap_PhaseSpace_mResA_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mResA_get", _wrap_PhaseSpace_mResA_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mResB_set", _wrap_PhaseSpace_mResB_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mResB_get", _wrap_PhaseSpace_mResB_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_GammaResA_set", _wrap_PhaseSpace_GammaResA_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_GammaResA_get", _wrap_PhaseSpace_GammaResA_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_GammaResB_set", _wrap_PhaseSpace_GammaResB_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_GammaResB_get", _wrap_PhaseSpace_GammaResB_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_tauResA_set", _wrap_PhaseSpace_tauResA_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_tauResA_get", _wrap_PhaseSpace_tauResA_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_tauResB_set", _wrap_PhaseSpace_tauResB_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_tauResB_get", _wrap_PhaseSpace_tauResB_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_widResA_set", _wrap_PhaseSpace_widResA_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_widResA_get", _wrap_PhaseSpace_widResA_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_widResB_set", _wrap_PhaseSpace_widResB_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_widResB_get", _wrap_PhaseSpace_widResB_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sameResMass_set", _wrap_PhaseSpace_sameResMass_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sameResMass_get", _wrap_PhaseSpace_sameResMass_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_useMirrorWeight_set", _wrap_PhaseSpace_useMirrorWeight_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_useMirrorWeight_get", _wrap_PhaseSpace_useMirrorWeight_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_hasNegZ_set", _wrap_PhaseSpace_hasNegZ_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_hasNegZ_get", _wrap_PhaseSpace_hasNegZ_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_hasPosZ_set", _wrap_PhaseSpace_hasPosZ_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_hasPosZ_get", _wrap_PhaseSpace_hasPosZ_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_tau_set", _wrap_PhaseSpace_tau_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_tau_get", _wrap_PhaseSpace_tau_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_y_set", _wrap_PhaseSpace_y_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_y_get", _wrap_PhaseSpace_y_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_z_set", _wrap_PhaseSpace_z_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_z_get", _wrap_PhaseSpace_z_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_tauMin_set", _wrap_PhaseSpace_tauMin_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_tauMin_get", _wrap_PhaseSpace_tauMin_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_tauMax_set", _wrap_PhaseSpace_tauMax_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_tauMax_get", _wrap_PhaseSpace_tauMax_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_yMax_set", _wrap_PhaseSpace_yMax_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_yMax_get", _wrap_PhaseSpace_yMax_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_zMin_set", _wrap_PhaseSpace_zMin_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_zMin_get", _wrap_PhaseSpace_zMin_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_zMax_set", _wrap_PhaseSpace_zMax_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_zMax_get", _wrap_PhaseSpace_zMax_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_ratio34_set", _wrap_PhaseSpace_ratio34_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_ratio34_get", _wrap_PhaseSpace_ratio34_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_unity34_set", _wrap_PhaseSpace_unity34_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_unity34_get", _wrap_PhaseSpace_unity34_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_zNeg_set", _wrap_PhaseSpace_zNeg_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_zNeg_get", _wrap_PhaseSpace_zNeg_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_zPos_set", _wrap_PhaseSpace_zPos_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_zPos_get", _wrap_PhaseSpace_zPos_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_wtTau_set", _wrap_PhaseSpace_wtTau_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_wtTau_get", _wrap_PhaseSpace_wtTau_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_wtY_set", _wrap_PhaseSpace_wtY_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_wtY_get", _wrap_PhaseSpace_wtY_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_wtZ_set", _wrap_PhaseSpace_wtZ_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_wtZ_get", _wrap_PhaseSpace_wtZ_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_wt3Body_set", _wrap_PhaseSpace_wt3Body_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_wt3Body_get", _wrap_PhaseSpace_wt3Body_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_runBW3H_set", _wrap_PhaseSpace_runBW3H_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_runBW3H_get", _wrap_PhaseSpace_runBW3H_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_runBW4H_set", _wrap_PhaseSpace_runBW4H_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_runBW4H_get", _wrap_PhaseSpace_runBW4H_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_runBW5H_set", _wrap_PhaseSpace_runBW5H_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_runBW5H_get", _wrap_PhaseSpace_runBW5H_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intTau0_set", _wrap_PhaseSpace_intTau0_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intTau0_get", _wrap_PhaseSpace_intTau0_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intTau1_set", _wrap_PhaseSpace_intTau1_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intTau1_get", _wrap_PhaseSpace_intTau1_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intTau2_set", _wrap_PhaseSpace_intTau2_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intTau2_get", _wrap_PhaseSpace_intTau2_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intTau3_set", _wrap_PhaseSpace_intTau3_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intTau3_get", _wrap_PhaseSpace_intTau3_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intTau4_set", _wrap_PhaseSpace_intTau4_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intTau4_get", _wrap_PhaseSpace_intTau4_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intTau5_set", _wrap_PhaseSpace_intTau5_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intTau5_get", _wrap_PhaseSpace_intTau5_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intTau6_set", _wrap_PhaseSpace_intTau6_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intTau6_get", _wrap_PhaseSpace_intTau6_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intY0_set", _wrap_PhaseSpace_intY0_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intY0_get", _wrap_PhaseSpace_intY0_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intY12_set", _wrap_PhaseSpace_intY12_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intY12_get", _wrap_PhaseSpace_intY12_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intY34_set", _wrap_PhaseSpace_intY34_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intY34_get", _wrap_PhaseSpace_intY34_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intY56_set", _wrap_PhaseSpace_intY56_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intY56_get", _wrap_PhaseSpace_intY56_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mTchan1_set", _wrap_PhaseSpace_mTchan1_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mTchan1_get", _wrap_PhaseSpace_mTchan1_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sTchan1_set", _wrap_PhaseSpace_sTchan1_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sTchan1_get", _wrap_PhaseSpace_sTchan1_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mTchan2_set", _wrap_PhaseSpace_mTchan2_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mTchan2_get", _wrap_PhaseSpace_mTchan2_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sTchan2_set", _wrap_PhaseSpace_sTchan2_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sTchan2_get", _wrap_PhaseSpace_sTchan2_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_frac3Flat_set", _wrap_PhaseSpace_frac3Flat_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_frac3Flat_get", _wrap_PhaseSpace_frac3Flat_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_frac3Pow1_set", _wrap_PhaseSpace_frac3Pow1_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_frac3Pow1_get", _wrap_PhaseSpace_frac3Pow1_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_frac3Pow2_set", _wrap_PhaseSpace_frac3Pow2_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_frac3Pow2_get", _wrap_PhaseSpace_frac3Pow2_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_zNegMin_set", _wrap_PhaseSpace_zNegMin_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_zNegMin_get", _wrap_PhaseSpace_zNegMin_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_zNegMax_set", _wrap_PhaseSpace_zNegMax_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_zNegMax_get", _wrap_PhaseSpace_zNegMax_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_zPosMin_set", _wrap_PhaseSpace_zPosMin_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_zPosMin_get", _wrap_PhaseSpace_zPosMin_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_zPosMax_set", _wrap_PhaseSpace_zPosMax_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_zPosMax_get", _wrap_PhaseSpace_zPosMax_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_p3cm_set", _wrap_PhaseSpace_p3cm_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_p3cm_get", _wrap_PhaseSpace_p3cm_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_p4cm_set", _wrap_PhaseSpace_p4cm_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_p4cm_get", _wrap_PhaseSpace_p4cm_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_p5cm_set", _wrap_PhaseSpace_p5cm_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_p5cm_get", _wrap_PhaseSpace_p5cm_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_nTau_set", _wrap_PhaseSpace_nTau_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_nTau_get", _wrap_PhaseSpace_nTau_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_nY_set", _wrap_PhaseSpace_nY_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_nY_get", _wrap_PhaseSpace_nY_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_nZ_set", _wrap_PhaseSpace_nZ_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_nZ_get", _wrap_PhaseSpace_nZ_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_tauCoef_set", _wrap_PhaseSpace_tauCoef_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_tauCoef_get", _wrap_PhaseSpace_tauCoef_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_yCoef_set", _wrap_PhaseSpace_yCoef_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_yCoef_get", _wrap_PhaseSpace_yCoef_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_zCoef_set", _wrap_PhaseSpace_zCoef_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_zCoef_get", _wrap_PhaseSpace_zCoef_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_tauCoefSum_set", _wrap_PhaseSpace_tauCoefSum_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_tauCoefSum_get", _wrap_PhaseSpace_tauCoefSum_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_yCoefSum_set", _wrap_PhaseSpace_yCoefSum_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_yCoefSum_get", _wrap_PhaseSpace_yCoefSum_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_zCoefSum_set", _wrap_PhaseSpace_zCoefSum_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_zCoefSum_get", _wrap_PhaseSpace_zCoefSum_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_limitTau", _wrap_PhaseSpace_limitTau, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_limitY", _wrap_PhaseSpace_limitY, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_limitZ", _wrap_PhaseSpace_limitZ, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_selectTau", _wrap_PhaseSpace_selectTau, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_selectY", _wrap_PhaseSpace_selectY, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_selectZ", _wrap_PhaseSpace_selectZ, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_select3Body", _wrap_PhaseSpace_select3Body, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_solveSys", _wrap_PhaseSpace_solveSys, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_useBW_set", _wrap_PhaseSpace_useBW_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_useBW_get", _wrap_PhaseSpace_useBW_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_idMass_set", _wrap_PhaseSpace_idMass_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_idMass_get", _wrap_PhaseSpace_idMass_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mPeak_set", _wrap_PhaseSpace_mPeak_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mPeak_get", _wrap_PhaseSpace_mPeak_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sPeak_set", _wrap_PhaseSpace_sPeak_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sPeak_get", _wrap_PhaseSpace_sPeak_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mWidth_set", _wrap_PhaseSpace_mWidth_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mWidth_get", _wrap_PhaseSpace_mWidth_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mMin_set", _wrap_PhaseSpace_mMin_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mMin_get", _wrap_PhaseSpace_mMin_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mMax_set", _wrap_PhaseSpace_mMax_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mMax_get", _wrap_PhaseSpace_mMax_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mw_set", _wrap_PhaseSpace_mw_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mw_get", _wrap_PhaseSpace_mw_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_wmRat_set", _wrap_PhaseSpace_wmRat_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_wmRat_get", _wrap_PhaseSpace_wmRat_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mLower_set", _wrap_PhaseSpace_mLower_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mLower_get", _wrap_PhaseSpace_mLower_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mUpper_set", _wrap_PhaseSpace_mUpper_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_mUpper_get", _wrap_PhaseSpace_mUpper_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sLower_set", _wrap_PhaseSpace_sLower_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sLower_get", _wrap_PhaseSpace_sLower_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sUpper_set", _wrap_PhaseSpace_sUpper_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_sUpper_get", _wrap_PhaseSpace_sUpper_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_fracFlatS_set", _wrap_PhaseSpace_fracFlatS_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_fracFlatS_get", _wrap_PhaseSpace_fracFlatS_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_fracFlatM_set", _wrap_PhaseSpace_fracFlatM_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_fracFlatM_get", _wrap_PhaseSpace_fracFlatM_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_fracInv_set", _wrap_PhaseSpace_fracInv_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_fracInv_get", _wrap_PhaseSpace_fracInv_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_fracInv2_set", _wrap_PhaseSpace_fracInv2_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_fracInv2_get", _wrap_PhaseSpace_fracInv2_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_atanLower_set", _wrap_PhaseSpace_atanLower_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_atanLower_get", _wrap_PhaseSpace_atanLower_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_atanUpper_set", _wrap_PhaseSpace_atanUpper_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_atanUpper_get", _wrap_PhaseSpace_atanUpper_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intBW_set", _wrap_PhaseSpace_intBW_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intBW_get", _wrap_PhaseSpace_intBW_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intFlatS_set", _wrap_PhaseSpace_intFlatS_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intFlatS_get", _wrap_PhaseSpace_intFlatS_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intFlatM_set", _wrap_PhaseSpace_intFlatM_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intFlatM_get", _wrap_PhaseSpace_intFlatM_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intInv_set", _wrap_PhaseSpace_intInv_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intInv_get", _wrap_PhaseSpace_intInv_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intInv2_set", _wrap_PhaseSpace_intInv2_set, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_intInv2_get", _wrap_PhaseSpace_intInv2_get, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_setupMass1", _wrap_PhaseSpace_setupMass1, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_setupMass2", _wrap_PhaseSpace_setupMass2, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_trialMass", _wrap_PhaseSpace_trialMass, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_weightMass", _wrap_PhaseSpace_weightMass, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_tRange", _wrap_PhaseSpace_tRange, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_tInRange", _wrap_PhaseSpace_tInRange, METH_VARARGS, NULL},
	 { (char *)"disown_PhaseSpace", _wrap_disown_PhaseSpace, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace_swigregister", PhaseSpace_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PhaseSpace2to1tauy", _wrap_new_PhaseSpace2to1tauy, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to1tauy_setupSampling", _wrap_PhaseSpace2to1tauy_setupSampling, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to1tauy_trialKin", _wrap_PhaseSpace2to1tauy_trialKin, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to1tauy_finalKin", _wrap_PhaseSpace2to1tauy_finalKin, METH_VARARGS, NULL},
	 { (char *)"delete_PhaseSpace2to1tauy", _wrap_delete_PhaseSpace2to1tauy, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to1tauy_swigregister", PhaseSpace2to1tauy_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PhaseSpace2to2tauyz", _wrap_new_PhaseSpace2to2tauyz, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2tauyz_setupSampling", _wrap_PhaseSpace2to2tauyz_setupSampling, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2tauyz_trialKin", _wrap_PhaseSpace2to2tauyz_trialKin, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2tauyz_finalKin", _wrap_PhaseSpace2to2tauyz_finalKin, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2tauyz_rescaleMomenta", _wrap_PhaseSpace2to2tauyz_rescaleMomenta, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2tauyz_rescaleSigma", _wrap_PhaseSpace2to2tauyz_rescaleSigma, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2tauyz_weightGammaPDFApprox", _wrap_PhaseSpace2to2tauyz_weightGammaPDFApprox, METH_VARARGS, NULL},
	 { (char *)"delete_PhaseSpace2to2tauyz", _wrap_delete_PhaseSpace2to2tauyz, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2tauyz_swigregister", PhaseSpace2to2tauyz_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PhaseSpace2to2elastic", _wrap_new_PhaseSpace2to2elastic, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2elastic_setupSampling", _wrap_PhaseSpace2to2elastic_setupSampling, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2elastic_trialKin", _wrap_PhaseSpace2to2elastic_trialKin, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2elastic_finalKin", _wrap_PhaseSpace2to2elastic_finalKin, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2elastic_isResolved", _wrap_PhaseSpace2to2elastic_isResolved, METH_VARARGS, NULL},
	 { (char *)"delete_PhaseSpace2to2elastic", _wrap_delete_PhaseSpace2to2elastic, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2elastic_swigregister", PhaseSpace2to2elastic_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PhaseSpace2to2diffractive", _wrap_new_PhaseSpace2to2diffractive, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2diffractive_setupSampling", _wrap_PhaseSpace2to2diffractive_setupSampling, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2diffractive_trialKin", _wrap_PhaseSpace2to2diffractive_trialKin, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2diffractive_finalKin", _wrap_PhaseSpace2to2diffractive_finalKin, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2diffractive_isResolved", _wrap_PhaseSpace2to2diffractive_isResolved, METH_VARARGS, NULL},
	 { (char *)"delete_PhaseSpace2to2diffractive", _wrap_delete_PhaseSpace2to2diffractive, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2diffractive_swigregister", PhaseSpace2to2diffractive_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PhaseSpace2to3diffractive", _wrap_new_PhaseSpace2to3diffractive, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to3diffractive_setupSampling", _wrap_PhaseSpace2to3diffractive_setupSampling, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to3diffractive_trialKin", _wrap_PhaseSpace2to3diffractive_trialKin, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to3diffractive_finalKin", _wrap_PhaseSpace2to3diffractive_finalKin, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to3diffractive_isResolved", _wrap_PhaseSpace2to3diffractive_isResolved, METH_VARARGS, NULL},
	 { (char *)"delete_PhaseSpace2to3diffractive", _wrap_delete_PhaseSpace2to3diffractive, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to3diffractive_swigregister", PhaseSpace2to3diffractive_swigregister, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2nondiffractive_setupSampling", _wrap_PhaseSpace2to2nondiffractive_setupSampling, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2nondiffractive_trialKin", _wrap_PhaseSpace2to2nondiffractive_trialKin, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2nondiffractive_finalKin", _wrap_PhaseSpace2to2nondiffractive_finalKin, METH_VARARGS, NULL},
	 { (char *)"delete_PhaseSpace2to2nondiffractive", _wrap_delete_PhaseSpace2to2nondiffractive, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2nondiffractive_swigregister", PhaseSpace2to2nondiffractive_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PhaseSpace2to2nondiffractiveGamma", _wrap_new_PhaseSpace2to2nondiffractiveGamma, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2nondiffractiveGamma_setupSampling", _wrap_PhaseSpace2to2nondiffractiveGamma_setupSampling, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2nondiffractiveGamma_trialKin", _wrap_PhaseSpace2to2nondiffractiveGamma_trialKin, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2nondiffractiveGamma_finalKin", _wrap_PhaseSpace2to2nondiffractiveGamma_finalKin, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2nondiffractiveGamma_setGammaKinPtr", _wrap_PhaseSpace2to2nondiffractiveGamma_setGammaKinPtr, METH_VARARGS, NULL},
	 { (char *)"delete_PhaseSpace2to2nondiffractiveGamma", _wrap_delete_PhaseSpace2to2nondiffractiveGamma, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to2nondiffractiveGamma_swigregister", PhaseSpace2to2nondiffractiveGamma_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PhaseSpace2to3tauycyl", _wrap_new_PhaseSpace2to3tauycyl, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to3tauycyl_setupSampling", _wrap_PhaseSpace2to3tauycyl_setupSampling, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to3tauycyl_trialKin", _wrap_PhaseSpace2to3tauycyl_trialKin, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to3tauycyl_finalKin", _wrap_PhaseSpace2to3tauycyl_finalKin, METH_VARARGS, NULL},
	 { (char *)"delete_PhaseSpace2to3tauycyl", _wrap_delete_PhaseSpace2to3tauycyl, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to3tauycyl_swigregister", PhaseSpace2to3tauycyl_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PhaseSpace2to3yyycyl", _wrap_new_PhaseSpace2to3yyycyl, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to3yyycyl_setupSampling", _wrap_PhaseSpace2to3yyycyl_setupSampling, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to3yyycyl_trialKin", _wrap_PhaseSpace2to3yyycyl_trialKin, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to3yyycyl_finalKin", _wrap_PhaseSpace2to3yyycyl_finalKin, METH_VARARGS, NULL},
	 { (char *)"delete_PhaseSpace2to3yyycyl", _wrap_delete_PhaseSpace2to3yyycyl, METH_VARARGS, NULL},
	 { (char *)"PhaseSpace2to3yyycyl_swigregister", PhaseSpace2to3yyycyl_swigregister, METH_VARARGS, NULL},
	 { (char *)"PhaseSpaceLHA_setupSampling", _wrap_PhaseSpaceLHA_setupSampling, METH_VARARGS, NULL},
	 { (char *)"PhaseSpaceLHA_trialKin", _wrap_PhaseSpaceLHA_trialKin, METH_VARARGS, NULL},
	 { (char *)"PhaseSpaceLHA_finalKin", _wrap_PhaseSpaceLHA_finalKin, METH_VARARGS, NULL},
	 { (char *)"PhaseSpaceLHA_sigmaSumSigned", _wrap_PhaseSpaceLHA_sigmaSumSigned, METH_VARARGS, NULL},
	 { (char *)"delete_PhaseSpaceLHA", _wrap_delete_PhaseSpaceLHA, METH_VARARGS, NULL},
	 { (char *)"PhaseSpaceLHA_swigregister", PhaseSpaceLHA_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma1qg2qStar", _wrap_new_Sigma1qg2qStar, METH_VARARGS, NULL},
	 { (char *)"Sigma1qg2qStar_initProc", _wrap_Sigma1qg2qStar_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma1qg2qStar_sigmaKin", _wrap_Sigma1qg2qStar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma1qg2qStar_sigmaHat", _wrap_Sigma1qg2qStar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma1qg2qStar_setIdColAcol", _wrap_Sigma1qg2qStar_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma1qg2qStar_weightDecay", _wrap_Sigma1qg2qStar_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma1qg2qStar_name", _wrap_Sigma1qg2qStar_name, METH_VARARGS, NULL},
	 { (char *)"Sigma1qg2qStar_code", _wrap_Sigma1qg2qStar_code, METH_VARARGS, NULL},
	 { (char *)"Sigma1qg2qStar_inFlux", _wrap_Sigma1qg2qStar_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma1qg2qStar_resonanceA", _wrap_Sigma1qg2qStar_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma1qg2qStar", _wrap_delete_Sigma1qg2qStar, METH_VARARGS, NULL},
	 { (char *)"Sigma1qg2qStar_swigregister", Sigma1qg2qStar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma1lgm2lStar", _wrap_new_Sigma1lgm2lStar, METH_VARARGS, NULL},
	 { (char *)"Sigma1lgm2lStar_initProc", _wrap_Sigma1lgm2lStar_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma1lgm2lStar_sigmaKin", _wrap_Sigma1lgm2lStar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma1lgm2lStar_sigmaHat", _wrap_Sigma1lgm2lStar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma1lgm2lStar_setIdColAcol", _wrap_Sigma1lgm2lStar_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma1lgm2lStar_weightDecay", _wrap_Sigma1lgm2lStar_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma1lgm2lStar_name", _wrap_Sigma1lgm2lStar_name, METH_VARARGS, NULL},
	 { (char *)"Sigma1lgm2lStar_code", _wrap_Sigma1lgm2lStar_code, METH_VARARGS, NULL},
	 { (char *)"Sigma1lgm2lStar_inFlux", _wrap_Sigma1lgm2lStar_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma1lgm2lStar_resonanceA", _wrap_Sigma1lgm2lStar_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma1lgm2lStar", _wrap_delete_Sigma1lgm2lStar, METH_VARARGS, NULL},
	 { (char *)"Sigma1lgm2lStar_swigregister", Sigma1lgm2lStar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qq2qStarq", _wrap_new_Sigma2qq2qStarq, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2qStarq_initProc", _wrap_Sigma2qq2qStarq_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2qStarq_sigmaKin", _wrap_Sigma2qq2qStarq_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2qStarq_sigmaHat", _wrap_Sigma2qq2qStarq_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2qStarq_setIdColAcol", _wrap_Sigma2qq2qStarq_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2qStarq_weightDecay", _wrap_Sigma2qq2qStarq_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2qStarq_name", _wrap_Sigma2qq2qStarq_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2qStarq_code", _wrap_Sigma2qq2qStarq_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2qStarq_inFlux", _wrap_Sigma2qq2qStarq_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2qStarq_id3Mass", _wrap_Sigma2qq2qStarq_id3Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qq2qStarq", _wrap_delete_Sigma2qq2qStarq, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2qStarq_swigregister", Sigma2qq2qStarq_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2lStarlbar", _wrap_new_Sigma2qqbar2lStarlbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2lStarlbar_initProc", _wrap_Sigma2qqbar2lStarlbar_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2lStarlbar_sigmaKin", _wrap_Sigma2qqbar2lStarlbar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2lStarlbar_sigmaHat", _wrap_Sigma2qqbar2lStarlbar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2lStarlbar_setIdColAcol", _wrap_Sigma2qqbar2lStarlbar_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2lStarlbar_weightDecay", _wrap_Sigma2qqbar2lStarlbar_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2lStarlbar_name", _wrap_Sigma2qqbar2lStarlbar_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2lStarlbar_code", _wrap_Sigma2qqbar2lStarlbar_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2lStarlbar_inFlux", _wrap_Sigma2qqbar2lStarlbar_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2lStarlbar_id3Mass", _wrap_Sigma2qqbar2lStarlbar_id3Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2lStarlbar", _wrap_delete_Sigma2qqbar2lStarlbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2lStarlbar_swigregister", Sigma2qqbar2lStarlbar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2lStarlStarBar", _wrap_new_Sigma2qqbar2lStarlStarBar, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2lStarlStarBar_initProc", _wrap_Sigma2qqbar2lStarlStarBar_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2lStarlStarBar_sigmaKin", _wrap_Sigma2qqbar2lStarlStarBar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2lStarlStarBar_sigmaHat", _wrap_Sigma2qqbar2lStarlStarBar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2lStarlStarBar_setIdColAcol", _wrap_Sigma2qqbar2lStarlStarBar_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2lStarlStarBar_weightDecay", _wrap_Sigma2qqbar2lStarlStarBar_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2lStarlStarBar_name", _wrap_Sigma2qqbar2lStarlStarBar_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2lStarlStarBar_code", _wrap_Sigma2qqbar2lStarlStarBar_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2lStarlStarBar_inFlux", _wrap_Sigma2qqbar2lStarlStarBar_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2lStarlStarBar_id3Mass", _wrap_Sigma2qqbar2lStarlStarBar_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2lStarlStarBar_id4Mass", _wrap_Sigma2qqbar2lStarlStarBar_id4Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2lStarlStarBar", _wrap_delete_Sigma2qqbar2lStarlStarBar, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2lStarlStarBar_swigregister", Sigma2qqbar2lStarlStarBar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2QCqq2qq", _wrap_new_Sigma2QCqq2qq, METH_VARARGS, NULL},
	 { (char *)"Sigma2QCqq2qq_initProc", _wrap_Sigma2QCqq2qq_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2QCqq2qq_sigmaKin", _wrap_Sigma2QCqq2qq_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2QCqq2qq_sigmaHat", _wrap_Sigma2QCqq2qq_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2QCqq2qq_setIdColAcol", _wrap_Sigma2QCqq2qq_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2QCqq2qq_name", _wrap_Sigma2QCqq2qq_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2QCqq2qq_code", _wrap_Sigma2QCqq2qq_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2QCqq2qq_inFlux", _wrap_Sigma2QCqq2qq_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2QCqq2qq", _wrap_delete_Sigma2QCqq2qq, METH_VARARGS, NULL},
	 { (char *)"Sigma2QCqq2qq_swigregister", Sigma2QCqq2qq_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2QCqqbar2qqbar", _wrap_new_Sigma2QCqqbar2qqbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2QCqqbar2qqbar_initProc", _wrap_Sigma2QCqqbar2qqbar_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2QCqqbar2qqbar_sigmaKin", _wrap_Sigma2QCqqbar2qqbar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2QCqqbar2qqbar_sigmaHat", _wrap_Sigma2QCqqbar2qqbar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2QCqqbar2qqbar_setIdColAcol", _wrap_Sigma2QCqqbar2qqbar_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2QCqqbar2qqbar_name", _wrap_Sigma2QCqqbar2qqbar_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2QCqqbar2qqbar_code", _wrap_Sigma2QCqqbar2qqbar_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2QCqqbar2qqbar_inFlux", _wrap_Sigma2QCqqbar2qqbar_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2QCqqbar2qqbar", _wrap_delete_Sigma2QCqqbar2qqbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2QCqqbar2qqbar_swigregister", Sigma2QCqqbar2qqbar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2QCffbar2llbar", _wrap_new_Sigma2QCffbar2llbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2QCffbar2llbar_initProc", _wrap_Sigma2QCffbar2llbar_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2QCffbar2llbar_sigmaKin", _wrap_Sigma2QCffbar2llbar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2QCffbar2llbar_sigmaHat", _wrap_Sigma2QCffbar2llbar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2QCffbar2llbar_setIdColAcol", _wrap_Sigma2QCffbar2llbar_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2QCffbar2llbar_name", _wrap_Sigma2QCffbar2llbar_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2QCffbar2llbar_code", _wrap_Sigma2QCffbar2llbar_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2QCffbar2llbar_inFlux", _wrap_Sigma2QCffbar2llbar_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2QCffbar2llbar_isSChannel", _wrap_Sigma2QCffbar2llbar_isSChannel, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2QCffbar2llbar", _wrap_delete_Sigma2QCffbar2llbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2QCffbar2llbar_swigregister", Sigma2QCffbar2llbar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma1ffbar2Zp2XX", _wrap_new_Sigma1ffbar2Zp2XX, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Zp2XX_initProc", _wrap_Sigma1ffbar2Zp2XX_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Zp2XX_sigmaKin", _wrap_Sigma1ffbar2Zp2XX_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Zp2XX_sigmaHat", _wrap_Sigma1ffbar2Zp2XX_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Zp2XX_setIdColAcol", _wrap_Sigma1ffbar2Zp2XX_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Zp2XX_name", _wrap_Sigma1ffbar2Zp2XX_name, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Zp2XX_code", _wrap_Sigma1ffbar2Zp2XX_code, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Zp2XX_inFlux", _wrap_Sigma1ffbar2Zp2XX_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Zp2XX_resonanceA", _wrap_Sigma1ffbar2Zp2XX_resonanceA, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Zp2XX_isSChannel", _wrap_Sigma1ffbar2Zp2XX_isSChannel, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Zp2XX_gmZmode", _wrap_Sigma1ffbar2Zp2XX_gmZmode, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma1ffbar2Zp2XX", _wrap_delete_Sigma1ffbar2Zp2XX, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Zp2XX_swigregister", Sigma1ffbar2Zp2XX_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2Zpg2XXj", _wrap_new_Sigma2qqbar2Zpg2XXj, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Zpg2XXj_initProc", _wrap_Sigma2qqbar2Zpg2XXj_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Zpg2XXj_sigmaKin", _wrap_Sigma2qqbar2Zpg2XXj_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Zpg2XXj_sigmaHat", _wrap_Sigma2qqbar2Zpg2XXj_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Zpg2XXj_setIdColAcol", _wrap_Sigma2qqbar2Zpg2XXj_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Zpg2XXj_name", _wrap_Sigma2qqbar2Zpg2XXj_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Zpg2XXj_code", _wrap_Sigma2qqbar2Zpg2XXj_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Zpg2XXj_inFlux", _wrap_Sigma2qqbar2Zpg2XXj_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Zpg2XXj_resonanceA", _wrap_Sigma2qqbar2Zpg2XXj_resonanceA, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Zpg2XXj_id3Mass", _wrap_Sigma2qqbar2Zpg2XXj_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Zpg2XXj_id4Mass", _wrap_Sigma2qqbar2Zpg2XXj_id4Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Zpg2XXj_isSChannel", _wrap_Sigma2qqbar2Zpg2XXj_isSChannel, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Zpg2XXj_gmZmode", _wrap_Sigma2qqbar2Zpg2XXj_gmZmode, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2Zpg2XXj", _wrap_delete_Sigma2qqbar2Zpg2XXj, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Zpg2XXj_swigregister", Sigma2qqbar2Zpg2XXj_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qg2Zpq2XXj", _wrap_delete_Sigma2qg2Zpq2XXj, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Zpq2XXj_swigregister", Sigma2qg2Zpq2XXj_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbar2ZpH", _wrap_new_Sigma2ffbar2ZpH, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ZpH_initProc", _wrap_Sigma2ffbar2ZpH_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ZpH_sigmaKin", _wrap_Sigma2ffbar2ZpH_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ZpH_sigmaHat", _wrap_Sigma2ffbar2ZpH_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ZpH_setIdColAcol", _wrap_Sigma2ffbar2ZpH_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ZpH_name", _wrap_Sigma2ffbar2ZpH_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ZpH_code", _wrap_Sigma2ffbar2ZpH_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ZpH_inFlux", _wrap_Sigma2ffbar2ZpH_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ZpH_isSChannel", _wrap_Sigma2ffbar2ZpH_isSChannel, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ZpH_id3Mass", _wrap_Sigma2ffbar2ZpH_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ZpH_id4Mass", _wrap_Sigma2ffbar2ZpH_id4Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ZpH_resonanceA", _wrap_Sigma2ffbar2ZpH_resonanceA, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ZpH_gmZmode", _wrap_Sigma2ffbar2ZpH_gmZmode, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbar2ZpH", _wrap_delete_Sigma2ffbar2ZpH, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ZpH_swigregister", Sigma2ffbar2ZpH_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma1gg2S2XX", _wrap_new_Sigma1gg2S2XX, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2S2XX_initProc", _wrap_Sigma1gg2S2XX_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2S2XX_sigmaKin", _wrap_Sigma1gg2S2XX_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2S2XX_sigmaHat", _wrap_Sigma1gg2S2XX_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2S2XX_setIdColAcol", _wrap_Sigma1gg2S2XX_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2S2XX_name", _wrap_Sigma1gg2S2XX_name, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2S2XX_code", _wrap_Sigma1gg2S2XX_code, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2S2XX_inFlux", _wrap_Sigma1gg2S2XX_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2S2XX_resonanceA", _wrap_Sigma1gg2S2XX_resonanceA, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2S2XX_isSChannel", _wrap_Sigma1gg2S2XX_isSChannel, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma1gg2S2XX", _wrap_delete_Sigma1gg2S2XX, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2S2XX_swigregister", Sigma1gg2S2XX_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2gg2Sg2XXj", _wrap_new_Sigma2gg2Sg2XXj, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2Sg2XXj_initProc", _wrap_Sigma2gg2Sg2XXj_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2Sg2XXj_sigmaKin", _wrap_Sigma2gg2Sg2XXj_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2Sg2XXj_sigmaHat", _wrap_Sigma2gg2Sg2XXj_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2Sg2XXj_setIdColAcol", _wrap_Sigma2gg2Sg2XXj_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2Sg2XXj_name", _wrap_Sigma2gg2Sg2XXj_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2Sg2XXj_code", _wrap_Sigma2gg2Sg2XXj_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2Sg2XXj_inFlux", _wrap_Sigma2gg2Sg2XXj_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2Sg2XXj_resonanceA", _wrap_Sigma2gg2Sg2XXj_resonanceA, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2Sg2XXj_isSChannel", _wrap_Sigma2gg2Sg2XXj_isSChannel, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2Sg2XXj_id3Mass", _wrap_Sigma2gg2Sg2XXj_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2Sg2XXj_id4Mass", _wrap_Sigma2gg2Sg2XXj_id4Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2gg2Sg2XXj", _wrap_delete_Sigma2gg2Sg2XXj, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2Sg2XXj_swigregister", Sigma2gg2Sg2XXj_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qg2Sq2XXj", _wrap_new_Sigma2qg2Sq2XXj, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Sq2XXj_name", _wrap_Sigma2qg2Sq2XXj_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Sq2XXj_code", _wrap_Sigma2qg2Sq2XXj_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Sq2XXj_inFlux", _wrap_Sigma2qg2Sq2XXj_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Sq2XXj_isSChannel", _wrap_Sigma2qg2Sq2XXj_isSChannel, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qg2Sq2XXj", _wrap_delete_Sigma2qg2Sq2XXj, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Sq2XXj_swigregister", Sigma2qg2Sq2XXj_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qg2qgamma", _wrap_new_Sigma2qg2qgamma, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2qgamma_sigmaKin", _wrap_Sigma2qg2qgamma_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2qgamma_sigmaHat", _wrap_Sigma2qg2qgamma_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2qgamma_setIdColAcol", _wrap_Sigma2qg2qgamma_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2qgamma_name", _wrap_Sigma2qg2qgamma_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2qgamma_code", _wrap_Sigma2qg2qgamma_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2qgamma_inFlux", _wrap_Sigma2qg2qgamma_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qg2qgamma", _wrap_delete_Sigma2qg2qgamma, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2qgamma_swigregister", Sigma2qg2qgamma_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2ggamma", _wrap_new_Sigma2qqbar2ggamma, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2ggamma_sigmaKin", _wrap_Sigma2qqbar2ggamma_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2ggamma_sigmaHat", _wrap_Sigma2qqbar2ggamma_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2ggamma_setIdColAcol", _wrap_Sigma2qqbar2ggamma_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2ggamma_name", _wrap_Sigma2qqbar2ggamma_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2ggamma_code", _wrap_Sigma2qqbar2ggamma_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2ggamma_inFlux", _wrap_Sigma2qqbar2ggamma_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2ggamma", _wrap_delete_Sigma2qqbar2ggamma, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2ggamma_swigregister", Sigma2qqbar2ggamma_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2gg2ggamma", _wrap_new_Sigma2gg2ggamma, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2ggamma_initProc", _wrap_Sigma2gg2ggamma_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2ggamma_sigmaKin", _wrap_Sigma2gg2ggamma_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2ggamma_sigmaHat", _wrap_Sigma2gg2ggamma_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2ggamma_setIdColAcol", _wrap_Sigma2gg2ggamma_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2ggamma_name", _wrap_Sigma2gg2ggamma_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2ggamma_code", _wrap_Sigma2gg2ggamma_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2ggamma_inFlux", _wrap_Sigma2gg2ggamma_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2gg2ggamma", _wrap_delete_Sigma2gg2ggamma, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2ggamma_swigregister", Sigma2gg2ggamma_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbar2gammagamma", _wrap_new_Sigma2ffbar2gammagamma, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gammagamma_sigmaKin", _wrap_Sigma2ffbar2gammagamma_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gammagamma_sigmaHat", _wrap_Sigma2ffbar2gammagamma_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gammagamma_setIdColAcol", _wrap_Sigma2ffbar2gammagamma_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gammagamma_name", _wrap_Sigma2ffbar2gammagamma_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gammagamma_code", _wrap_Sigma2ffbar2gammagamma_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gammagamma_inFlux", _wrap_Sigma2ffbar2gammagamma_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbar2gammagamma", _wrap_delete_Sigma2ffbar2gammagamma, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gammagamma_swigregister", Sigma2ffbar2gammagamma_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2gg2gammagamma", _wrap_new_Sigma2gg2gammagamma, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gammagamma_initProc", _wrap_Sigma2gg2gammagamma_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gammagamma_sigmaKin", _wrap_Sigma2gg2gammagamma_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gammagamma_sigmaHat", _wrap_Sigma2gg2gammagamma_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gammagamma_setIdColAcol", _wrap_Sigma2gg2gammagamma_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gammagamma_name", _wrap_Sigma2gg2gammagamma_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gammagamma_code", _wrap_Sigma2gg2gammagamma_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gammagamma_inFlux", _wrap_Sigma2gg2gammagamma_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2gg2gammagamma", _wrap_delete_Sigma2gg2gammagamma, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gammagamma_swigregister", Sigma2gg2gammagamma_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ff2fftgmZ", _wrap_new_Sigma2ff2fftgmZ, METH_VARARGS, NULL},
	 { (char *)"Sigma2ff2fftgmZ_initProc", _wrap_Sigma2ff2fftgmZ_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2ff2fftgmZ_sigmaKin", _wrap_Sigma2ff2fftgmZ_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ff2fftgmZ_sigmaHat", _wrap_Sigma2ff2fftgmZ_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ff2fftgmZ_setIdColAcol", _wrap_Sigma2ff2fftgmZ_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ff2fftgmZ_name", _wrap_Sigma2ff2fftgmZ_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ff2fftgmZ_code", _wrap_Sigma2ff2fftgmZ_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ff2fftgmZ_inFlux", _wrap_Sigma2ff2fftgmZ_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ff2fftgmZ", _wrap_delete_Sigma2ff2fftgmZ, METH_VARARGS, NULL},
	 { (char *)"Sigma2ff2fftgmZ_swigregister", Sigma2ff2fftgmZ_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ff2fftW", _wrap_new_Sigma2ff2fftW, METH_VARARGS, NULL},
	 { (char *)"Sigma2ff2fftW_initProc", _wrap_Sigma2ff2fftW_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2ff2fftW_sigmaKin", _wrap_Sigma2ff2fftW_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ff2fftW_sigmaHat", _wrap_Sigma2ff2fftW_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ff2fftW_setIdColAcol", _wrap_Sigma2ff2fftW_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ff2fftW_name", _wrap_Sigma2ff2fftW_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ff2fftW_code", _wrap_Sigma2ff2fftW_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ff2fftW_inFlux", _wrap_Sigma2ff2fftW_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ff2fftW", _wrap_delete_Sigma2ff2fftW, METH_VARARGS, NULL},
	 { (char *)"Sigma2ff2fftW_swigregister", Sigma2ff2fftW_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qq2QqtW", _wrap_new_Sigma2qq2QqtW, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2QqtW_initProc", _wrap_Sigma2qq2QqtW_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2QqtW_sigmaKin", _wrap_Sigma2qq2QqtW_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2QqtW_sigmaHat", _wrap_Sigma2qq2QqtW_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2QqtW_setIdColAcol", _wrap_Sigma2qq2QqtW_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2QqtW_weightDecay", _wrap_Sigma2qq2QqtW_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2QqtW_name", _wrap_Sigma2qq2QqtW_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2QqtW_code", _wrap_Sigma2qq2QqtW_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2QqtW_inFlux", _wrap_Sigma2qq2QqtW_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2QqtW_id3Mass", _wrap_Sigma2qq2QqtW_id3Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qq2QqtW", _wrap_delete_Sigma2qq2QqtW, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2QqtW_swigregister", Sigma2qq2QqtW_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma1ffbar2gmZ", _wrap_new_Sigma1ffbar2gmZ, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2gmZ_initProc", _wrap_Sigma1ffbar2gmZ_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2gmZ_sigmaKin", _wrap_Sigma1ffbar2gmZ_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2gmZ_sigmaHat", _wrap_Sigma1ffbar2gmZ_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2gmZ_setIdColAcol", _wrap_Sigma1ffbar2gmZ_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2gmZ_weightDecay", _wrap_Sigma1ffbar2gmZ_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2gmZ_name", _wrap_Sigma1ffbar2gmZ_name, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2gmZ_code", _wrap_Sigma1ffbar2gmZ_code, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2gmZ_inFlux", _wrap_Sigma1ffbar2gmZ_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2gmZ_resonanceA", _wrap_Sigma1ffbar2gmZ_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma1ffbar2gmZ", _wrap_delete_Sigma1ffbar2gmZ, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2gmZ_swigregister", Sigma1ffbar2gmZ_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma1ffbar2W", _wrap_new_Sigma1ffbar2W, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2W_initProc", _wrap_Sigma1ffbar2W_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2W_sigmaKin", _wrap_Sigma1ffbar2W_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2W_sigmaHat", _wrap_Sigma1ffbar2W_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2W_setIdColAcol", _wrap_Sigma1ffbar2W_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2W_weightDecay", _wrap_Sigma1ffbar2W_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2W_name", _wrap_Sigma1ffbar2W_name, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2W_code", _wrap_Sigma1ffbar2W_code, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2W_inFlux", _wrap_Sigma1ffbar2W_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2W_resonanceA", _wrap_Sigma1ffbar2W_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma1ffbar2W", _wrap_delete_Sigma1ffbar2W, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2W_swigregister", Sigma1ffbar2W_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbar2ffbarsgm", _wrap_new_Sigma2ffbar2ffbarsgm, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsgm_sigmaKin", _wrap_Sigma2ffbar2ffbarsgm_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsgm_sigmaHat", _wrap_Sigma2ffbar2ffbarsgm_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsgm_setIdColAcol", _wrap_Sigma2ffbar2ffbarsgm_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsgm_name", _wrap_Sigma2ffbar2ffbarsgm_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsgm_code", _wrap_Sigma2ffbar2ffbarsgm_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsgm_inFlux", _wrap_Sigma2ffbar2ffbarsgm_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsgm_isSChannel", _wrap_Sigma2ffbar2ffbarsgm_isSChannel, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbar2ffbarsgm", _wrap_delete_Sigma2ffbar2ffbarsgm, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsgm_swigregister", Sigma2ffbar2ffbarsgm_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbar2ffbarsgmZ", _wrap_new_Sigma2ffbar2ffbarsgmZ, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsgmZ_initProc", _wrap_Sigma2ffbar2ffbarsgmZ_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsgmZ_sigmaKin", _wrap_Sigma2ffbar2ffbarsgmZ_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsgmZ_sigmaHat", _wrap_Sigma2ffbar2ffbarsgmZ_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsgmZ_setIdColAcol", _wrap_Sigma2ffbar2ffbarsgmZ_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsgmZ_name", _wrap_Sigma2ffbar2ffbarsgmZ_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsgmZ_code", _wrap_Sigma2ffbar2ffbarsgmZ_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsgmZ_inFlux", _wrap_Sigma2ffbar2ffbarsgmZ_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsgmZ_isSChannel", _wrap_Sigma2ffbar2ffbarsgmZ_isSChannel, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsgmZ_idSChannel", _wrap_Sigma2ffbar2ffbarsgmZ_idSChannel, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsgmZ_resonanceA", _wrap_Sigma2ffbar2ffbarsgmZ_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbar2ffbarsgmZ", _wrap_delete_Sigma2ffbar2ffbarsgmZ, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsgmZ_swigregister", Sigma2ffbar2ffbarsgmZ_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbar2ffbarsW", _wrap_new_Sigma2ffbar2ffbarsW, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsW_initProc", _wrap_Sigma2ffbar2ffbarsW_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsW_sigmaKin", _wrap_Sigma2ffbar2ffbarsW_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsW_sigmaHat", _wrap_Sigma2ffbar2ffbarsW_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsW_setIdColAcol", _wrap_Sigma2ffbar2ffbarsW_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsW_name", _wrap_Sigma2ffbar2ffbarsW_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsW_code", _wrap_Sigma2ffbar2ffbarsW_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsW_inFlux", _wrap_Sigma2ffbar2ffbarsW_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsW_isSChannel", _wrap_Sigma2ffbar2ffbarsW_isSChannel, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsW_idSChannel", _wrap_Sigma2ffbar2ffbarsW_idSChannel, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsW_resonanceA", _wrap_Sigma2ffbar2ffbarsW_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbar2ffbarsW", _wrap_delete_Sigma2ffbar2ffbarsW, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ffbarsW_swigregister", Sigma2ffbar2ffbarsW_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbar2FFbarsgmZ", _wrap_new_Sigma2ffbar2FFbarsgmZ, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FFbarsgmZ_initProc", _wrap_Sigma2ffbar2FFbarsgmZ_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FFbarsgmZ_sigmaKin", _wrap_Sigma2ffbar2FFbarsgmZ_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FFbarsgmZ_sigmaHat", _wrap_Sigma2ffbar2FFbarsgmZ_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FFbarsgmZ_setIdColAcol", _wrap_Sigma2ffbar2FFbarsgmZ_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FFbarsgmZ_weightDecay", _wrap_Sigma2ffbar2FFbarsgmZ_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FFbarsgmZ_name", _wrap_Sigma2ffbar2FFbarsgmZ_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FFbarsgmZ_code", _wrap_Sigma2ffbar2FFbarsgmZ_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FFbarsgmZ_inFlux", _wrap_Sigma2ffbar2FFbarsgmZ_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FFbarsgmZ_isSChannel", _wrap_Sigma2ffbar2FFbarsgmZ_isSChannel, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FFbarsgmZ_id3Mass", _wrap_Sigma2ffbar2FFbarsgmZ_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FFbarsgmZ_id4Mass", _wrap_Sigma2ffbar2FFbarsgmZ_id4Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FFbarsgmZ_resonanceA", _wrap_Sigma2ffbar2FFbarsgmZ_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbar2FFbarsgmZ", _wrap_delete_Sigma2ffbar2FFbarsgmZ, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FFbarsgmZ_swigregister", Sigma2ffbar2FFbarsgmZ_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbar2FfbarsW", _wrap_new_Sigma2ffbar2FfbarsW, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FfbarsW_initProc", _wrap_Sigma2ffbar2FfbarsW_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FfbarsW_sigmaKin", _wrap_Sigma2ffbar2FfbarsW_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FfbarsW_sigmaHat", _wrap_Sigma2ffbar2FfbarsW_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FfbarsW_setIdColAcol", _wrap_Sigma2ffbar2FfbarsW_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FfbarsW_weightDecay", _wrap_Sigma2ffbar2FfbarsW_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FfbarsW_name", _wrap_Sigma2ffbar2FfbarsW_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FfbarsW_code", _wrap_Sigma2ffbar2FfbarsW_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FfbarsW_inFlux", _wrap_Sigma2ffbar2FfbarsW_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FfbarsW_isSChannel", _wrap_Sigma2ffbar2FfbarsW_isSChannel, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FfbarsW_id3Mass", _wrap_Sigma2ffbar2FfbarsW_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FfbarsW_id4Mass", _wrap_Sigma2ffbar2FfbarsW_id4Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FfbarsW_resonanceA", _wrap_Sigma2ffbar2FfbarsW_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbar2FfbarsW", _wrap_delete_Sigma2ffbar2FfbarsW, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2FfbarsW_swigregister", Sigma2ffbar2FfbarsW_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbargmZWgmZW", _wrap_new_Sigma2ffbargmZWgmZW, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbargmZWgmZW", _wrap_delete_Sigma2ffbargmZWgmZW, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbargmZWgmZW_swigregister", Sigma2ffbargmZWgmZW_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbar2gmZgmZ", _wrap_new_Sigma2ffbar2gmZgmZ, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gmZgmZ_initProc", _wrap_Sigma2ffbar2gmZgmZ_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gmZgmZ_sigmaKin", _wrap_Sigma2ffbar2gmZgmZ_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gmZgmZ_sigmaHat", _wrap_Sigma2ffbar2gmZgmZ_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gmZgmZ_setIdColAcol", _wrap_Sigma2ffbar2gmZgmZ_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gmZgmZ_weightDecayFlav", _wrap_Sigma2ffbar2gmZgmZ_weightDecayFlav, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gmZgmZ_weightDecay", _wrap_Sigma2ffbar2gmZgmZ_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gmZgmZ_name", _wrap_Sigma2ffbar2gmZgmZ_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gmZgmZ_code", _wrap_Sigma2ffbar2gmZgmZ_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gmZgmZ_inFlux", _wrap_Sigma2ffbar2gmZgmZ_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gmZgmZ_id3Mass", _wrap_Sigma2ffbar2gmZgmZ_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gmZgmZ_id4Mass", _wrap_Sigma2ffbar2gmZgmZ_id4Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbar2gmZgmZ", _wrap_delete_Sigma2ffbar2gmZgmZ, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gmZgmZ_swigregister", Sigma2ffbar2gmZgmZ_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbar2ZW", _wrap_new_Sigma2ffbar2ZW, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ZW_initProc", _wrap_Sigma2ffbar2ZW_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ZW_sigmaKin", _wrap_Sigma2ffbar2ZW_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ZW_sigmaHat", _wrap_Sigma2ffbar2ZW_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ZW_setIdColAcol", _wrap_Sigma2ffbar2ZW_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ZW_weightDecay", _wrap_Sigma2ffbar2ZW_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ZW_name", _wrap_Sigma2ffbar2ZW_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ZW_code", _wrap_Sigma2ffbar2ZW_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ZW_inFlux", _wrap_Sigma2ffbar2ZW_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ZW_id3Mass", _wrap_Sigma2ffbar2ZW_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ZW_id4Mass", _wrap_Sigma2ffbar2ZW_id4Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ZW_resonanceA", _wrap_Sigma2ffbar2ZW_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbar2ZW", _wrap_delete_Sigma2ffbar2ZW, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2ZW_swigregister", Sigma2ffbar2ZW_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbar2WW", _wrap_new_Sigma2ffbar2WW, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2WW_initProc", _wrap_Sigma2ffbar2WW_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2WW_sigmaKin", _wrap_Sigma2ffbar2WW_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2WW_sigmaHat", _wrap_Sigma2ffbar2WW_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2WW_setIdColAcol", _wrap_Sigma2ffbar2WW_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2WW_weightDecay", _wrap_Sigma2ffbar2WW_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2WW_name", _wrap_Sigma2ffbar2WW_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2WW_code", _wrap_Sigma2ffbar2WW_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2WW_inFlux", _wrap_Sigma2ffbar2WW_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2WW_id3Mass", _wrap_Sigma2ffbar2WW_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2WW_id4Mass", _wrap_Sigma2ffbar2WW_id4Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2WW_resonanceA", _wrap_Sigma2ffbar2WW_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbar2WW", _wrap_delete_Sigma2ffbar2WW, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2WW_swigregister", Sigma2ffbar2WW_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbargmZggm", _wrap_new_Sigma2ffbargmZggm, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbargmZggm_initProc", _wrap_Sigma2ffbargmZggm_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbargmZggm_weightDecay", _wrap_Sigma2ffbargmZggm_weightDecay, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbargmZggm", _wrap_delete_Sigma2ffbargmZggm, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbargmZggm_swigregister", Sigma2ffbargmZggm_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2gmZg", _wrap_new_Sigma2qqbar2gmZg, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gmZg_sigmaKin", _wrap_Sigma2qqbar2gmZg_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gmZg_sigmaHat", _wrap_Sigma2qqbar2gmZg_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gmZg_setIdColAcol", _wrap_Sigma2qqbar2gmZg_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gmZg_name", _wrap_Sigma2qqbar2gmZg_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gmZg_code", _wrap_Sigma2qqbar2gmZg_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gmZg_inFlux", _wrap_Sigma2qqbar2gmZg_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gmZg_id3Mass", _wrap_Sigma2qqbar2gmZg_id3Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2gmZg", _wrap_delete_Sigma2qqbar2gmZg, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gmZg_swigregister", Sigma2qqbar2gmZg_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qg2gmZq", _wrap_new_Sigma2qg2gmZq, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2gmZq_sigmaKin", _wrap_Sigma2qg2gmZq_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2gmZq_sigmaHat", _wrap_Sigma2qg2gmZq_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2gmZq_setIdColAcol", _wrap_Sigma2qg2gmZq_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2gmZq_name", _wrap_Sigma2qg2gmZq_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2gmZq_code", _wrap_Sigma2qg2gmZq_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2gmZq_inFlux", _wrap_Sigma2qg2gmZq_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2gmZq_id3Mass", _wrap_Sigma2qg2gmZq_id3Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qg2gmZq", _wrap_delete_Sigma2qg2gmZq, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2gmZq_swigregister", Sigma2qg2gmZq_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbar2gmZgm", _wrap_new_Sigma2ffbar2gmZgm, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gmZgm_sigmaKin", _wrap_Sigma2ffbar2gmZgm_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gmZgm_sigmaHat", _wrap_Sigma2ffbar2gmZgm_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gmZgm_setIdColAcol", _wrap_Sigma2ffbar2gmZgm_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gmZgm_name", _wrap_Sigma2ffbar2gmZgm_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gmZgm_code", _wrap_Sigma2ffbar2gmZgm_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gmZgm_inFlux", _wrap_Sigma2ffbar2gmZgm_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gmZgm_id3Mass", _wrap_Sigma2ffbar2gmZgm_id3Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbar2gmZgm", _wrap_delete_Sigma2ffbar2gmZgm, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2gmZgm_swigregister", Sigma2ffbar2gmZgm_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2fgm2gmZf", _wrap_new_Sigma2fgm2gmZf, METH_VARARGS, NULL},
	 { (char *)"Sigma2fgm2gmZf_sigmaKin", _wrap_Sigma2fgm2gmZf_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2fgm2gmZf_sigmaHat", _wrap_Sigma2fgm2gmZf_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2fgm2gmZf_setIdColAcol", _wrap_Sigma2fgm2gmZf_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2fgm2gmZf_name", _wrap_Sigma2fgm2gmZf_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2fgm2gmZf_code", _wrap_Sigma2fgm2gmZf_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2fgm2gmZf_inFlux", _wrap_Sigma2fgm2gmZf_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2fgm2gmZf_id3Mass", _wrap_Sigma2fgm2gmZf_id3Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2fgm2gmZf", _wrap_delete_Sigma2fgm2gmZf, METH_VARARGS, NULL},
	 { (char *)"Sigma2fgm2gmZf_swigregister", Sigma2fgm2gmZf_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbarWggm", _wrap_new_Sigma2ffbarWggm, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbarWggm_weightDecay", _wrap_Sigma2ffbarWggm_weightDecay, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbarWggm", _wrap_delete_Sigma2ffbarWggm, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbarWggm_swigregister", Sigma2ffbarWggm_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2Wg", _wrap_new_Sigma2qqbar2Wg, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Wg_initProc", _wrap_Sigma2qqbar2Wg_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Wg_sigmaKin", _wrap_Sigma2qqbar2Wg_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Wg_sigmaHat", _wrap_Sigma2qqbar2Wg_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Wg_setIdColAcol", _wrap_Sigma2qqbar2Wg_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Wg_name", _wrap_Sigma2qqbar2Wg_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Wg_code", _wrap_Sigma2qqbar2Wg_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Wg_inFlux", _wrap_Sigma2qqbar2Wg_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Wg_id3Mass", _wrap_Sigma2qqbar2Wg_id3Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2Wg", _wrap_delete_Sigma2qqbar2Wg, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Wg_swigregister", Sigma2qqbar2Wg_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qg2Wq", _wrap_new_Sigma2qg2Wq, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Wq_initProc", _wrap_Sigma2qg2Wq_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Wq_sigmaKin", _wrap_Sigma2qg2Wq_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Wq_sigmaHat", _wrap_Sigma2qg2Wq_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Wq_setIdColAcol", _wrap_Sigma2qg2Wq_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Wq_name", _wrap_Sigma2qg2Wq_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Wq_code", _wrap_Sigma2qg2Wq_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Wq_inFlux", _wrap_Sigma2qg2Wq_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Wq_id3Mass", _wrap_Sigma2qg2Wq_id3Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qg2Wq", _wrap_delete_Sigma2qg2Wq, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Wq_swigregister", Sigma2qg2Wq_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbar2Wgm", _wrap_new_Sigma2ffbar2Wgm, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2Wgm_initProc", _wrap_Sigma2ffbar2Wgm_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2Wgm_sigmaKin", _wrap_Sigma2ffbar2Wgm_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2Wgm_sigmaHat", _wrap_Sigma2ffbar2Wgm_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2Wgm_setIdColAcol", _wrap_Sigma2ffbar2Wgm_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2Wgm_name", _wrap_Sigma2ffbar2Wgm_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2Wgm_code", _wrap_Sigma2ffbar2Wgm_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2Wgm_inFlux", _wrap_Sigma2ffbar2Wgm_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2Wgm_id3Mass", _wrap_Sigma2ffbar2Wgm_id3Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbar2Wgm", _wrap_delete_Sigma2ffbar2Wgm, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2Wgm_swigregister", Sigma2ffbar2Wgm_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2fgm2Wf", _wrap_new_Sigma2fgm2Wf, METH_VARARGS, NULL},
	 { (char *)"Sigma2fgm2Wf_initProc", _wrap_Sigma2fgm2Wf_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2fgm2Wf_sigmaKin", _wrap_Sigma2fgm2Wf_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2fgm2Wf_sigmaHat", _wrap_Sigma2fgm2Wf_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2fgm2Wf_setIdColAcol", _wrap_Sigma2fgm2Wf_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2fgm2Wf_name", _wrap_Sigma2fgm2Wf_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2fgm2Wf_code", _wrap_Sigma2fgm2Wf_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2fgm2Wf_inFlux", _wrap_Sigma2fgm2Wf_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2fgm2Wf_id3Mass", _wrap_Sigma2fgm2Wf_id3Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2fgm2Wf", _wrap_delete_Sigma2fgm2Wf, METH_VARARGS, NULL},
	 { (char *)"Sigma2fgm2Wf_swigregister", Sigma2fgm2Wf_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2gmgm2ffbar", _wrap_new_Sigma2gmgm2ffbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2gmgm2ffbar_initProc", _wrap_Sigma2gmgm2ffbar_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2gmgm2ffbar_sigmaKin", _wrap_Sigma2gmgm2ffbar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2gmgm2ffbar_sigmaHat", _wrap_Sigma2gmgm2ffbar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2gmgm2ffbar_setIdColAcol", _wrap_Sigma2gmgm2ffbar_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2gmgm2ffbar_name", _wrap_Sigma2gmgm2ffbar_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2gmgm2ffbar_code", _wrap_Sigma2gmgm2ffbar_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2gmgm2ffbar_inFlux", _wrap_Sigma2gmgm2ffbar_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2gmgm2ffbar_id3Mass", _wrap_Sigma2gmgm2ffbar_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2gmgm2ffbar_id4Mass", _wrap_Sigma2gmgm2ffbar_id4Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2gmgm2ffbar", _wrap_delete_Sigma2gmgm2ffbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2gmgm2ffbar_swigregister", Sigma2gmgm2ffbar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ggm2qqbar", _wrap_new_Sigma2ggm2qqbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2ggm2qqbar_initProc", _wrap_Sigma2ggm2qqbar_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2ggm2qqbar_sigmaKin", _wrap_Sigma2ggm2qqbar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ggm2qqbar_sigmaHat", _wrap_Sigma2ggm2qqbar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ggm2qqbar_setIdColAcol", _wrap_Sigma2ggm2qqbar_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ggm2qqbar_name", _wrap_Sigma2ggm2qqbar_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ggm2qqbar_code", _wrap_Sigma2ggm2qqbar_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ggm2qqbar_inFlux", _wrap_Sigma2ggm2qqbar_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2ggm2qqbar_id3Mass", _wrap_Sigma2ggm2qqbar_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ggm2qqbar_id4Mass", _wrap_Sigma2ggm2qqbar_id4Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ggm2qqbar", _wrap_delete_Sigma2ggm2qqbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2ggm2qqbar_swigregister", Sigma2ggm2qqbar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qgm2qg", _wrap_new_Sigma2qgm2qg, METH_VARARGS, NULL},
	 { (char *)"Sigma2qgm2qg_initProc", _wrap_Sigma2qgm2qg_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qgm2qg_sigmaKin", _wrap_Sigma2qgm2qg_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qgm2qg_sigmaHat", _wrap_Sigma2qgm2qg_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qgm2qg_setIdColAcol", _wrap_Sigma2qgm2qg_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qgm2qg_name", _wrap_Sigma2qgm2qg_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qgm2qg_code", _wrap_Sigma2qgm2qg_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qgm2qg_inFlux", _wrap_Sigma2qgm2qg_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qgm2qg", _wrap_delete_Sigma2qgm2qg, METH_VARARGS, NULL},
	 { (char *)"Sigma2qgm2qg_swigregister", Sigma2qgm2qg_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qgm2qgm", _wrap_new_Sigma2qgm2qgm, METH_VARARGS, NULL},
	 { (char *)"Sigma2qgm2qgm_initProc", _wrap_Sigma2qgm2qgm_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qgm2qgm_sigmaKin", _wrap_Sigma2qgm2qgm_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qgm2qgm_sigmaHat", _wrap_Sigma2qgm2qgm_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qgm2qgm_setIdColAcol", _wrap_Sigma2qgm2qgm_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qgm2qgm_name", _wrap_Sigma2qgm2qgm_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qgm2qgm_code", _wrap_Sigma2qgm2qgm_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qgm2qgm_inFlux", _wrap_Sigma2qgm2qgm_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qgm2qgm", _wrap_delete_Sigma2qgm2qgm, METH_VARARGS, NULL},
	 { (char *)"Sigma2qgm2qgm_swigregister", Sigma2qgm2qgm_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma1gg2GravitonStar", _wrap_new_Sigma1gg2GravitonStar, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2GravitonStar_initProc", _wrap_Sigma1gg2GravitonStar_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2GravitonStar_sigmaKin", _wrap_Sigma1gg2GravitonStar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2GravitonStar_sigmaHat", _wrap_Sigma1gg2GravitonStar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2GravitonStar_setIdColAcol", _wrap_Sigma1gg2GravitonStar_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2GravitonStar_weightDecay", _wrap_Sigma1gg2GravitonStar_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2GravitonStar_name", _wrap_Sigma1gg2GravitonStar_name, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2GravitonStar_code", _wrap_Sigma1gg2GravitonStar_code, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2GravitonStar_inFlux", _wrap_Sigma1gg2GravitonStar_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2GravitonStar_resonanceA", _wrap_Sigma1gg2GravitonStar_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma1gg2GravitonStar", _wrap_delete_Sigma1gg2GravitonStar, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2GravitonStar_swigregister", Sigma1gg2GravitonStar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma1ffbar2GravitonStar", _wrap_new_Sigma1ffbar2GravitonStar, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2GravitonStar_initProc", _wrap_Sigma1ffbar2GravitonStar_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2GravitonStar_sigmaKin", _wrap_Sigma1ffbar2GravitonStar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2GravitonStar_sigmaHat", _wrap_Sigma1ffbar2GravitonStar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2GravitonStar_setIdColAcol", _wrap_Sigma1ffbar2GravitonStar_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2GravitonStar_weightDecay", _wrap_Sigma1ffbar2GravitonStar_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2GravitonStar_name", _wrap_Sigma1ffbar2GravitonStar_name, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2GravitonStar_code", _wrap_Sigma1ffbar2GravitonStar_code, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2GravitonStar_inFlux", _wrap_Sigma1ffbar2GravitonStar_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2GravitonStar_resonanceA", _wrap_Sigma1ffbar2GravitonStar_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma1ffbar2GravitonStar", _wrap_delete_Sigma1ffbar2GravitonStar, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2GravitonStar_swigregister", Sigma1ffbar2GravitonStar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma1qqbar2KKgluonStar", _wrap_new_Sigma1qqbar2KKgluonStar, METH_VARARGS, NULL},
	 { (char *)"Sigma1qqbar2KKgluonStar_initProc", _wrap_Sigma1qqbar2KKgluonStar_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma1qqbar2KKgluonStar_sigmaKin", _wrap_Sigma1qqbar2KKgluonStar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma1qqbar2KKgluonStar_sigmaHat", _wrap_Sigma1qqbar2KKgluonStar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma1qqbar2KKgluonStar_setIdColAcol", _wrap_Sigma1qqbar2KKgluonStar_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma1qqbar2KKgluonStar_weightDecay", _wrap_Sigma1qqbar2KKgluonStar_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma1qqbar2KKgluonStar_name", _wrap_Sigma1qqbar2KKgluonStar_name, METH_VARARGS, NULL},
	 { (char *)"Sigma1qqbar2KKgluonStar_code", _wrap_Sigma1qqbar2KKgluonStar_code, METH_VARARGS, NULL},
	 { (char *)"Sigma1qqbar2KKgluonStar_inFlux", _wrap_Sigma1qqbar2KKgluonStar_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma1qqbar2KKgluonStar_resonanceA", _wrap_Sigma1qqbar2KKgluonStar_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma1qqbar2KKgluonStar", _wrap_delete_Sigma1qqbar2KKgluonStar, METH_VARARGS, NULL},
	 { (char *)"Sigma1qqbar2KKgluonStar_swigregister", Sigma1qqbar2KKgluonStar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2gg2GravitonStarg", _wrap_new_Sigma2gg2GravitonStarg, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2GravitonStarg_initProc", _wrap_Sigma2gg2GravitonStarg_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2GravitonStarg_sigmaKin", _wrap_Sigma2gg2GravitonStarg_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2GravitonStarg_sigmaHat", _wrap_Sigma2gg2GravitonStarg_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2GravitonStarg_setIdColAcol", _wrap_Sigma2gg2GravitonStarg_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2GravitonStarg_weightDecay", _wrap_Sigma2gg2GravitonStarg_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2GravitonStarg_name", _wrap_Sigma2gg2GravitonStarg_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2GravitonStarg_code", _wrap_Sigma2gg2GravitonStarg_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2GravitonStarg_inFlux", _wrap_Sigma2gg2GravitonStarg_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2GravitonStarg_id3Mass", _wrap_Sigma2gg2GravitonStarg_id3Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2gg2GravitonStarg", _wrap_delete_Sigma2gg2GravitonStarg, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2GravitonStarg_swigregister", Sigma2gg2GravitonStarg_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qg2GravitonStarq", _wrap_new_Sigma2qg2GravitonStarq, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2GravitonStarq_initProc", _wrap_Sigma2qg2GravitonStarq_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2GravitonStarq_sigmaKin", _wrap_Sigma2qg2GravitonStarq_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2GravitonStarq_sigmaHat", _wrap_Sigma2qg2GravitonStarq_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2GravitonStarq_setIdColAcol", _wrap_Sigma2qg2GravitonStarq_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2GravitonStarq_weightDecay", _wrap_Sigma2qg2GravitonStarq_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2GravitonStarq_name", _wrap_Sigma2qg2GravitonStarq_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2GravitonStarq_code", _wrap_Sigma2qg2GravitonStarq_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2GravitonStarq_inFlux", _wrap_Sigma2qg2GravitonStarq_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2GravitonStarq_id3Mass", _wrap_Sigma2qg2GravitonStarq_id3Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qg2GravitonStarq", _wrap_delete_Sigma2qg2GravitonStarq, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2GravitonStarq_swigregister", Sigma2qg2GravitonStarq_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2GravitonStarg", _wrap_new_Sigma2qqbar2GravitonStarg, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2GravitonStarg_initProc", _wrap_Sigma2qqbar2GravitonStarg_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2GravitonStarg_sigmaKin", _wrap_Sigma2qqbar2GravitonStarg_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2GravitonStarg_sigmaHat", _wrap_Sigma2qqbar2GravitonStarg_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2GravitonStarg_setIdColAcol", _wrap_Sigma2qqbar2GravitonStarg_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2GravitonStarg_weightDecay", _wrap_Sigma2qqbar2GravitonStarg_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2GravitonStarg_name", _wrap_Sigma2qqbar2GravitonStarg_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2GravitonStarg_code", _wrap_Sigma2qqbar2GravitonStarg_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2GravitonStarg_inFlux", _wrap_Sigma2qqbar2GravitonStarg_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2GravitonStarg_id3Mass", _wrap_Sigma2qqbar2GravitonStarg_id3Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2GravitonStarg", _wrap_delete_Sigma2qqbar2GravitonStarg, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2GravitonStarg_swigregister", Sigma2qqbar2GravitonStarg_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbar2TEVffbar", _wrap_new_Sigma2ffbar2TEVffbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2TEVffbar_initProc", _wrap_Sigma2ffbar2TEVffbar_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2TEVffbar_sigmaKin", _wrap_Sigma2ffbar2TEVffbar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2TEVffbar_sigmaHat", _wrap_Sigma2ffbar2TEVffbar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2TEVffbar_setIdColAcol", _wrap_Sigma2ffbar2TEVffbar_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2TEVffbar_weightDecay", _wrap_Sigma2ffbar2TEVffbar_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2TEVffbar_name", _wrap_Sigma2ffbar2TEVffbar_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2TEVffbar_code", _wrap_Sigma2ffbar2TEVffbar_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2TEVffbar_inFlux", _wrap_Sigma2ffbar2TEVffbar_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2TEVffbar_isSChannel", _wrap_Sigma2ffbar2TEVffbar_isSChannel, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2TEVffbar_idSChannel", _wrap_Sigma2ffbar2TEVffbar_idSChannel, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2TEVffbar_id3Mass", _wrap_Sigma2ffbar2TEVffbar_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2TEVffbar_id4Mass", _wrap_Sigma2ffbar2TEVffbar_id4Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2TEVffbar_resonanceA", _wrap_Sigma2ffbar2TEVffbar_resonanceA, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2TEVffbar_resonanceB", _wrap_Sigma2ffbar2TEVffbar_resonanceB, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbar2TEVffbar", _wrap_delete_Sigma2ffbar2TEVffbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2TEVffbar_swigregister", Sigma2ffbar2TEVffbar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2gg2LEDUnparticleg", _wrap_new_Sigma2gg2LEDUnparticleg, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDUnparticleg_initProc", _wrap_Sigma2gg2LEDUnparticleg_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDUnparticleg_sigmaKin", _wrap_Sigma2gg2LEDUnparticleg_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDUnparticleg_sigmaHat", _wrap_Sigma2gg2LEDUnparticleg_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDUnparticleg_setIdColAcol", _wrap_Sigma2gg2LEDUnparticleg_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDUnparticleg_name", _wrap_Sigma2gg2LEDUnparticleg_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDUnparticleg_code", _wrap_Sigma2gg2LEDUnparticleg_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDUnparticleg_inFlux", _wrap_Sigma2gg2LEDUnparticleg_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDUnparticleg_id3Mass", _wrap_Sigma2gg2LEDUnparticleg_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDUnparticleg_id4Mass", _wrap_Sigma2gg2LEDUnparticleg_id4Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2gg2LEDUnparticleg", _wrap_delete_Sigma2gg2LEDUnparticleg, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDUnparticleg_swigregister", Sigma2gg2LEDUnparticleg_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qg2LEDUnparticleq", _wrap_new_Sigma2qg2LEDUnparticleq, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LEDUnparticleq_initProc", _wrap_Sigma2qg2LEDUnparticleq_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LEDUnparticleq_sigmaKin", _wrap_Sigma2qg2LEDUnparticleq_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LEDUnparticleq_sigmaHat", _wrap_Sigma2qg2LEDUnparticleq_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LEDUnparticleq_setIdColAcol", _wrap_Sigma2qg2LEDUnparticleq_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LEDUnparticleq_name", _wrap_Sigma2qg2LEDUnparticleq_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LEDUnparticleq_code", _wrap_Sigma2qg2LEDUnparticleq_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LEDUnparticleq_inFlux", _wrap_Sigma2qg2LEDUnparticleq_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LEDUnparticleq_id3Mass", _wrap_Sigma2qg2LEDUnparticleq_id3Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qg2LEDUnparticleq", _wrap_delete_Sigma2qg2LEDUnparticleq, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LEDUnparticleq_swigregister", Sigma2qg2LEDUnparticleq_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2LEDUnparticleg", _wrap_new_Sigma2qqbar2LEDUnparticleg, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDUnparticleg_initProc", _wrap_Sigma2qqbar2LEDUnparticleg_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDUnparticleg_sigmaKin", _wrap_Sigma2qqbar2LEDUnparticleg_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDUnparticleg_sigmaHat", _wrap_Sigma2qqbar2LEDUnparticleg_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDUnparticleg_setIdColAcol", _wrap_Sigma2qqbar2LEDUnparticleg_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDUnparticleg_name", _wrap_Sigma2qqbar2LEDUnparticleg_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDUnparticleg_code", _wrap_Sigma2qqbar2LEDUnparticleg_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDUnparticleg_inFlux", _wrap_Sigma2qqbar2LEDUnparticleg_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDUnparticleg_id3Mass", _wrap_Sigma2qqbar2LEDUnparticleg_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDUnparticleg_id4Mass", _wrap_Sigma2qqbar2LEDUnparticleg_id4Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2LEDUnparticleg", _wrap_delete_Sigma2qqbar2LEDUnparticleg, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDUnparticleg_swigregister", Sigma2qqbar2LEDUnparticleg_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbar2LEDUnparticleZ", _wrap_new_Sigma2ffbar2LEDUnparticleZ, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDUnparticleZ_initProc", _wrap_Sigma2ffbar2LEDUnparticleZ_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDUnparticleZ_sigmaKin", _wrap_Sigma2ffbar2LEDUnparticleZ_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDUnparticleZ_sigmaHat", _wrap_Sigma2ffbar2LEDUnparticleZ_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDUnparticleZ_setIdColAcol", _wrap_Sigma2ffbar2LEDUnparticleZ_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDUnparticleZ_name", _wrap_Sigma2ffbar2LEDUnparticleZ_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDUnparticleZ_code", _wrap_Sigma2ffbar2LEDUnparticleZ_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDUnparticleZ_inFlux", _wrap_Sigma2ffbar2LEDUnparticleZ_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDUnparticleZ_id3Mass", _wrap_Sigma2ffbar2LEDUnparticleZ_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDUnparticleZ_id4Mass", _wrap_Sigma2ffbar2LEDUnparticleZ_id4Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDUnparticleZ_resonanceA", _wrap_Sigma2ffbar2LEDUnparticleZ_resonanceA, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDUnparticleZ_gmZmode", _wrap_Sigma2ffbar2LEDUnparticleZ_gmZmode, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbar2LEDUnparticleZ", _wrap_delete_Sigma2ffbar2LEDUnparticleZ, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDUnparticleZ_swigregister", Sigma2ffbar2LEDUnparticleZ_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbar2LEDUnparticlegamma", _wrap_new_Sigma2ffbar2LEDUnparticlegamma, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDUnparticlegamma_initProc", _wrap_Sigma2ffbar2LEDUnparticlegamma_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDUnparticlegamma_sigmaKin", _wrap_Sigma2ffbar2LEDUnparticlegamma_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDUnparticlegamma_sigmaHat", _wrap_Sigma2ffbar2LEDUnparticlegamma_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDUnparticlegamma_setIdColAcol", _wrap_Sigma2ffbar2LEDUnparticlegamma_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDUnparticlegamma_name", _wrap_Sigma2ffbar2LEDUnparticlegamma_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDUnparticlegamma_code", _wrap_Sigma2ffbar2LEDUnparticlegamma_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDUnparticlegamma_inFlux", _wrap_Sigma2ffbar2LEDUnparticlegamma_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDUnparticlegamma_id3Mass", _wrap_Sigma2ffbar2LEDUnparticlegamma_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDUnparticlegamma_id4Mass", _wrap_Sigma2ffbar2LEDUnparticlegamma_id4Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbar2LEDUnparticlegamma", _wrap_delete_Sigma2ffbar2LEDUnparticlegamma, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDUnparticlegamma_swigregister", Sigma2ffbar2LEDUnparticlegamma_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbar2LEDgammagamma", _wrap_new_Sigma2ffbar2LEDgammagamma, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDgammagamma_initProc", _wrap_Sigma2ffbar2LEDgammagamma_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDgammagamma_sigmaKin", _wrap_Sigma2ffbar2LEDgammagamma_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDgammagamma_sigmaHat", _wrap_Sigma2ffbar2LEDgammagamma_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDgammagamma_setIdColAcol", _wrap_Sigma2ffbar2LEDgammagamma_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDgammagamma_name", _wrap_Sigma2ffbar2LEDgammagamma_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDgammagamma_code", _wrap_Sigma2ffbar2LEDgammagamma_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDgammagamma_inFlux", _wrap_Sigma2ffbar2LEDgammagamma_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbar2LEDgammagamma", _wrap_delete_Sigma2ffbar2LEDgammagamma, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDgammagamma_swigregister", Sigma2ffbar2LEDgammagamma_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2gg2LEDgammagamma", _wrap_new_Sigma2gg2LEDgammagamma, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDgammagamma_initProc", _wrap_Sigma2gg2LEDgammagamma_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDgammagamma_sigmaKin", _wrap_Sigma2gg2LEDgammagamma_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDgammagamma_sigmaHat", _wrap_Sigma2gg2LEDgammagamma_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDgammagamma_setIdColAcol", _wrap_Sigma2gg2LEDgammagamma_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDgammagamma_name", _wrap_Sigma2gg2LEDgammagamma_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDgammagamma_code", _wrap_Sigma2gg2LEDgammagamma_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDgammagamma_inFlux", _wrap_Sigma2gg2LEDgammagamma_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2gg2LEDgammagamma", _wrap_delete_Sigma2gg2LEDgammagamma, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDgammagamma_swigregister", Sigma2gg2LEDgammagamma_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbar2LEDllbar", _wrap_new_Sigma2ffbar2LEDllbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDllbar_initProc", _wrap_Sigma2ffbar2LEDllbar_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDllbar_sigmaKin", _wrap_Sigma2ffbar2LEDllbar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDllbar_sigmaHat", _wrap_Sigma2ffbar2LEDllbar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDllbar_setIdColAcol", _wrap_Sigma2ffbar2LEDllbar_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDllbar_name", _wrap_Sigma2ffbar2LEDllbar_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDllbar_code", _wrap_Sigma2ffbar2LEDllbar_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDllbar_inFlux", _wrap_Sigma2ffbar2LEDllbar_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDllbar_isSChannel", _wrap_Sigma2ffbar2LEDllbar_isSChannel, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbar2LEDllbar", _wrap_delete_Sigma2ffbar2LEDllbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2LEDllbar_swigregister", Sigma2ffbar2LEDllbar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2gg2LEDllbar", _wrap_new_Sigma2gg2LEDllbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDllbar_initProc", _wrap_Sigma2gg2LEDllbar_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDllbar_sigmaKin", _wrap_Sigma2gg2LEDllbar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDllbar_sigmaHat", _wrap_Sigma2gg2LEDllbar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDllbar_setIdColAcol", _wrap_Sigma2gg2LEDllbar_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDllbar_name", _wrap_Sigma2gg2LEDllbar_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDllbar_code", _wrap_Sigma2gg2LEDllbar_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDllbar_inFlux", _wrap_Sigma2gg2LEDllbar_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2gg2LEDllbar", _wrap_delete_Sigma2gg2LEDllbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDllbar_swigregister", Sigma2gg2LEDllbar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2gg2LEDgg", _wrap_new_Sigma2gg2LEDgg, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDgg_initProc", _wrap_Sigma2gg2LEDgg_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDgg_sigmaKin", _wrap_Sigma2gg2LEDgg_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDgg_sigmaHat", _wrap_Sigma2gg2LEDgg_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDgg_setIdColAcol", _wrap_Sigma2gg2LEDgg_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDgg_name", _wrap_Sigma2gg2LEDgg_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDgg_code", _wrap_Sigma2gg2LEDgg_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDgg_inFlux", _wrap_Sigma2gg2LEDgg_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2gg2LEDgg", _wrap_delete_Sigma2gg2LEDgg, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDgg_swigregister", Sigma2gg2LEDgg_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2gg2LEDqqbar", _wrap_new_Sigma2gg2LEDqqbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDqqbar_initProc", _wrap_Sigma2gg2LEDqqbar_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDqqbar_sigmaKin", _wrap_Sigma2gg2LEDqqbar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDqqbar_sigmaHat", _wrap_Sigma2gg2LEDqqbar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDqqbar_setIdColAcol", _wrap_Sigma2gg2LEDqqbar_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDqqbar_name", _wrap_Sigma2gg2LEDqqbar_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDqqbar_code", _wrap_Sigma2gg2LEDqqbar_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDqqbar_inFlux", _wrap_Sigma2gg2LEDqqbar_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2gg2LEDqqbar", _wrap_delete_Sigma2gg2LEDqqbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LEDqqbar_swigregister", Sigma2gg2LEDqqbar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qg2LEDqg", _wrap_new_Sigma2qg2LEDqg, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LEDqg_initProc", _wrap_Sigma2qg2LEDqg_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LEDqg_sigmaKin", _wrap_Sigma2qg2LEDqg_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LEDqg_sigmaHat", _wrap_Sigma2qg2LEDqg_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LEDqg_setIdColAcol", _wrap_Sigma2qg2LEDqg_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LEDqg_name", _wrap_Sigma2qg2LEDqg_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LEDqg_code", _wrap_Sigma2qg2LEDqg_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LEDqg_inFlux", _wrap_Sigma2qg2LEDqg_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qg2LEDqg", _wrap_delete_Sigma2qg2LEDqg, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LEDqg_swigregister", Sigma2qg2LEDqg_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qq2LEDqq", _wrap_new_Sigma2qq2LEDqq, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2LEDqq_initProc", _wrap_Sigma2qq2LEDqq_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2LEDqq_sigmaKin", _wrap_Sigma2qq2LEDqq_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2LEDqq_sigmaHat", _wrap_Sigma2qq2LEDqq_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2LEDqq_setIdColAcol", _wrap_Sigma2qq2LEDqq_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2LEDqq_name", _wrap_Sigma2qq2LEDqq_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2LEDqq_code", _wrap_Sigma2qq2LEDqq_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2LEDqq_inFlux", _wrap_Sigma2qq2LEDqq_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qq2LEDqq", _wrap_delete_Sigma2qq2LEDqq, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2LEDqq_swigregister", Sigma2qq2LEDqq_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2LEDgg", _wrap_new_Sigma2qqbar2LEDgg, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDgg_initProc", _wrap_Sigma2qqbar2LEDgg_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDgg_sigmaKin", _wrap_Sigma2qqbar2LEDgg_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDgg_sigmaHat", _wrap_Sigma2qqbar2LEDgg_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDgg_setIdColAcol", _wrap_Sigma2qqbar2LEDgg_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDgg_name", _wrap_Sigma2qqbar2LEDgg_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDgg_code", _wrap_Sigma2qqbar2LEDgg_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDgg_inFlux", _wrap_Sigma2qqbar2LEDgg_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2LEDgg", _wrap_delete_Sigma2qqbar2LEDgg, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDgg_swigregister", Sigma2qqbar2LEDgg_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2LEDqqbarNew", _wrap_new_Sigma2qqbar2LEDqqbarNew, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDqqbarNew_initProc", _wrap_Sigma2qqbar2LEDqqbarNew_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDqqbarNew_sigmaKin", _wrap_Sigma2qqbar2LEDqqbarNew_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDqqbarNew_sigmaHat", _wrap_Sigma2qqbar2LEDqqbarNew_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDqqbarNew_setIdColAcol", _wrap_Sigma2qqbar2LEDqqbarNew_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDqqbarNew_name", _wrap_Sigma2qqbar2LEDqqbarNew_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDqqbarNew_code", _wrap_Sigma2qqbar2LEDqqbarNew_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDqqbarNew_inFlux", _wrap_Sigma2qqbar2LEDqqbarNew_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2LEDqqbarNew", _wrap_delete_Sigma2qqbar2LEDqqbarNew, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LEDqqbarNew_swigregister", Sigma2qqbar2LEDqqbarNew_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2gg2qGqGbar", _wrap_new_Sigma2gg2qGqGbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2qGqGbar_initProc", _wrap_Sigma2gg2qGqGbar_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2qGqGbar_sigmaKin", _wrap_Sigma2gg2qGqGbar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2qGqGbar_sigmaHat", _wrap_Sigma2gg2qGqGbar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2qGqGbar_setIdColAcol", _wrap_Sigma2gg2qGqGbar_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2qGqGbar_name", _wrap_Sigma2gg2qGqGbar_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2qGqGbar_code", _wrap_Sigma2gg2qGqGbar_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2qGqGbar_inFlux", _wrap_Sigma2gg2qGqGbar_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2qGqGbar_id3Mass", _wrap_Sigma2gg2qGqGbar_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2qGqGbar_id4Mass", _wrap_Sigma2gg2qGqGbar_id4Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2gg2qGqGbar", _wrap_delete_Sigma2gg2qGqGbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2qGqGbar_swigregister", Sigma2gg2qGqGbar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2qGqGbar", _wrap_new_Sigma2qqbar2qGqGbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2qGqGbar_initProc", _wrap_Sigma2qqbar2qGqGbar_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2qGqGbar_sigmaKin", _wrap_Sigma2qqbar2qGqGbar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2qGqGbar_sigmaHat", _wrap_Sigma2qqbar2qGqGbar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2qGqGbar_setIdColAcol", _wrap_Sigma2qqbar2qGqGbar_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2qGqGbar_name", _wrap_Sigma2qqbar2qGqGbar_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2qGqGbar_code", _wrap_Sigma2qqbar2qGqGbar_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2qGqGbar_inFlux", _wrap_Sigma2qqbar2qGqGbar_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2qGqGbar_id3Mass", _wrap_Sigma2qqbar2qGqGbar_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2qGqGbar_id4Mass", _wrap_Sigma2qqbar2qGqGbar_id4Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2qGqGbar", _wrap_delete_Sigma2qqbar2qGqGbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2qGqGbar_swigregister", Sigma2qqbar2qGqGbar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbar2fGfGbar", _wrap_new_Sigma2ffbar2fGfGbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2fGfGbar_initProc", _wrap_Sigma2ffbar2fGfGbar_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2fGfGbar_sigmaKin", _wrap_Sigma2ffbar2fGfGbar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2fGfGbar_sigmaHat", _wrap_Sigma2ffbar2fGfGbar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2fGfGbar_setIdColAcol", _wrap_Sigma2ffbar2fGfGbar_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2fGfGbar_name", _wrap_Sigma2ffbar2fGfGbar_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2fGfGbar_code", _wrap_Sigma2ffbar2fGfGbar_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2fGfGbar_inFlux", _wrap_Sigma2ffbar2fGfGbar_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2fGfGbar_id3Mass", _wrap_Sigma2ffbar2fGfGbar_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2fGfGbar_id4Mass", _wrap_Sigma2ffbar2fGfGbar_id4Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbar2fGfGbar", _wrap_delete_Sigma2ffbar2fGfGbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2fGfGbar_swigregister", Sigma2ffbar2fGfGbar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma1ffbar2Zv", _wrap_new_Sigma1ffbar2Zv, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Zv_initProc", _wrap_Sigma1ffbar2Zv_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Zv_sigmaKin", _wrap_Sigma1ffbar2Zv_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Zv_sigmaHat", _wrap_Sigma1ffbar2Zv_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Zv_setIdColAcol", _wrap_Sigma1ffbar2Zv_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Zv_weightDecay", _wrap_Sigma1ffbar2Zv_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Zv_name", _wrap_Sigma1ffbar2Zv_name, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Zv_code", _wrap_Sigma1ffbar2Zv_code, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Zv_inFlux", _wrap_Sigma1ffbar2Zv_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Zv_resonanceA", _wrap_Sigma1ffbar2Zv_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma1ffbar2Zv", _wrap_delete_Sigma1ffbar2Zv, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Zv_swigregister", Sigma1ffbar2Zv_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma1ffbar2H", _wrap_new_Sigma1ffbar2H, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2H_initProc", _wrap_Sigma1ffbar2H_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2H_sigmaKin", _wrap_Sigma1ffbar2H_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2H_sigmaHat", _wrap_Sigma1ffbar2H_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2H_setIdColAcol", _wrap_Sigma1ffbar2H_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2H_weightDecay", _wrap_Sigma1ffbar2H_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2H_name", _wrap_Sigma1ffbar2H_name, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2H_code", _wrap_Sigma1ffbar2H_code, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2H_inFlux", _wrap_Sigma1ffbar2H_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2H_resonanceA", _wrap_Sigma1ffbar2H_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma1ffbar2H", _wrap_delete_Sigma1ffbar2H, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2H_swigregister", Sigma1ffbar2H_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma1gg2H", _wrap_new_Sigma1gg2H, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2H_initProc", _wrap_Sigma1gg2H_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2H_sigmaKin", _wrap_Sigma1gg2H_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2H_sigmaHat", _wrap_Sigma1gg2H_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2H_setIdColAcol", _wrap_Sigma1gg2H_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2H_weightDecay", _wrap_Sigma1gg2H_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2H_name", _wrap_Sigma1gg2H_name, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2H_code", _wrap_Sigma1gg2H_code, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2H_inFlux", _wrap_Sigma1gg2H_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2H_resonanceA", _wrap_Sigma1gg2H_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma1gg2H", _wrap_delete_Sigma1gg2H, METH_VARARGS, NULL},
	 { (char *)"Sigma1gg2H_swigregister", Sigma1gg2H_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma1gmgm2H", _wrap_new_Sigma1gmgm2H, METH_VARARGS, NULL},
	 { (char *)"Sigma1gmgm2H_initProc", _wrap_Sigma1gmgm2H_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma1gmgm2H_sigmaKin", _wrap_Sigma1gmgm2H_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma1gmgm2H_sigmaHat", _wrap_Sigma1gmgm2H_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma1gmgm2H_setIdColAcol", _wrap_Sigma1gmgm2H_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma1gmgm2H_weightDecay", _wrap_Sigma1gmgm2H_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma1gmgm2H_name", _wrap_Sigma1gmgm2H_name, METH_VARARGS, NULL},
	 { (char *)"Sigma1gmgm2H_code", _wrap_Sigma1gmgm2H_code, METH_VARARGS, NULL},
	 { (char *)"Sigma1gmgm2H_inFlux", _wrap_Sigma1gmgm2H_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma1gmgm2H_resonanceA", _wrap_Sigma1gmgm2H_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma1gmgm2H", _wrap_delete_Sigma1gmgm2H, METH_VARARGS, NULL},
	 { (char *)"Sigma1gmgm2H_swigregister", Sigma1gmgm2H_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbar2HZ", _wrap_new_Sigma2ffbar2HZ, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HZ_initProc", _wrap_Sigma2ffbar2HZ_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HZ_sigmaKin", _wrap_Sigma2ffbar2HZ_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HZ_sigmaHat", _wrap_Sigma2ffbar2HZ_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HZ_setIdColAcol", _wrap_Sigma2ffbar2HZ_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HZ_weightDecay", _wrap_Sigma2ffbar2HZ_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HZ_name", _wrap_Sigma2ffbar2HZ_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HZ_code", _wrap_Sigma2ffbar2HZ_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HZ_inFlux", _wrap_Sigma2ffbar2HZ_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HZ_isSChannel", _wrap_Sigma2ffbar2HZ_isSChannel, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HZ_id3Mass", _wrap_Sigma2ffbar2HZ_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HZ_id4Mass", _wrap_Sigma2ffbar2HZ_id4Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HZ_resonanceA", _wrap_Sigma2ffbar2HZ_resonanceA, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HZ_gmZmode", _wrap_Sigma2ffbar2HZ_gmZmode, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbar2HZ", _wrap_delete_Sigma2ffbar2HZ, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HZ_swigregister", Sigma2ffbar2HZ_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbar2HW", _wrap_new_Sigma2ffbar2HW, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HW_initProc", _wrap_Sigma2ffbar2HW_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HW_sigmaKin", _wrap_Sigma2ffbar2HW_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HW_sigmaHat", _wrap_Sigma2ffbar2HW_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HW_setIdColAcol", _wrap_Sigma2ffbar2HW_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HW_weightDecay", _wrap_Sigma2ffbar2HW_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HW_name", _wrap_Sigma2ffbar2HW_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HW_code", _wrap_Sigma2ffbar2HW_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HW_inFlux", _wrap_Sigma2ffbar2HW_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HW_isSChannel", _wrap_Sigma2ffbar2HW_isSChannel, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HW_id3Mass", _wrap_Sigma2ffbar2HW_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HW_id4Mass", _wrap_Sigma2ffbar2HW_id4Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HW_resonanceA", _wrap_Sigma2ffbar2HW_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbar2HW", _wrap_delete_Sigma2ffbar2HW, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HW_swigregister", Sigma2ffbar2HW_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma3ff2HfftZZ", _wrap_new_Sigma3ff2HfftZZ, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftZZ_initProc", _wrap_Sigma3ff2HfftZZ_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftZZ_sigmaKin", _wrap_Sigma3ff2HfftZZ_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftZZ_sigmaHat", _wrap_Sigma3ff2HfftZZ_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftZZ_setIdColAcol", _wrap_Sigma3ff2HfftZZ_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftZZ_weightDecay", _wrap_Sigma3ff2HfftZZ_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftZZ_name", _wrap_Sigma3ff2HfftZZ_name, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftZZ_code", _wrap_Sigma3ff2HfftZZ_code, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftZZ_inFlux", _wrap_Sigma3ff2HfftZZ_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftZZ_id3Mass", _wrap_Sigma3ff2HfftZZ_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftZZ_idTchan1", _wrap_Sigma3ff2HfftZZ_idTchan1, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftZZ_idTchan2", _wrap_Sigma3ff2HfftZZ_idTchan2, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftZZ_tChanFracPow1", _wrap_Sigma3ff2HfftZZ_tChanFracPow1, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftZZ_tChanFracPow2", _wrap_Sigma3ff2HfftZZ_tChanFracPow2, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftZZ_useMirrorWeight", _wrap_Sigma3ff2HfftZZ_useMirrorWeight, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma3ff2HfftZZ", _wrap_delete_Sigma3ff2HfftZZ, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftZZ_swigregister", Sigma3ff2HfftZZ_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma3ff2HfftWW", _wrap_new_Sigma3ff2HfftWW, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftWW_initProc", _wrap_Sigma3ff2HfftWW_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftWW_sigmaKin", _wrap_Sigma3ff2HfftWW_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftWW_sigmaHat", _wrap_Sigma3ff2HfftWW_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftWW_setIdColAcol", _wrap_Sigma3ff2HfftWW_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftWW_weightDecay", _wrap_Sigma3ff2HfftWW_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftWW_name", _wrap_Sigma3ff2HfftWW_name, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftWW_code", _wrap_Sigma3ff2HfftWW_code, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftWW_inFlux", _wrap_Sigma3ff2HfftWW_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftWW_id3Mass", _wrap_Sigma3ff2HfftWW_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftWW_idTchan1", _wrap_Sigma3ff2HfftWW_idTchan1, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftWW_idTchan2", _wrap_Sigma3ff2HfftWW_idTchan2, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftWW_tChanFracPow1", _wrap_Sigma3ff2HfftWW_tChanFracPow1, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftWW_tChanFracPow2", _wrap_Sigma3ff2HfftWW_tChanFracPow2, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftWW_useMirrorWeight", _wrap_Sigma3ff2HfftWW_useMirrorWeight, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma3ff2HfftWW", _wrap_delete_Sigma3ff2HfftWW, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HfftWW_swigregister", Sigma3ff2HfftWW_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma3gg2HQQbar", _wrap_new_Sigma3gg2HQQbar, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2HQQbar_initProc", _wrap_Sigma3gg2HQQbar_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2HQQbar_sigmaKin", _wrap_Sigma3gg2HQQbar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2HQQbar_sigmaHat", _wrap_Sigma3gg2HQQbar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2HQQbar_setIdColAcol", _wrap_Sigma3gg2HQQbar_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2HQQbar_weightDecay", _wrap_Sigma3gg2HQQbar_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2HQQbar_name", _wrap_Sigma3gg2HQQbar_name, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2HQQbar_code", _wrap_Sigma3gg2HQQbar_code, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2HQQbar_inFlux", _wrap_Sigma3gg2HQQbar_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2HQQbar_id3Mass", _wrap_Sigma3gg2HQQbar_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2HQQbar_id4Mass", _wrap_Sigma3gg2HQQbar_id4Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2HQQbar_id5Mass", _wrap_Sigma3gg2HQQbar_id5Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2HQQbar_idTchan1", _wrap_Sigma3gg2HQQbar_idTchan1, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2HQQbar_idTchan2", _wrap_Sigma3gg2HQQbar_idTchan2, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2HQQbar_tChanFracPow1", _wrap_Sigma3gg2HQQbar_tChanFracPow1, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2HQQbar_tChanFracPow2", _wrap_Sigma3gg2HQQbar_tChanFracPow2, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2HQQbar_useMirrorWeight", _wrap_Sigma3gg2HQQbar_useMirrorWeight, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma3gg2HQQbar", _wrap_delete_Sigma3gg2HQQbar, METH_VARARGS, NULL},
	 { (char *)"Sigma3gg2HQQbar_swigregister", Sigma3gg2HQQbar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma3qqbar2HQQbar", _wrap_new_Sigma3qqbar2HQQbar, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2HQQbar_initProc", _wrap_Sigma3qqbar2HQQbar_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2HQQbar_sigmaKin", _wrap_Sigma3qqbar2HQQbar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2HQQbar_sigmaHat", _wrap_Sigma3qqbar2HQQbar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2HQQbar_setIdColAcol", _wrap_Sigma3qqbar2HQQbar_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2HQQbar_weightDecay", _wrap_Sigma3qqbar2HQQbar_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2HQQbar_name", _wrap_Sigma3qqbar2HQQbar_name, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2HQQbar_code", _wrap_Sigma3qqbar2HQQbar_code, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2HQQbar_inFlux", _wrap_Sigma3qqbar2HQQbar_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2HQQbar_id3Mass", _wrap_Sigma3qqbar2HQQbar_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2HQQbar_id4Mass", _wrap_Sigma3qqbar2HQQbar_id4Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2HQQbar_id5Mass", _wrap_Sigma3qqbar2HQQbar_id5Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2HQQbar_idTchan1", _wrap_Sigma3qqbar2HQQbar_idTchan1, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2HQQbar_idTchan2", _wrap_Sigma3qqbar2HQQbar_idTchan2, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2HQQbar_tChanFracPow1", _wrap_Sigma3qqbar2HQQbar_tChanFracPow1, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2HQQbar_tChanFracPow2", _wrap_Sigma3qqbar2HQQbar_tChanFracPow2, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2HQQbar_useMirrorWeight", _wrap_Sigma3qqbar2HQQbar_useMirrorWeight, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma3qqbar2HQQbar", _wrap_delete_Sigma3qqbar2HQQbar, METH_VARARGS, NULL},
	 { (char *)"Sigma3qqbar2HQQbar_swigregister", Sigma3qqbar2HQQbar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qg2Hq", _wrap_new_Sigma2qg2Hq, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hq_initProc", _wrap_Sigma2qg2Hq_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hq_sigmaKin", _wrap_Sigma2qg2Hq_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hq_sigmaHat", _wrap_Sigma2qg2Hq_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hq_setIdColAcol", _wrap_Sigma2qg2Hq_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hq_weightDecay", _wrap_Sigma2qg2Hq_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hq_name", _wrap_Sigma2qg2Hq_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hq_code", _wrap_Sigma2qg2Hq_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hq_inFlux", _wrap_Sigma2qg2Hq_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hq_id3Mass", _wrap_Sigma2qg2Hq_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hq_id4Mass", _wrap_Sigma2qg2Hq_id4Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qg2Hq", _wrap_delete_Sigma2qg2Hq, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hq_swigregister", Sigma2qg2Hq_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2gg2Hglt", _wrap_new_Sigma2gg2Hglt, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2Hglt_initProc", _wrap_Sigma2gg2Hglt_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2Hglt_sigmaKin", _wrap_Sigma2gg2Hglt_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2Hglt_sigmaHat", _wrap_Sigma2gg2Hglt_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2Hglt_setIdColAcol", _wrap_Sigma2gg2Hglt_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2Hglt_weightDecay", _wrap_Sigma2gg2Hglt_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2Hglt_name", _wrap_Sigma2gg2Hglt_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2Hglt_code", _wrap_Sigma2gg2Hglt_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2Hglt_inFlux", _wrap_Sigma2gg2Hglt_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2Hglt_id3Mass", _wrap_Sigma2gg2Hglt_id3Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2gg2Hglt", _wrap_delete_Sigma2gg2Hglt, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2Hglt_swigregister", Sigma2gg2Hglt_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qg2Hqlt", _wrap_new_Sigma2qg2Hqlt, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hqlt_initProc", _wrap_Sigma2qg2Hqlt_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hqlt_sigmaKin", _wrap_Sigma2qg2Hqlt_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hqlt_sigmaHat", _wrap_Sigma2qg2Hqlt_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hqlt_setIdColAcol", _wrap_Sigma2qg2Hqlt_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hqlt_weightDecay", _wrap_Sigma2qg2Hqlt_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hqlt_name", _wrap_Sigma2qg2Hqlt_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hqlt_code", _wrap_Sigma2qg2Hqlt_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hqlt_inFlux", _wrap_Sigma2qg2Hqlt_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hqlt_id3Mass", _wrap_Sigma2qg2Hqlt_id3Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qg2Hqlt", _wrap_delete_Sigma2qg2Hqlt, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hqlt_swigregister", Sigma2qg2Hqlt_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2Hglt", _wrap_new_Sigma2qqbar2Hglt, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Hglt_initProc", _wrap_Sigma2qqbar2Hglt_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Hglt_sigmaKin", _wrap_Sigma2qqbar2Hglt_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Hglt_sigmaHat", _wrap_Sigma2qqbar2Hglt_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Hglt_setIdColAcol", _wrap_Sigma2qqbar2Hglt_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Hglt_weightDecay", _wrap_Sigma2qqbar2Hglt_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Hglt_name", _wrap_Sigma2qqbar2Hglt_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Hglt_code", _wrap_Sigma2qqbar2Hglt_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Hglt_inFlux", _wrap_Sigma2qqbar2Hglt_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Hglt_id3Mass", _wrap_Sigma2qqbar2Hglt_id3Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2Hglt", _wrap_delete_Sigma2qqbar2Hglt, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2Hglt_swigregister", Sigma2qqbar2Hglt_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma1ffbar2Hchg", _wrap_new_Sigma1ffbar2Hchg, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Hchg_initProc", _wrap_Sigma1ffbar2Hchg_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Hchg_sigmaKin", _wrap_Sigma1ffbar2Hchg_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Hchg_sigmaHat", _wrap_Sigma1ffbar2Hchg_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Hchg_setIdColAcol", _wrap_Sigma1ffbar2Hchg_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Hchg_weightDecay", _wrap_Sigma1ffbar2Hchg_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Hchg_name", _wrap_Sigma1ffbar2Hchg_name, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Hchg_code", _wrap_Sigma1ffbar2Hchg_code, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Hchg_inFlux", _wrap_Sigma1ffbar2Hchg_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Hchg_resonanceA", _wrap_Sigma1ffbar2Hchg_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma1ffbar2Hchg", _wrap_delete_Sigma1ffbar2Hchg, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Hchg_swigregister", Sigma1ffbar2Hchg_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qg2Hchgq", _wrap_new_Sigma2qg2Hchgq, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hchgq_initProc", _wrap_Sigma2qg2Hchgq_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hchgq_sigmaKin", _wrap_Sigma2qg2Hchgq_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hchgq_sigmaHat", _wrap_Sigma2qg2Hchgq_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hchgq_setIdColAcol", _wrap_Sigma2qg2Hchgq_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hchgq_weightDecay", _wrap_Sigma2qg2Hchgq_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hchgq_name", _wrap_Sigma2qg2Hchgq_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hchgq_code", _wrap_Sigma2qg2Hchgq_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hchgq_inFlux", _wrap_Sigma2qg2Hchgq_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hchgq_id3Mass", _wrap_Sigma2qg2Hchgq_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hchgq_id4Mass", _wrap_Sigma2qg2Hchgq_id4Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qg2Hchgq", _wrap_delete_Sigma2qg2Hchgq, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2Hchgq_swigregister", Sigma2qg2Hchgq_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbar2A3H12", _wrap_new_Sigma2ffbar2A3H12, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2A3H12_initProc", _wrap_Sigma2ffbar2A3H12_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2A3H12_sigmaKin", _wrap_Sigma2ffbar2A3H12_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2A3H12_sigmaHat", _wrap_Sigma2ffbar2A3H12_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2A3H12_setIdColAcol", _wrap_Sigma2ffbar2A3H12_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2A3H12_weightDecay", _wrap_Sigma2ffbar2A3H12_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2A3H12_name", _wrap_Sigma2ffbar2A3H12_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2A3H12_code", _wrap_Sigma2ffbar2A3H12_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2A3H12_inFlux", _wrap_Sigma2ffbar2A3H12_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2A3H12_id3Mass", _wrap_Sigma2ffbar2A3H12_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2A3H12_id4Mass", _wrap_Sigma2ffbar2A3H12_id4Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbar2A3H12", _wrap_delete_Sigma2ffbar2A3H12, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2A3H12_swigregister", Sigma2ffbar2A3H12_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbar2HchgH12", _wrap_new_Sigma2ffbar2HchgH12, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HchgH12_initProc", _wrap_Sigma2ffbar2HchgH12_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HchgH12_sigmaKin", _wrap_Sigma2ffbar2HchgH12_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HchgH12_sigmaHat", _wrap_Sigma2ffbar2HchgH12_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HchgH12_setIdColAcol", _wrap_Sigma2ffbar2HchgH12_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HchgH12_weightDecay", _wrap_Sigma2ffbar2HchgH12_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HchgH12_name", _wrap_Sigma2ffbar2HchgH12_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HchgH12_code", _wrap_Sigma2ffbar2HchgH12_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HchgH12_inFlux", _wrap_Sigma2ffbar2HchgH12_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HchgH12_id3Mass", _wrap_Sigma2ffbar2HchgH12_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HchgH12_id4Mass", _wrap_Sigma2ffbar2HchgH12_id4Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbar2HchgH12", _wrap_delete_Sigma2ffbar2HchgH12, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HchgH12_swigregister", Sigma2ffbar2HchgH12_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbar2HposHneg", _wrap_new_Sigma2ffbar2HposHneg, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HposHneg_initProc", _wrap_Sigma2ffbar2HposHneg_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HposHneg_sigmaKin", _wrap_Sigma2ffbar2HposHneg_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HposHneg_sigmaHat", _wrap_Sigma2ffbar2HposHneg_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HposHneg_setIdColAcol", _wrap_Sigma2ffbar2HposHneg_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HposHneg_weightDecay", _wrap_Sigma2ffbar2HposHneg_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HposHneg_name", _wrap_Sigma2ffbar2HposHneg_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HposHneg_code", _wrap_Sigma2ffbar2HposHneg_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HposHneg_inFlux", _wrap_Sigma2ffbar2HposHneg_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HposHneg_id3Mass", _wrap_Sigma2ffbar2HposHneg_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HposHneg_id4Mass", _wrap_Sigma2ffbar2HposHneg_id4Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbar2HposHneg", _wrap_delete_Sigma2ffbar2HposHneg, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HposHneg_swigregister", Sigma2ffbar2HposHneg_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma1ffbar2ZRight", _wrap_new_Sigma1ffbar2ZRight, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2ZRight_initProc", _wrap_Sigma1ffbar2ZRight_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2ZRight_sigmaKin", _wrap_Sigma1ffbar2ZRight_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2ZRight_sigmaHat", _wrap_Sigma1ffbar2ZRight_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2ZRight_setIdColAcol", _wrap_Sigma1ffbar2ZRight_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2ZRight_weightDecay", _wrap_Sigma1ffbar2ZRight_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2ZRight_name", _wrap_Sigma1ffbar2ZRight_name, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2ZRight_code", _wrap_Sigma1ffbar2ZRight_code, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2ZRight_inFlux", _wrap_Sigma1ffbar2ZRight_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2ZRight_resonanceA", _wrap_Sigma1ffbar2ZRight_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma1ffbar2ZRight", _wrap_delete_Sigma1ffbar2ZRight, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2ZRight_swigregister", Sigma1ffbar2ZRight_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma1ffbar2WRight", _wrap_new_Sigma1ffbar2WRight, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2WRight_initProc", _wrap_Sigma1ffbar2WRight_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2WRight_sigmaKin", _wrap_Sigma1ffbar2WRight_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2WRight_sigmaHat", _wrap_Sigma1ffbar2WRight_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2WRight_setIdColAcol", _wrap_Sigma1ffbar2WRight_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2WRight_weightDecay", _wrap_Sigma1ffbar2WRight_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2WRight_name", _wrap_Sigma1ffbar2WRight_name, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2WRight_code", _wrap_Sigma1ffbar2WRight_code, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2WRight_inFlux", _wrap_Sigma1ffbar2WRight_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2WRight_resonanceA", _wrap_Sigma1ffbar2WRight_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma1ffbar2WRight", _wrap_delete_Sigma1ffbar2WRight, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2WRight_swigregister", Sigma1ffbar2WRight_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma1ll2Hchgchg", _wrap_new_Sigma1ll2Hchgchg, METH_VARARGS, NULL},
	 { (char *)"Sigma1ll2Hchgchg_initProc", _wrap_Sigma1ll2Hchgchg_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma1ll2Hchgchg_sigmaHat", _wrap_Sigma1ll2Hchgchg_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma1ll2Hchgchg_setIdColAcol", _wrap_Sigma1ll2Hchgchg_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma1ll2Hchgchg_weightDecay", _wrap_Sigma1ll2Hchgchg_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma1ll2Hchgchg_name", _wrap_Sigma1ll2Hchgchg_name, METH_VARARGS, NULL},
	 { (char *)"Sigma1ll2Hchgchg_code", _wrap_Sigma1ll2Hchgchg_code, METH_VARARGS, NULL},
	 { (char *)"Sigma1ll2Hchgchg_inFlux", _wrap_Sigma1ll2Hchgchg_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma1ll2Hchgchg_resonanceA", _wrap_Sigma1ll2Hchgchg_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma1ll2Hchgchg", _wrap_delete_Sigma1ll2Hchgchg, METH_VARARGS, NULL},
	 { (char *)"Sigma1ll2Hchgchg_swigregister", Sigma1ll2Hchgchg_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2lgm2Hchgchgl", _wrap_new_Sigma2lgm2Hchgchgl, METH_VARARGS, NULL},
	 { (char *)"Sigma2lgm2Hchgchgl_initProc", _wrap_Sigma2lgm2Hchgchgl_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2lgm2Hchgchgl_sigmaHat", _wrap_Sigma2lgm2Hchgchgl_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2lgm2Hchgchgl_setIdColAcol", _wrap_Sigma2lgm2Hchgchgl_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2lgm2Hchgchgl_weightDecay", _wrap_Sigma2lgm2Hchgchgl_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2lgm2Hchgchgl_name", _wrap_Sigma2lgm2Hchgchgl_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2lgm2Hchgchgl_code", _wrap_Sigma2lgm2Hchgchgl_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2lgm2Hchgchgl_inFlux", _wrap_Sigma2lgm2Hchgchgl_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2lgm2Hchgchgl_resonanceA", _wrap_Sigma2lgm2Hchgchgl_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2lgm2Hchgchgl", _wrap_delete_Sigma2lgm2Hchgchgl, METH_VARARGS, NULL},
	 { (char *)"Sigma2lgm2Hchgchgl_swigregister", Sigma2lgm2Hchgchgl_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma3ff2HchgchgfftWW", _wrap_new_Sigma3ff2HchgchgfftWW, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HchgchgfftWW_initProc", _wrap_Sigma3ff2HchgchgfftWW_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HchgchgfftWW_sigmaKin", _wrap_Sigma3ff2HchgchgfftWW_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HchgchgfftWW_sigmaHat", _wrap_Sigma3ff2HchgchgfftWW_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HchgchgfftWW_setIdColAcol", _wrap_Sigma3ff2HchgchgfftWW_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HchgchgfftWW_weightDecay", _wrap_Sigma3ff2HchgchgfftWW_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HchgchgfftWW_name", _wrap_Sigma3ff2HchgchgfftWW_name, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HchgchgfftWW_code", _wrap_Sigma3ff2HchgchgfftWW_code, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HchgchgfftWW_inFlux", _wrap_Sigma3ff2HchgchgfftWW_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HchgchgfftWW_id3Mass", _wrap_Sigma3ff2HchgchgfftWW_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HchgchgfftWW_idTchan1", _wrap_Sigma3ff2HchgchgfftWW_idTchan1, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HchgchgfftWW_idTchan2", _wrap_Sigma3ff2HchgchgfftWW_idTchan2, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HchgchgfftWW_tChanFracPow1", _wrap_Sigma3ff2HchgchgfftWW_tChanFracPow1, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HchgchgfftWW_tChanFracPow2", _wrap_Sigma3ff2HchgchgfftWW_tChanFracPow2, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HchgchgfftWW_useMirrorWeight", _wrap_Sigma3ff2HchgchgfftWW_useMirrorWeight, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma3ff2HchgchgfftWW", _wrap_delete_Sigma3ff2HchgchgfftWW, METH_VARARGS, NULL},
	 { (char *)"Sigma3ff2HchgchgfftWW_swigregister", Sigma3ff2HchgchgfftWW_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2ffbar2HchgchgHchgchg", _wrap_new_Sigma2ffbar2HchgchgHchgchg, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HchgchgHchgchg_initProc", _wrap_Sigma2ffbar2HchgchgHchgchg_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HchgchgHchgchg_sigmaHat", _wrap_Sigma2ffbar2HchgchgHchgchg_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HchgchgHchgchg_setIdColAcol", _wrap_Sigma2ffbar2HchgchgHchgchg_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HchgchgHchgchg_weightDecay", _wrap_Sigma2ffbar2HchgchgHchgchg_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HchgchgHchgchg_name", _wrap_Sigma2ffbar2HchgchgHchgchg_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HchgchgHchgchg_code", _wrap_Sigma2ffbar2HchgchgHchgchg_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HchgchgHchgchg_inFlux", _wrap_Sigma2ffbar2HchgchgHchgchg_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HchgchgHchgchg_id3Mass", _wrap_Sigma2ffbar2HchgchgHchgchg_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HchgchgHchgchg_id4Mass", _wrap_Sigma2ffbar2HchgchgHchgchg_id4Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HchgchgHchgchg_resonanceA", _wrap_Sigma2ffbar2HchgchgHchgchg_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2ffbar2HchgchgHchgchg", _wrap_delete_Sigma2ffbar2HchgchgHchgchg, METH_VARARGS, NULL},
	 { (char *)"Sigma2ffbar2HchgchgHchgchg_swigregister", Sigma2ffbar2HchgchgHchgchg_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma1ql2LeptoQuark", _wrap_new_Sigma1ql2LeptoQuark, METH_VARARGS, NULL},
	 { (char *)"Sigma1ql2LeptoQuark_initProc", _wrap_Sigma1ql2LeptoQuark_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma1ql2LeptoQuark_sigmaKin", _wrap_Sigma1ql2LeptoQuark_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma1ql2LeptoQuark_sigmaHat", _wrap_Sigma1ql2LeptoQuark_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma1ql2LeptoQuark_setIdColAcol", _wrap_Sigma1ql2LeptoQuark_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma1ql2LeptoQuark_name", _wrap_Sigma1ql2LeptoQuark_name, METH_VARARGS, NULL},
	 { (char *)"Sigma1ql2LeptoQuark_code", _wrap_Sigma1ql2LeptoQuark_code, METH_VARARGS, NULL},
	 { (char *)"Sigma1ql2LeptoQuark_inFlux", _wrap_Sigma1ql2LeptoQuark_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma1ql2LeptoQuark_resonanceA", _wrap_Sigma1ql2LeptoQuark_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma1ql2LeptoQuark", _wrap_delete_Sigma1ql2LeptoQuark, METH_VARARGS, NULL},
	 { (char *)"Sigma1ql2LeptoQuark_swigregister", Sigma1ql2LeptoQuark_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qg2LeptoQuarkl", _wrap_new_Sigma2qg2LeptoQuarkl, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LeptoQuarkl_initProc", _wrap_Sigma2qg2LeptoQuarkl_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LeptoQuarkl_sigmaKin", _wrap_Sigma2qg2LeptoQuarkl_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LeptoQuarkl_sigmaHat", _wrap_Sigma2qg2LeptoQuarkl_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LeptoQuarkl_setIdColAcol", _wrap_Sigma2qg2LeptoQuarkl_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LeptoQuarkl_name", _wrap_Sigma2qg2LeptoQuarkl_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LeptoQuarkl_code", _wrap_Sigma2qg2LeptoQuarkl_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LeptoQuarkl_inFlux", _wrap_Sigma2qg2LeptoQuarkl_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LeptoQuarkl_id3Mass", _wrap_Sigma2qg2LeptoQuarkl_id3Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qg2LeptoQuarkl", _wrap_delete_Sigma2qg2LeptoQuarkl, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2LeptoQuarkl_swigregister", Sigma2qg2LeptoQuarkl_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2gg2LQLQbar", _wrap_new_Sigma2gg2LQLQbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LQLQbar_initProc", _wrap_Sigma2gg2LQLQbar_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LQLQbar_sigmaKin", _wrap_Sigma2gg2LQLQbar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LQLQbar_sigmaHat", _wrap_Sigma2gg2LQLQbar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LQLQbar_setIdColAcol", _wrap_Sigma2gg2LQLQbar_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LQLQbar_name", _wrap_Sigma2gg2LQLQbar_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LQLQbar_code", _wrap_Sigma2gg2LQLQbar_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LQLQbar_inFlux", _wrap_Sigma2gg2LQLQbar_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LQLQbar_id3Mass", _wrap_Sigma2gg2LQLQbar_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LQLQbar_id4Mass", _wrap_Sigma2gg2LQLQbar_id4Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2gg2LQLQbar", _wrap_delete_Sigma2gg2LQLQbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2LQLQbar_swigregister", Sigma2gg2LQLQbar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2LQLQbar", _wrap_new_Sigma2qqbar2LQLQbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LQLQbar_initProc", _wrap_Sigma2qqbar2LQLQbar_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LQLQbar_sigmaKin", _wrap_Sigma2qqbar2LQLQbar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LQLQbar_sigmaHat", _wrap_Sigma2qqbar2LQLQbar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LQLQbar_setIdColAcol", _wrap_Sigma2qqbar2LQLQbar_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LQLQbar_name", _wrap_Sigma2qqbar2LQLQbar_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LQLQbar_code", _wrap_Sigma2qqbar2LQLQbar_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LQLQbar_inFlux", _wrap_Sigma2qqbar2LQLQbar_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LQLQbar_id3Mass", _wrap_Sigma2qqbar2LQLQbar_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LQLQbar_id4Mass", _wrap_Sigma2qqbar2LQLQbar_id4Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2LQLQbar", _wrap_delete_Sigma2qqbar2LQLQbar, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2LQLQbar_swigregister", Sigma2qqbar2LQLQbar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma1ffbarZprimeWprime", _wrap_new_Sigma1ffbarZprimeWprime, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma1ffbarZprimeWprime", _wrap_delete_Sigma1ffbarZprimeWprime, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbarZprimeWprime_swigregister", Sigma1ffbarZprimeWprime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma1ffbar2gmZZprime", _wrap_new_Sigma1ffbar2gmZZprime, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2gmZZprime_initProc", _wrap_Sigma1ffbar2gmZZprime_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2gmZZprime_sigmaKin", _wrap_Sigma1ffbar2gmZZprime_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2gmZZprime_sigmaHat", _wrap_Sigma1ffbar2gmZZprime_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2gmZZprime_setIdColAcol", _wrap_Sigma1ffbar2gmZZprime_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2gmZZprime_weightDecay", _wrap_Sigma1ffbar2gmZZprime_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2gmZZprime_name", _wrap_Sigma1ffbar2gmZZprime_name, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2gmZZprime_code", _wrap_Sigma1ffbar2gmZZprime_code, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2gmZZprime_inFlux", _wrap_Sigma1ffbar2gmZZprime_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2gmZZprime_resonanceA", _wrap_Sigma1ffbar2gmZZprime_resonanceA, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2gmZZprime_resonanceB", _wrap_Sigma1ffbar2gmZZprime_resonanceB, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma1ffbar2gmZZprime", _wrap_delete_Sigma1ffbar2gmZZprime, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2gmZZprime_swigregister", Sigma1ffbar2gmZZprime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma1ffbar2Wprime", _wrap_new_Sigma1ffbar2Wprime, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Wprime_initProc", _wrap_Sigma1ffbar2Wprime_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Wprime_sigmaKin", _wrap_Sigma1ffbar2Wprime_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Wprime_sigmaHat", _wrap_Sigma1ffbar2Wprime_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Wprime_setIdColAcol", _wrap_Sigma1ffbar2Wprime_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Wprime_weightDecay", _wrap_Sigma1ffbar2Wprime_weightDecay, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Wprime_name", _wrap_Sigma1ffbar2Wprime_name, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Wprime_code", _wrap_Sigma1ffbar2Wprime_code, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Wprime_inFlux", _wrap_Sigma1ffbar2Wprime_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Wprime_resonanceA", _wrap_Sigma1ffbar2Wprime_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma1ffbar2Wprime", _wrap_delete_Sigma1ffbar2Wprime, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Wprime_swigregister", Sigma1ffbar2Wprime_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma1ffbar2Rhorizontal", _wrap_new_Sigma1ffbar2Rhorizontal, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Rhorizontal_initProc", _wrap_Sigma1ffbar2Rhorizontal_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Rhorizontal_sigmaKin", _wrap_Sigma1ffbar2Rhorizontal_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Rhorizontal_sigmaHat", _wrap_Sigma1ffbar2Rhorizontal_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Rhorizontal_setIdColAcol", _wrap_Sigma1ffbar2Rhorizontal_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Rhorizontal_name", _wrap_Sigma1ffbar2Rhorizontal_name, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Rhorizontal_code", _wrap_Sigma1ffbar2Rhorizontal_code, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Rhorizontal_inFlux", _wrap_Sigma1ffbar2Rhorizontal_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Rhorizontal_resonanceA", _wrap_Sigma1ffbar2Rhorizontal_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma1ffbar2Rhorizontal", _wrap_delete_Sigma1ffbar2Rhorizontal, METH_VARARGS, NULL},
	 { (char *)"Sigma1ffbar2Rhorizontal_swigregister", Sigma1ffbar2Rhorizontal_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SigmaOniaSetup", _wrap_new_SigmaOniaSetup, METH_VARARGS, NULL},
	 { (char *)"SigmaOniaSetup_setupSigma2gg", _wrap_SigmaOniaSetup_setupSigma2gg, METH_VARARGS, NULL},
	 { (char *)"SigmaOniaSetup_setupSigma2qg", _wrap_SigmaOniaSetup_setupSigma2qg, METH_VARARGS, NULL},
	 { (char *)"SigmaOniaSetup_setupSigma2qq", _wrap_SigmaOniaSetup_setupSigma2qq, METH_VARARGS, NULL},
	 { (char *)"SigmaOniaSetup_setupSigma2dbl", _wrap_SigmaOniaSetup_setupSigma2dbl, METH_VARARGS, NULL},
	 { (char *)"delete_SigmaOniaSetup", _wrap_delete_SigmaOniaSetup, METH_VARARGS, NULL},
	 { (char *)"SigmaOniaSetup_swigregister", SigmaOniaSetup_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2gg2QQbar3S11g", _wrap_new_Sigma2gg2QQbar3S11g, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11g_initProc", _wrap_Sigma2gg2QQbar3S11g_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11g_sigmaKin", _wrap_Sigma2gg2QQbar3S11g_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11g_sigmaHat", _wrap_Sigma2gg2QQbar3S11g_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11g_setIdColAcol", _wrap_Sigma2gg2QQbar3S11g_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11g_name", _wrap_Sigma2gg2QQbar3S11g_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11g_code", _wrap_Sigma2gg2QQbar3S11g_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11g_inFlux", _wrap_Sigma2gg2QQbar3S11g_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11g_id3Mass", _wrap_Sigma2gg2QQbar3S11g_id3Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2gg2QQbar3S11g", _wrap_delete_Sigma2gg2QQbar3S11g, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11g_swigregister", Sigma2gg2QQbar3S11g_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2gg2QQbar3S11gm", _wrap_new_Sigma2gg2QQbar3S11gm, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11gm_initProc", _wrap_Sigma2gg2QQbar3S11gm_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11gm_sigmaKin", _wrap_Sigma2gg2QQbar3S11gm_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11gm_sigmaHat", _wrap_Sigma2gg2QQbar3S11gm_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11gm_setIdColAcol", _wrap_Sigma2gg2QQbar3S11gm_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11gm_name", _wrap_Sigma2gg2QQbar3S11gm_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11gm_code", _wrap_Sigma2gg2QQbar3S11gm_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11gm_inFlux", _wrap_Sigma2gg2QQbar3S11gm_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11gm_id3Mass", _wrap_Sigma2gg2QQbar3S11gm_id3Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2gg2QQbar3S11gm", _wrap_delete_Sigma2gg2QQbar3S11gm, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11gm_swigregister", Sigma2gg2QQbar3S11gm_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2gg2QQbar3PJ1g", _wrap_new_Sigma2gg2QQbar3PJ1g, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3PJ1g_initProc", _wrap_Sigma2gg2QQbar3PJ1g_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3PJ1g_sigmaKin", _wrap_Sigma2gg2QQbar3PJ1g_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3PJ1g_sigmaHat", _wrap_Sigma2gg2QQbar3PJ1g_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3PJ1g_setIdColAcol", _wrap_Sigma2gg2QQbar3PJ1g_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3PJ1g_name", _wrap_Sigma2gg2QQbar3PJ1g_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3PJ1g_code", _wrap_Sigma2gg2QQbar3PJ1g_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3PJ1g_inFlux", _wrap_Sigma2gg2QQbar3PJ1g_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3PJ1g_id3Mass", _wrap_Sigma2gg2QQbar3PJ1g_id3Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2gg2QQbar3PJ1g", _wrap_delete_Sigma2gg2QQbar3PJ1g, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3PJ1g_swigregister", Sigma2gg2QQbar3PJ1g_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qg2QQbar3PJ1q", _wrap_new_Sigma2qg2QQbar3PJ1q, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2QQbar3PJ1q_sigmaKin", _wrap_Sigma2qg2QQbar3PJ1q_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2QQbar3PJ1q_setIdColAcol", _wrap_Sigma2qg2QQbar3PJ1q_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2QQbar3PJ1q_inFlux", _wrap_Sigma2qg2QQbar3PJ1q_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qg2QQbar3PJ1q", _wrap_delete_Sigma2qg2QQbar3PJ1q, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2QQbar3PJ1q_swigregister", Sigma2qg2QQbar3PJ1q_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2QQbar3PJ1g", _wrap_new_Sigma2qqbar2QQbar3PJ1g, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbar3PJ1g_sigmaKin", _wrap_Sigma2qqbar2QQbar3PJ1g_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbar3PJ1g_setIdColAcol", _wrap_Sigma2qqbar2QQbar3PJ1g_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbar3PJ1g_inFlux", _wrap_Sigma2qqbar2QQbar3PJ1g_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2QQbar3PJ1g", _wrap_delete_Sigma2qqbar2QQbar3PJ1g, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbar3PJ1g_swigregister", Sigma2qqbar2QQbar3PJ1g_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2gg2QQbar3DJ1g", _wrap_new_Sigma2gg2QQbar3DJ1g, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3DJ1g_initProc", _wrap_Sigma2gg2QQbar3DJ1g_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3DJ1g_sigmaKin", _wrap_Sigma2gg2QQbar3DJ1g_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2gg2QQbar3DJ1g", _wrap_delete_Sigma2gg2QQbar3DJ1g, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3DJ1g_swigregister", Sigma2gg2QQbar3DJ1g_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2gg2QQbarX8g", _wrap_new_Sigma2gg2QQbarX8g, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbarX8g_initProc", _wrap_Sigma2gg2QQbarX8g_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbarX8g_sigmaKin", _wrap_Sigma2gg2QQbarX8g_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbarX8g_sigmaHat", _wrap_Sigma2gg2QQbarX8g_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbarX8g_setIdColAcol", _wrap_Sigma2gg2QQbarX8g_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbarX8g_name", _wrap_Sigma2gg2QQbarX8g_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbarX8g_code", _wrap_Sigma2gg2QQbarX8g_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbarX8g_inFlux", _wrap_Sigma2gg2QQbarX8g_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbarX8g_id3Mass", _wrap_Sigma2gg2QQbarX8g_id3Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2gg2QQbarX8g", _wrap_delete_Sigma2gg2QQbarX8g, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbarX8g_swigregister", Sigma2gg2QQbarX8g_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qg2QQbarX8q", _wrap_new_Sigma2qg2QQbarX8q, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2QQbarX8q_sigmaKin", _wrap_Sigma2qg2QQbarX8q_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2QQbarX8q_setIdColAcol", _wrap_Sigma2qg2QQbarX8q_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2QQbarX8q_inFlux", _wrap_Sigma2qg2QQbarX8q_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qg2QQbarX8q", _wrap_delete_Sigma2qg2QQbarX8q, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2QQbarX8q_swigregister", Sigma2qg2QQbarX8q_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2QQbarX8g", _wrap_new_Sigma2qqbar2QQbarX8g, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbarX8g_sigmaKin", _wrap_Sigma2qqbar2QQbarX8g_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbarX8g_setIdColAcol", _wrap_Sigma2qqbar2QQbarX8g_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbarX8g_inFlux", _wrap_Sigma2qqbar2QQbarX8g_inFlux, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2QQbarX8g", _wrap_delete_Sigma2qqbar2QQbarX8g, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbarX8g_swigregister", Sigma2qqbar2QQbarX8g_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2gg2QQbar3S11QQbar3S11", _wrap_new_Sigma2gg2QQbar3S11QQbar3S11, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11QQbar3S11_initProc", _wrap_Sigma2gg2QQbar3S11QQbar3S11_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11QQbar3S11_sigmaKin", _wrap_Sigma2gg2QQbar3S11QQbar3S11_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11QQbar3S11_sigmaHat", _wrap_Sigma2gg2QQbar3S11QQbar3S11_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11QQbar3S11_setIdColAcol", _wrap_Sigma2gg2QQbar3S11QQbar3S11_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11QQbar3S11_name", _wrap_Sigma2gg2QQbar3S11QQbar3S11_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11QQbar3S11_code", _wrap_Sigma2gg2QQbar3S11QQbar3S11_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11QQbar3S11_inFlux", _wrap_Sigma2gg2QQbar3S11QQbar3S11_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11QQbar3S11_id3Mass", _wrap_Sigma2gg2QQbar3S11QQbar3S11_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11QQbar3S11_id4Mass", _wrap_Sigma2gg2QQbar3S11QQbar3S11_id4Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2gg2QQbar3S11QQbar3S11", _wrap_delete_Sigma2gg2QQbar3S11QQbar3S11, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2QQbar3S11QQbar3S11_swigregister", Sigma2gg2QQbar3S11QQbar3S11_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2QQbar3S11QQbar3S11", _wrap_new_Sigma2qqbar2QQbar3S11QQbar3S11, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbar3S11QQbar3S11_initProc", _wrap_Sigma2qqbar2QQbar3S11QQbar3S11_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbar3S11QQbar3S11_sigmaKin", _wrap_Sigma2qqbar2QQbar3S11QQbar3S11_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbar3S11QQbar3S11_sigmaHat", _wrap_Sigma2qqbar2QQbar3S11QQbar3S11_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbar3S11QQbar3S11_setIdColAcol", _wrap_Sigma2qqbar2QQbar3S11QQbar3S11_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbar3S11QQbar3S11_name", _wrap_Sigma2qqbar2QQbar3S11QQbar3S11_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbar3S11QQbar3S11_code", _wrap_Sigma2qqbar2QQbar3S11QQbar3S11_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbar3S11QQbar3S11_inFlux", _wrap_Sigma2qqbar2QQbar3S11QQbar3S11_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbar3S11QQbar3S11_id3Mass", _wrap_Sigma2qqbar2QQbar3S11QQbar3S11_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbar3S11QQbar3S11_id4Mass", _wrap_Sigma2qqbar2QQbar3S11QQbar3S11_id4Mass, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2QQbar3S11QQbar3S11", _wrap_delete_Sigma2qqbar2QQbar3S11QQbar3S11, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2QQbar3S11QQbar3S11_swigregister", Sigma2qqbar2QQbar3S11QQbar3S11_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2SUSY", _wrap_new_Sigma2SUSY, METH_VARARGS, NULL},
	 { (char *)"Sigma2SUSY_weightDecay", _wrap_Sigma2SUSY_weightDecay, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2SUSY", _wrap_delete_Sigma2SUSY, METH_VARARGS, NULL},
	 { (char *)"Sigma2SUSY_swigregister", Sigma2SUSY_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2chi0chi0", _wrap_new_Sigma2qqbar2chi0chi0, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0chi0_initProc", _wrap_Sigma2qqbar2chi0chi0_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0chi0_sigmaKin", _wrap_Sigma2qqbar2chi0chi0_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0chi0_sigmaHat", _wrap_Sigma2qqbar2chi0chi0_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0chi0_setIdColAcol", _wrap_Sigma2qqbar2chi0chi0_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0chi0_name", _wrap_Sigma2qqbar2chi0chi0_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0chi0_code", _wrap_Sigma2qqbar2chi0chi0_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0chi0_inFlux", _wrap_Sigma2qqbar2chi0chi0_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0chi0_id3Mass", _wrap_Sigma2qqbar2chi0chi0_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0chi0_id4Mass", _wrap_Sigma2qqbar2chi0chi0_id4Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0chi0_resonanceA", _wrap_Sigma2qqbar2chi0chi0_resonanceA, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0chi0_isSUSY", _wrap_Sigma2qqbar2chi0chi0_isSUSY, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0chi0_getSigma0", _wrap_Sigma2qqbar2chi0chi0_getSigma0, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2chi0chi0", _wrap_delete_Sigma2qqbar2chi0chi0, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0chi0_swigregister", Sigma2qqbar2chi0chi0_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2charchi0", _wrap_new_Sigma2qqbar2charchi0, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2charchi0_sigmaKin", _wrap_Sigma2qqbar2charchi0_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2charchi0_sigmaHat", _wrap_Sigma2qqbar2charchi0_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2charchi0_resonanceA", _wrap_Sigma2qqbar2charchi0_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2charchi0", _wrap_delete_Sigma2qqbar2charchi0, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2charchi0_swigregister", Sigma2qqbar2charchi0_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2charchar", _wrap_new_Sigma2qqbar2charchar, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2charchar_sigmaKin", _wrap_Sigma2qqbar2charchar_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2charchar_sigmaHat", _wrap_Sigma2qqbar2charchar_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2charchar", _wrap_delete_Sigma2qqbar2charchar, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2charchar_swigregister", Sigma2qqbar2charchar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qg2chi0squark", _wrap_new_Sigma2qg2chi0squark, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2chi0squark_initProc", _wrap_Sigma2qg2chi0squark_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2chi0squark_sigmaKin", _wrap_Sigma2qg2chi0squark_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2chi0squark_sigmaHat", _wrap_Sigma2qg2chi0squark_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2chi0squark_setIdColAcol", _wrap_Sigma2qg2chi0squark_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2chi0squark_name", _wrap_Sigma2qg2chi0squark_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2chi0squark_code", _wrap_Sigma2qg2chi0squark_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2chi0squark_inFlux", _wrap_Sigma2qg2chi0squark_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2chi0squark_id3Mass", _wrap_Sigma2qg2chi0squark_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2chi0squark_id4Mass", _wrap_Sigma2qg2chi0squark_id4Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2chi0squark_isSUSY", _wrap_Sigma2qg2chi0squark_isSUSY, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qg2chi0squark", _wrap_delete_Sigma2qg2chi0squark, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2chi0squark_swigregister", Sigma2qg2chi0squark_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qg2charsquark", _wrap_new_Sigma2qg2charsquark, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2charsquark_initProc", _wrap_Sigma2qg2charsquark_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2charsquark_sigmaKin", _wrap_Sigma2qg2charsquark_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2charsquark_sigmaHat", _wrap_Sigma2qg2charsquark_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2charsquark_setIdColAcol", _wrap_Sigma2qg2charsquark_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qg2charsquark", _wrap_delete_Sigma2qg2charsquark, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2charsquark_swigregister", Sigma2qg2charsquark_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qq2squarksquark", _wrap_new_Sigma2qq2squarksquark, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2squarksquark_initProc", _wrap_Sigma2qq2squarksquark_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2squarksquark_sigmaKin", _wrap_Sigma2qq2squarksquark_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2squarksquark_sigmaHat", _wrap_Sigma2qq2squarksquark_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2squarksquark_setIdColAcol", _wrap_Sigma2qq2squarksquark_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2squarksquark_name", _wrap_Sigma2qq2squarksquark_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2squarksquark_code", _wrap_Sigma2qq2squarksquark_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2squarksquark_inFlux", _wrap_Sigma2qq2squarksquark_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2squarksquark_id3Mass", _wrap_Sigma2qq2squarksquark_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2squarksquark_id4Mass", _wrap_Sigma2qq2squarksquark_id4Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2squarksquark_isSUSY", _wrap_Sigma2qq2squarksquark_isSUSY, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qq2squarksquark", _wrap_delete_Sigma2qq2squarksquark, METH_VARARGS, NULL},
	 { (char *)"Sigma2qq2squarksquark_swigregister", Sigma2qq2squarksquark_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2squarkantisquark", _wrap_new_Sigma2qqbar2squarkantisquark, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2squarkantisquark_initProc", _wrap_Sigma2qqbar2squarkantisquark_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2squarkantisquark_sigmaKin", _wrap_Sigma2qqbar2squarkantisquark_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2squarkantisquark_sigmaHat", _wrap_Sigma2qqbar2squarkantisquark_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2squarkantisquark_setIdColAcol", _wrap_Sigma2qqbar2squarkantisquark_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2squarkantisquark_name", _wrap_Sigma2qqbar2squarkantisquark_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2squarkantisquark_code", _wrap_Sigma2qqbar2squarkantisquark_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2squarkantisquark_inFlux", _wrap_Sigma2qqbar2squarkantisquark_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2squarkantisquark_id3Mass", _wrap_Sigma2qqbar2squarkantisquark_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2squarkantisquark_id4Mass", _wrap_Sigma2qqbar2squarkantisquark_id4Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2squarkantisquark_isSUSY", _wrap_Sigma2qqbar2squarkantisquark_isSUSY, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2squarkantisquark", _wrap_delete_Sigma2qqbar2squarkantisquark, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2squarkantisquark_swigregister", Sigma2qqbar2squarkantisquark_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2gg2squarkantisquark", _wrap_new_Sigma2gg2squarkantisquark, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2squarkantisquark_initProc", _wrap_Sigma2gg2squarkantisquark_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2squarkantisquark_sigmaKin", _wrap_Sigma2gg2squarkantisquark_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2squarkantisquark_sigmaHat", _wrap_Sigma2gg2squarkantisquark_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2squarkantisquark_setIdColAcol", _wrap_Sigma2gg2squarkantisquark_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2squarkantisquark_name", _wrap_Sigma2gg2squarkantisquark_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2squarkantisquark_code", _wrap_Sigma2gg2squarkantisquark_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2squarkantisquark_inFlux", _wrap_Sigma2gg2squarkantisquark_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2squarkantisquark_id3Mass", _wrap_Sigma2gg2squarkantisquark_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2squarkantisquark_id4Mass", _wrap_Sigma2gg2squarkantisquark_id4Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2squarkantisquark_isSUSY", _wrap_Sigma2gg2squarkantisquark_isSUSY, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2gg2squarkantisquark", _wrap_delete_Sigma2gg2squarkantisquark, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2squarkantisquark_swigregister", Sigma2gg2squarkantisquark_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qg2squarkgluino", _wrap_new_Sigma2qg2squarkgluino, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2squarkgluino_initProc", _wrap_Sigma2qg2squarkgluino_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2squarkgluino_sigmaKin", _wrap_Sigma2qg2squarkgluino_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2squarkgluino_sigmaHat", _wrap_Sigma2qg2squarkgluino_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2squarkgluino_setIdColAcol", _wrap_Sigma2qg2squarkgluino_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2squarkgluino_name", _wrap_Sigma2qg2squarkgluino_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2squarkgluino_code", _wrap_Sigma2qg2squarkgluino_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2squarkgluino_inFlux", _wrap_Sigma2qg2squarkgluino_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2squarkgluino_id3Mass", _wrap_Sigma2qg2squarkgluino_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2squarkgluino_id4Mass", _wrap_Sigma2qg2squarkgluino_id4Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2squarkgluino_isSUSY", _wrap_Sigma2qg2squarkgluino_isSUSY, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qg2squarkgluino", _wrap_delete_Sigma2qg2squarkgluino, METH_VARARGS, NULL},
	 { (char *)"Sigma2qg2squarkgluino_swigregister", Sigma2qg2squarkgluino_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2gg2gluinogluino", _wrap_new_Sigma2gg2gluinogluino, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gluinogluino_initProc", _wrap_Sigma2gg2gluinogluino_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gluinogluino_sigmaKin", _wrap_Sigma2gg2gluinogluino_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gluinogluino_sigmaHat", _wrap_Sigma2gg2gluinogluino_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gluinogluino_setIdColAcol", _wrap_Sigma2gg2gluinogluino_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gluinogluino_name", _wrap_Sigma2gg2gluinogluino_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gluinogluino_code", _wrap_Sigma2gg2gluinogluino_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gluinogluino_inFlux", _wrap_Sigma2gg2gluinogluino_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gluinogluino_id3Mass", _wrap_Sigma2gg2gluinogluino_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gluinogluino_id4Mass", _wrap_Sigma2gg2gluinogluino_id4Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gluinogluino_isSUSY", _wrap_Sigma2gg2gluinogluino_isSUSY, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2gg2gluinogluino", _wrap_delete_Sigma2gg2gluinogluino, METH_VARARGS, NULL},
	 { (char *)"Sigma2gg2gluinogluino_swigregister", Sigma2gg2gluinogluino_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2gluinogluino", _wrap_new_Sigma2qqbar2gluinogluino, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gluinogluino_initProc", _wrap_Sigma2qqbar2gluinogluino_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gluinogluino_sigmaKin", _wrap_Sigma2qqbar2gluinogluino_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gluinogluino_sigmaHat", _wrap_Sigma2qqbar2gluinogluino_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gluinogluino_setIdColAcol", _wrap_Sigma2qqbar2gluinogluino_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gluinogluino_name", _wrap_Sigma2qqbar2gluinogluino_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gluinogluino_code", _wrap_Sigma2qqbar2gluinogluino_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gluinogluino_inFlux", _wrap_Sigma2qqbar2gluinogluino_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gluinogluino_id3Mass", _wrap_Sigma2qqbar2gluinogluino_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gluinogluino_id4Mass", _wrap_Sigma2qqbar2gluinogluino_id4Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gluinogluino_isSUSY", _wrap_Sigma2qqbar2gluinogluino_isSUSY, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2gluinogluino", _wrap_delete_Sigma2qqbar2gluinogluino, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2gluinogluino_swigregister", Sigma2qqbar2gluinogluino_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma1qq2antisquark", _wrap_new_Sigma1qq2antisquark, METH_VARARGS, NULL},
	 { (char *)"Sigma1qq2antisquark_initProc", _wrap_Sigma1qq2antisquark_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma1qq2antisquark_sigmaKin", _wrap_Sigma1qq2antisquark_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma1qq2antisquark_sigmaHat", _wrap_Sigma1qq2antisquark_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma1qq2antisquark_setIdColAcol", _wrap_Sigma1qq2antisquark_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma1qq2antisquark_name", _wrap_Sigma1qq2antisquark_name, METH_VARARGS, NULL},
	 { (char *)"Sigma1qq2antisquark_code", _wrap_Sigma1qq2antisquark_code, METH_VARARGS, NULL},
	 { (char *)"Sigma1qq2antisquark_inFlux", _wrap_Sigma1qq2antisquark_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma1qq2antisquark_isSUSY", _wrap_Sigma1qq2antisquark_isSUSY, METH_VARARGS, NULL},
	 { (char *)"Sigma1qq2antisquark_isRPV", _wrap_Sigma1qq2antisquark_isRPV, METH_VARARGS, NULL},
	 { (char *)"Sigma1qq2antisquark_resonanceA", _wrap_Sigma1qq2antisquark_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma1qq2antisquark", _wrap_delete_Sigma1qq2antisquark, METH_VARARGS, NULL},
	 { (char *)"Sigma1qq2antisquark_swigregister", Sigma1qq2antisquark_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2chi0gluino", _wrap_new_Sigma2qqbar2chi0gluino, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0gluino_initProc", _wrap_Sigma2qqbar2chi0gluino_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0gluino_sigmaKin", _wrap_Sigma2qqbar2chi0gluino_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0gluino_sigmaHat", _wrap_Sigma2qqbar2chi0gluino_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0gluino_setIdColAcol", _wrap_Sigma2qqbar2chi0gluino_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0gluino_name", _wrap_Sigma2qqbar2chi0gluino_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0gluino_code", _wrap_Sigma2qqbar2chi0gluino_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0gluino_inFlux", _wrap_Sigma2qqbar2chi0gluino_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0gluino_id3Mass", _wrap_Sigma2qqbar2chi0gluino_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0gluino_id4Mass", _wrap_Sigma2qqbar2chi0gluino_id4Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0gluino_resonanceA", _wrap_Sigma2qqbar2chi0gluino_resonanceA, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0gluino_isSUSY", _wrap_Sigma2qqbar2chi0gluino_isSUSY, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0gluino_getSigma0", _wrap_Sigma2qqbar2chi0gluino_getSigma0, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2chi0gluino", _wrap_delete_Sigma2qqbar2chi0gluino, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chi0gluino_swigregister", Sigma2qqbar2chi0gluino_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2chargluino", _wrap_new_Sigma2qqbar2chargluino, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chargluino_initProc", _wrap_Sigma2qqbar2chargluino_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chargluino_sigmaKin", _wrap_Sigma2qqbar2chargluino_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chargluino_sigmaHat", _wrap_Sigma2qqbar2chargluino_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chargluino_setIdColAcol", _wrap_Sigma2qqbar2chargluino_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chargluino_resonanceA", _wrap_Sigma2qqbar2chargluino_resonanceA, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2chargluino", _wrap_delete_Sigma2qqbar2chargluino, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2chargluino_swigregister", Sigma2qqbar2chargluino_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Sigma2qqbar2sleptonantislepton", _wrap_new_Sigma2qqbar2sleptonantislepton, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2sleptonantislepton_initProc", _wrap_Sigma2qqbar2sleptonantislepton_initProc, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2sleptonantislepton_sigmaKin", _wrap_Sigma2qqbar2sleptonantislepton_sigmaKin, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2sleptonantislepton_sigmaHat", _wrap_Sigma2qqbar2sleptonantislepton_sigmaHat, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2sleptonantislepton_setIdColAcol", _wrap_Sigma2qqbar2sleptonantislepton_setIdColAcol, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2sleptonantislepton_name", _wrap_Sigma2qqbar2sleptonantislepton_name, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2sleptonantislepton_code", _wrap_Sigma2qqbar2sleptonantislepton_code, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2sleptonantislepton_inFlux", _wrap_Sigma2qqbar2sleptonantislepton_inFlux, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2sleptonantislepton_id3Mass", _wrap_Sigma2qqbar2sleptonantislepton_id3Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2sleptonantislepton_id4Mass", _wrap_Sigma2qqbar2sleptonantislepton_id4Mass, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2sleptonantislepton_isSUSY", _wrap_Sigma2qqbar2sleptonantislepton_isSUSY, METH_VARARGS, NULL},
	 { (char *)"delete_Sigma2qqbar2sleptonantislepton", _wrap_delete_Sigma2qqbar2sleptonantislepton, METH_VARARGS, NULL},
	 { (char *)"Sigma2qqbar2sleptonantislepton_swigregister", Sigma2qqbar2sleptonantislepton_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SpaceDipoleEnd", _wrap_new_SpaceDipoleEnd, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_store", _wrap_SpaceDipoleEnd_store, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_system_set", _wrap_SpaceDipoleEnd_system_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_system_get", _wrap_SpaceDipoleEnd_system_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_side_set", _wrap_SpaceDipoleEnd_side_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_side_get", _wrap_SpaceDipoleEnd_side_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_iRadiator_set", _wrap_SpaceDipoleEnd_iRadiator_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_iRadiator_get", _wrap_SpaceDipoleEnd_iRadiator_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_iRecoiler_set", _wrap_SpaceDipoleEnd_iRecoiler_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_iRecoiler_get", _wrap_SpaceDipoleEnd_iRecoiler_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_pTmax_set", _wrap_SpaceDipoleEnd_pTmax_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_pTmax_get", _wrap_SpaceDipoleEnd_pTmax_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_colType_set", _wrap_SpaceDipoleEnd_colType_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_colType_get", _wrap_SpaceDipoleEnd_colType_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_chgType_set", _wrap_SpaceDipoleEnd_chgType_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_chgType_get", _wrap_SpaceDipoleEnd_chgType_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_weakType_set", _wrap_SpaceDipoleEnd_weakType_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_weakType_get", _wrap_SpaceDipoleEnd_weakType_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_MEtype_set", _wrap_SpaceDipoleEnd_MEtype_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_MEtype_get", _wrap_SpaceDipoleEnd_MEtype_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_normalRecoil_set", _wrap_SpaceDipoleEnd_normalRecoil_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_normalRecoil_get", _wrap_SpaceDipoleEnd_normalRecoil_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_weakPol_set", _wrap_SpaceDipoleEnd_weakPol_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_weakPol_get", _wrap_SpaceDipoleEnd_weakPol_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_iColPartner_set", _wrap_SpaceDipoleEnd_iColPartner_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_iColPartner_get", _wrap_SpaceDipoleEnd_iColPartner_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_idColPartner_set", _wrap_SpaceDipoleEnd_idColPartner_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_idColPartner_get", _wrap_SpaceDipoleEnd_idColPartner_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_nBranch_set", _wrap_SpaceDipoleEnd_nBranch_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_nBranch_get", _wrap_SpaceDipoleEnd_nBranch_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_idDaughter_set", _wrap_SpaceDipoleEnd_idDaughter_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_idDaughter_get", _wrap_SpaceDipoleEnd_idDaughter_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_idMother_set", _wrap_SpaceDipoleEnd_idMother_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_idMother_get", _wrap_SpaceDipoleEnd_idMother_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_idSister_set", _wrap_SpaceDipoleEnd_idSister_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_idSister_get", _wrap_SpaceDipoleEnd_idSister_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_iFinPol_set", _wrap_SpaceDipoleEnd_iFinPol_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_iFinPol_get", _wrap_SpaceDipoleEnd_iFinPol_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_x1_set", _wrap_SpaceDipoleEnd_x1_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_x1_get", _wrap_SpaceDipoleEnd_x1_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_x2_set", _wrap_SpaceDipoleEnd_x2_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_x2_get", _wrap_SpaceDipoleEnd_x2_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_m2Dip_set", _wrap_SpaceDipoleEnd_m2Dip_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_m2Dip_get", _wrap_SpaceDipoleEnd_m2Dip_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_pT2_set", _wrap_SpaceDipoleEnd_pT2_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_pT2_get", _wrap_SpaceDipoleEnd_pT2_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_z_set", _wrap_SpaceDipoleEnd_z_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_z_get", _wrap_SpaceDipoleEnd_z_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_xMo_set", _wrap_SpaceDipoleEnd_xMo_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_xMo_get", _wrap_SpaceDipoleEnd_xMo_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_Q2_set", _wrap_SpaceDipoleEnd_Q2_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_Q2_get", _wrap_SpaceDipoleEnd_Q2_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_mSister_set", _wrap_SpaceDipoleEnd_mSister_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_mSister_get", _wrap_SpaceDipoleEnd_mSister_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_m2Sister_set", _wrap_SpaceDipoleEnd_m2Sister_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_m2Sister_get", _wrap_SpaceDipoleEnd_m2Sister_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_pT2corr_set", _wrap_SpaceDipoleEnd_pT2corr_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_pT2corr_get", _wrap_SpaceDipoleEnd_pT2corr_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_pT2Old_set", _wrap_SpaceDipoleEnd_pT2Old_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_pT2Old_get", _wrap_SpaceDipoleEnd_pT2Old_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_zOld_set", _wrap_SpaceDipoleEnd_zOld_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_zOld_get", _wrap_SpaceDipoleEnd_zOld_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_asymPol_set", _wrap_SpaceDipoleEnd_asymPol_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_asymPol_get", _wrap_SpaceDipoleEnd_asymPol_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_m2IF_set", _wrap_SpaceDipoleEnd_m2IF_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_m2IF_get", _wrap_SpaceDipoleEnd_m2IF_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_mColPartner_set", _wrap_SpaceDipoleEnd_mColPartner_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_mColPartner_get", _wrap_SpaceDipoleEnd_mColPartner_get, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_pAccept_set", _wrap_SpaceDipoleEnd_pAccept_set, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_pAccept_get", _wrap_SpaceDipoleEnd_pAccept_get, METH_VARARGS, NULL},
	 { (char *)"delete_SpaceDipoleEnd", _wrap_delete_SpaceDipoleEnd, METH_VARARGS, NULL},
	 { (char *)"SpaceDipoleEnd_swigregister", SpaceDipoleEnd_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SpaceShower", _wrap_new_SpaceShower, METH_VARARGS, NULL},
	 { (char *)"delete_SpaceShower", _wrap_delete_SpaceShower, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_initPtr", _wrap_SpaceShower_initPtr, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_init", _wrap_SpaceShower_init, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_reassignBeamPtrs", _wrap_SpaceShower_reassignBeamPtrs, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_limitPTmax", _wrap_SpaceShower_limitPTmax, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_enhancePTmax", _wrap_SpaceShower_enhancePTmax, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_prepare", _wrap_SpaceShower_prepare, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_update", _wrap_SpaceShower_update, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_pTnext", _wrap_SpaceShower_pTnext, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_branch", _wrap_SpaceShower_branch, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_initUncertainties", _wrap_SpaceShower_initUncertainties, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_calcUncertainties", _wrap_SpaceShower_calcUncertainties, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_wasGamma2qqbar", _wrap_SpaceShower_wasGamma2qqbar, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_system", _wrap_SpaceShower_system, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_doRestart", _wrap_SpaceShower_doRestart, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_getHasWeaklyRadiated", _wrap_SpaceShower_getHasWeaklyRadiated, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_clustered", _wrap_SpaceShower_clustered, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_getStateVariables", _wrap_SpaceShower_getStateVariables, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_isSpacelike", _wrap_SpaceShower_isSpacelike, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_getSplittingName", _wrap_SpaceShower_getSplittingName, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_getSplittingProb", _wrap_SpaceShower_getSplittingProb, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_allowedSplitting", _wrap_SpaceShower_allowedSplitting, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_getRecoilers", _wrap_SpaceShower_getRecoilers, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_mergingHooksPtr_set", _wrap_SpaceShower_mergingHooksPtr_set, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_mergingHooksPtr_get", _wrap_SpaceShower_mergingHooksPtr_get, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_infoPtr_set", _wrap_SpaceShower_infoPtr_set, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_infoPtr_get", _wrap_SpaceShower_infoPtr_get, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_settingsPtr_set", _wrap_SpaceShower_settingsPtr_set, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_settingsPtr_get", _wrap_SpaceShower_settingsPtr_get, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_particleDataPtr_set", _wrap_SpaceShower_particleDataPtr_set, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_particleDataPtr_get", _wrap_SpaceShower_particleDataPtr_get, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_rndmPtr_set", _wrap_SpaceShower_rndmPtr_set, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_rndmPtr_get", _wrap_SpaceShower_rndmPtr_get, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_coupSMPtr_set", _wrap_SpaceShower_coupSMPtr_set, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_coupSMPtr_get", _wrap_SpaceShower_coupSMPtr_get, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_beamAPtr_set", _wrap_SpaceShower_beamAPtr_set, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_beamAPtr_get", _wrap_SpaceShower_beamAPtr_get, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_beamBPtr_set", _wrap_SpaceShower_beamBPtr_set, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_beamBPtr_get", _wrap_SpaceShower_beamBPtr_get, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_beamOffset_set", _wrap_SpaceShower_beamOffset_set, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_beamOffset_get", _wrap_SpaceShower_beamOffset_get, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_partonSystemsPtr_set", _wrap_SpaceShower_partonSystemsPtr_set, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_partonSystemsPtr_get", _wrap_SpaceShower_partonSystemsPtr_get, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_userHooksPtr_set", _wrap_SpaceShower_userHooksPtr_set, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_userHooksPtr_get", _wrap_SpaceShower_userHooksPtr_get, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_partonVertexPtr_set", _wrap_SpaceShower_partonVertexPtr_set, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_partonVertexPtr_get", _wrap_SpaceShower_partonVertexPtr_get, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_weakShowerMEs_set", _wrap_SpaceShower_weakShowerMEs_set, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_weakShowerMEs_get", _wrap_SpaceShower_weakShowerMEs_get, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_rescatterFail_set", _wrap_SpaceShower_rescatterFail_set, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_rescatterFail_get", _wrap_SpaceShower_rescatterFail_get, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_iSysSel_set", _wrap_SpaceShower_iSysSel_set, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_iSysSel_get", _wrap_SpaceShower_iSysSel_get, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_pTmaxFudge_set", _wrap_SpaceShower_pTmaxFudge_set, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_pTmaxFudge_get", _wrap_SpaceShower_pTmaxFudge_get, METH_VARARGS, NULL},
	 { (char *)"SpaceShower___str__", _wrap_SpaceShower___str__, METH_VARARGS, NULL},
	 { (char *)"disown_SpaceShower", _wrap_disown_SpaceShower, METH_VARARGS, NULL},
	 { (char *)"SpaceShower_swigregister", SpaceShower_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StringEnd", _wrap_new_StringEnd, METH_VARARGS, NULL},
	 { (char *)"StringEnd_init", _wrap_StringEnd_init, METH_VARARGS, NULL},
	 { (char *)"StringEnd_setUp", _wrap_StringEnd_setUp, METH_VARARGS, NULL},
	 { (char *)"StringEnd_newHadron", _wrap_StringEnd_newHadron, METH_VARARGS, NULL},
	 { (char *)"StringEnd_kinematicsHadron", _wrap_StringEnd_kinematicsHadron, METH_VARARGS, NULL},
	 { (char *)"StringEnd_kinematicsHadronTmp", _wrap_StringEnd_kinematicsHadronTmp, METH_VARARGS, NULL},
	 { (char *)"StringEnd_update", _wrap_StringEnd_update, METH_VARARGS, NULL},
	 { (char *)"StringEnd_particleDataPtr_set", _wrap_StringEnd_particleDataPtr_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_particleDataPtr_get", _wrap_StringEnd_particleDataPtr_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_flavSelPtr_set", _wrap_StringEnd_flavSelPtr_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_flavSelPtr_get", _wrap_StringEnd_flavSelPtr_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_pTSelPtr_set", _wrap_StringEnd_pTSelPtr_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_pTSelPtr_get", _wrap_StringEnd_pTSelPtr_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_zSelPtr_set", _wrap_StringEnd_zSelPtr_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_zSelPtr_get", _wrap_StringEnd_zSelPtr_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_fromPos_set", _wrap_StringEnd_fromPos_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_fromPos_get", _wrap_StringEnd_fromPos_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_thermalModel_set", _wrap_StringEnd_thermalModel_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_thermalModel_get", _wrap_StringEnd_thermalModel_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_mT2suppression_set", _wrap_StringEnd_mT2suppression_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_mT2suppression_get", _wrap_StringEnd_mT2suppression_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_iEnd_set", _wrap_StringEnd_iEnd_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_iEnd_get", _wrap_StringEnd_iEnd_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_iMax_set", _wrap_StringEnd_iMax_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_iMax_get", _wrap_StringEnd_iMax_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_idHad_set", _wrap_StringEnd_idHad_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_idHad_get", _wrap_StringEnd_idHad_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_iPosOld_set", _wrap_StringEnd_iPosOld_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_iPosOld_get", _wrap_StringEnd_iPosOld_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_iNegOld_set", _wrap_StringEnd_iNegOld_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_iNegOld_get", _wrap_StringEnd_iNegOld_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_iPosNew_set", _wrap_StringEnd_iPosNew_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_iPosNew_get", _wrap_StringEnd_iPosNew_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_iNegNew_set", _wrap_StringEnd_iNegNew_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_iNegNew_get", _wrap_StringEnd_iNegNew_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_hadSoFar_set", _wrap_StringEnd_hadSoFar_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_hadSoFar_get", _wrap_StringEnd_hadSoFar_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_pxOld_set", _wrap_StringEnd_pxOld_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_pxOld_get", _wrap_StringEnd_pxOld_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_pyOld_set", _wrap_StringEnd_pyOld_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_pyOld_get", _wrap_StringEnd_pyOld_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_pxNew_set", _wrap_StringEnd_pxNew_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_pxNew_get", _wrap_StringEnd_pxNew_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_pyNew_set", _wrap_StringEnd_pyNew_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_pyNew_get", _wrap_StringEnd_pyNew_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_pxHad_set", _wrap_StringEnd_pxHad_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_pxHad_get", _wrap_StringEnd_pxHad_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_pyHad_set", _wrap_StringEnd_pyHad_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_pyHad_get", _wrap_StringEnd_pyHad_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_mHad_set", _wrap_StringEnd_mHad_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_mHad_get", _wrap_StringEnd_mHad_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_mT2Had_set", _wrap_StringEnd_mT2Had_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_mT2Had_get", _wrap_StringEnd_mT2Had_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_zHad_set", _wrap_StringEnd_zHad_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_zHad_get", _wrap_StringEnd_zHad_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_GammaOld_set", _wrap_StringEnd_GammaOld_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_GammaOld_get", _wrap_StringEnd_GammaOld_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_GammaNew_set", _wrap_StringEnd_GammaNew_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_GammaNew_get", _wrap_StringEnd_GammaNew_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_xPosOld_set", _wrap_StringEnd_xPosOld_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_xPosOld_get", _wrap_StringEnd_xPosOld_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_xPosNew_set", _wrap_StringEnd_xPosNew_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_xPosNew_get", _wrap_StringEnd_xPosNew_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_xPosHad_set", _wrap_StringEnd_xPosHad_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_xPosHad_get", _wrap_StringEnd_xPosHad_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_xNegOld_set", _wrap_StringEnd_xNegOld_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_xNegOld_get", _wrap_StringEnd_xNegOld_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_xNegNew_set", _wrap_StringEnd_xNegNew_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_xNegNew_get", _wrap_StringEnd_xNegNew_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_xNegHad_set", _wrap_StringEnd_xNegHad_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_xNegHad_get", _wrap_StringEnd_xNegHad_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_aLund_set", _wrap_StringEnd_aLund_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_aLund_get", _wrap_StringEnd_aLund_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_bLund_set", _wrap_StringEnd_bLund_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_bLund_get", _wrap_StringEnd_bLund_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_flavOld_set", _wrap_StringEnd_flavOld_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_flavOld_get", _wrap_StringEnd_flavOld_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_flavNew_set", _wrap_StringEnd_flavNew_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_flavNew_get", _wrap_StringEnd_flavNew_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_pHad_set", _wrap_StringEnd_pHad_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_pHad_get", _wrap_StringEnd_pHad_get, METH_VARARGS, NULL},
	 { (char *)"StringEnd_pSoFar_set", _wrap_StringEnd_pSoFar_set, METH_VARARGS, NULL},
	 { (char *)"StringEnd_pSoFar_get", _wrap_StringEnd_pSoFar_get, METH_VARARGS, NULL},
	 { (char *)"delete_StringEnd", _wrap_delete_StringEnd, METH_VARARGS, NULL},
	 { (char *)"StringEnd_swigregister", StringEnd_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_StringFragmentation", _wrap_new_StringFragmentation, METH_VARARGS, NULL},
	 { (char *)"StringFragmentation_init", _wrap_StringFragmentation_init, METH_VARARGS, NULL},
	 { (char *)"StringFragmentation_fragment", _wrap_StringFragmentation_fragment, METH_VARARGS, NULL},
	 { (char *)"StringFragmentation_junctionRestFrame", _wrap_StringFragmentation_junctionRestFrame, METH_VARARGS, NULL},
	 { (char *)"delete_StringFragmentation", _wrap_delete_StringFragmentation, METH_VARARGS, NULL},
	 { (char *)"StringFragmentation_swigregister", StringFragmentation_swigregister, METH_VARARGS, NULL},
	 { (char *)"StringLength_init", _wrap_StringLength_init, METH_VARARGS, NULL},
	 { (char *)"StringLength_getLength", _wrap_StringLength_getLength, METH_VARARGS, NULL},
	 { (char *)"StringLength_getStringLength", _wrap_StringLength_getStringLength, METH_VARARGS, NULL},
	 { (char *)"StringLength_getJuncLength", _wrap_StringLength_getJuncLength, METH_VARARGS, NULL},
	 { (char *)"new_StringLength", _wrap_new_StringLength, METH_VARARGS, NULL},
	 { (char *)"delete_StringLength", _wrap_delete_StringLength, METH_VARARGS, NULL},
	 { (char *)"StringLength_swigregister", StringLength_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TimeDipoleEnd", _wrap_new_TimeDipoleEnd, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_iRadiator_set", _wrap_TimeDipoleEnd_iRadiator_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_iRadiator_get", _wrap_TimeDipoleEnd_iRadiator_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_iRecoiler_set", _wrap_TimeDipoleEnd_iRecoiler_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_iRecoiler_get", _wrap_TimeDipoleEnd_iRecoiler_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_pTmax_set", _wrap_TimeDipoleEnd_pTmax_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_pTmax_get", _wrap_TimeDipoleEnd_pTmax_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_colType_set", _wrap_TimeDipoleEnd_colType_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_colType_get", _wrap_TimeDipoleEnd_colType_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_chgType_set", _wrap_TimeDipoleEnd_chgType_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_chgType_get", _wrap_TimeDipoleEnd_chgType_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_gamType_set", _wrap_TimeDipoleEnd_gamType_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_gamType_get", _wrap_TimeDipoleEnd_gamType_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_weakType_set", _wrap_TimeDipoleEnd_weakType_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_weakType_get", _wrap_TimeDipoleEnd_weakType_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_isrType_set", _wrap_TimeDipoleEnd_isrType_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_isrType_get", _wrap_TimeDipoleEnd_isrType_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_system_set", _wrap_TimeDipoleEnd_system_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_system_get", _wrap_TimeDipoleEnd_system_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_systemRec_set", _wrap_TimeDipoleEnd_systemRec_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_systemRec_get", _wrap_TimeDipoleEnd_systemRec_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_MEtype_set", _wrap_TimeDipoleEnd_MEtype_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_MEtype_get", _wrap_TimeDipoleEnd_MEtype_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_iMEpartner_set", _wrap_TimeDipoleEnd_iMEpartner_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_iMEpartner_get", _wrap_TimeDipoleEnd_iMEpartner_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_weakPol_set", _wrap_TimeDipoleEnd_weakPol_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_weakPol_get", _wrap_TimeDipoleEnd_weakPol_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_isOctetOnium_set", _wrap_TimeDipoleEnd_isOctetOnium_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_isOctetOnium_get", _wrap_TimeDipoleEnd_isOctetOnium_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_isHiddenValley_set", _wrap_TimeDipoleEnd_isHiddenValley_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_isHiddenValley_get", _wrap_TimeDipoleEnd_isHiddenValley_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_colvType_set", _wrap_TimeDipoleEnd_colvType_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_colvType_get", _wrap_TimeDipoleEnd_colvType_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_MEmix_set", _wrap_TimeDipoleEnd_MEmix_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_MEmix_get", _wrap_TimeDipoleEnd_MEmix_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_MEorder_set", _wrap_TimeDipoleEnd_MEorder_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_MEorder_get", _wrap_TimeDipoleEnd_MEorder_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_MEsplit_set", _wrap_TimeDipoleEnd_MEsplit_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_MEsplit_get", _wrap_TimeDipoleEnd_MEsplit_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_MEgluinoRec_set", _wrap_TimeDipoleEnd_MEgluinoRec_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_MEgluinoRec_get", _wrap_TimeDipoleEnd_MEgluinoRec_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_isFlexible_set", _wrap_TimeDipoleEnd_isFlexible_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_isFlexible_get", _wrap_TimeDipoleEnd_isFlexible_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_flavour_set", _wrap_TimeDipoleEnd_flavour_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_flavour_get", _wrap_TimeDipoleEnd_flavour_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_iAunt_set", _wrap_TimeDipoleEnd_iAunt_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_iAunt_get", _wrap_TimeDipoleEnd_iAunt_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_mRad_set", _wrap_TimeDipoleEnd_mRad_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_mRad_get", _wrap_TimeDipoleEnd_mRad_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_m2Rad_set", _wrap_TimeDipoleEnd_m2Rad_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_m2Rad_get", _wrap_TimeDipoleEnd_m2Rad_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_mRec_set", _wrap_TimeDipoleEnd_mRec_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_mRec_get", _wrap_TimeDipoleEnd_mRec_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_m2Rec_set", _wrap_TimeDipoleEnd_m2Rec_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_m2Rec_get", _wrap_TimeDipoleEnd_m2Rec_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_mDip_set", _wrap_TimeDipoleEnd_mDip_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_mDip_get", _wrap_TimeDipoleEnd_mDip_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_m2Dip_set", _wrap_TimeDipoleEnd_m2Dip_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_m2Dip_get", _wrap_TimeDipoleEnd_m2Dip_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_m2DipCorr_set", _wrap_TimeDipoleEnd_m2DipCorr_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_m2DipCorr_get", _wrap_TimeDipoleEnd_m2DipCorr_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_pT2_set", _wrap_TimeDipoleEnd_pT2_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_pT2_get", _wrap_TimeDipoleEnd_pT2_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_m2_set", _wrap_TimeDipoleEnd_m2_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_m2_get", _wrap_TimeDipoleEnd_m2_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_z_set", _wrap_TimeDipoleEnd_z_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_z_get", _wrap_TimeDipoleEnd_z_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_mFlavour_set", _wrap_TimeDipoleEnd_mFlavour_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_mFlavour_get", _wrap_TimeDipoleEnd_mFlavour_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_asymPol_set", _wrap_TimeDipoleEnd_asymPol_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_asymPol_get", _wrap_TimeDipoleEnd_asymPol_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_flexFactor_set", _wrap_TimeDipoleEnd_flexFactor_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_flexFactor_get", _wrap_TimeDipoleEnd_flexFactor_get, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_pAccept_set", _wrap_TimeDipoleEnd_pAccept_set, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_pAccept_get", _wrap_TimeDipoleEnd_pAccept_get, METH_VARARGS, NULL},
	 { (char *)"delete_TimeDipoleEnd", _wrap_delete_TimeDipoleEnd, METH_VARARGS, NULL},
	 { (char *)"TimeDipoleEnd_swigregister", TimeDipoleEnd_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TimeShower", _wrap_new_TimeShower, METH_VARARGS, NULL},
	 { (char *)"delete_TimeShower", _wrap_delete_TimeShower, METH_VARARGS, NULL},
	 { (char *)"TimeShower_initPtr", _wrap_TimeShower_initPtr, METH_VARARGS, NULL},
	 { (char *)"TimeShower_init", _wrap_TimeShower_init, METH_VARARGS, NULL},
	 { (char *)"TimeShower_reassignBeamPtrs", _wrap_TimeShower_reassignBeamPtrs, METH_VARARGS, NULL},
	 { (char *)"TimeShower_limitPTmax", _wrap_TimeShower_limitPTmax, METH_VARARGS, NULL},
	 { (char *)"TimeShower_enhancePTmax", _wrap_TimeShower_enhancePTmax, METH_VARARGS, NULL},
	 { (char *)"TimeShower_shower", _wrap_TimeShower_shower, METH_VARARGS, NULL},
	 { (char *)"TimeShower_showerQED", _wrap_TimeShower_showerQED, METH_VARARGS, NULL},
	 { (char *)"TimeShower_pTLastInShower", _wrap_TimeShower_pTLastInShower, METH_VARARGS, NULL},
	 { (char *)"TimeShower_prepareGlobal", _wrap_TimeShower_prepareGlobal, METH_VARARGS, NULL},
	 { (char *)"TimeShower_prepare", _wrap_TimeShower_prepare, METH_VARARGS, NULL},
	 { (char *)"TimeShower_rescatterUpdate", _wrap_TimeShower_rescatterUpdate, METH_VARARGS, NULL},
	 { (char *)"TimeShower_update", _wrap_TimeShower_update, METH_VARARGS, NULL},
	 { (char *)"TimeShower_pTnext", _wrap_TimeShower_pTnext, METH_VARARGS, NULL},
	 { (char *)"TimeShower_branch", _wrap_TimeShower_branch, METH_VARARGS, NULL},
	 { (char *)"TimeShower_initUncertainties", _wrap_TimeShower_initUncertainties, METH_VARARGS, NULL},
	 { (char *)"TimeShower_calcUncertainties", _wrap_TimeShower_calcUncertainties, METH_VARARGS, NULL},
	 { (char *)"TimeShower_system", _wrap_TimeShower_system, METH_VARARGS, NULL},
	 { (char *)"TimeShower_getHasWeaklyRadiated", _wrap_TimeShower_getHasWeaklyRadiated, METH_VARARGS, NULL},
	 { (char *)"TimeShower_clustered", _wrap_TimeShower_clustered, METH_VARARGS, NULL},
	 { (char *)"TimeShower_getStateVariables", _wrap_TimeShower_getStateVariables, METH_VARARGS, NULL},
	 { (char *)"TimeShower_isTimelike", _wrap_TimeShower_isTimelike, METH_VARARGS, NULL},
	 { (char *)"TimeShower_getSplittingName", _wrap_TimeShower_getSplittingName, METH_VARARGS, NULL},
	 { (char *)"TimeShower_getSplittingProb", _wrap_TimeShower_getSplittingProb, METH_VARARGS, NULL},
	 { (char *)"TimeShower_allowedSplitting", _wrap_TimeShower_allowedSplitting, METH_VARARGS, NULL},
	 { (char *)"TimeShower_getRecoilers", _wrap_TimeShower_getRecoilers, METH_VARARGS, NULL},
	 { (char *)"TimeShower_mergingHooksPtr_set", _wrap_TimeShower_mergingHooksPtr_set, METH_VARARGS, NULL},
	 { (char *)"TimeShower_mergingHooksPtr_get", _wrap_TimeShower_mergingHooksPtr_get, METH_VARARGS, NULL},
	 { (char *)"TimeShower_infoPtr_set", _wrap_TimeShower_infoPtr_set, METH_VARARGS, NULL},
	 { (char *)"TimeShower_infoPtr_get", _wrap_TimeShower_infoPtr_get, METH_VARARGS, NULL},
	 { (char *)"TimeShower_settingsPtr_set", _wrap_TimeShower_settingsPtr_set, METH_VARARGS, NULL},
	 { (char *)"TimeShower_settingsPtr_get", _wrap_TimeShower_settingsPtr_get, METH_VARARGS, NULL},
	 { (char *)"TimeShower_particleDataPtr_set", _wrap_TimeShower_particleDataPtr_set, METH_VARARGS, NULL},
	 { (char *)"TimeShower_particleDataPtr_get", _wrap_TimeShower_particleDataPtr_get, METH_VARARGS, NULL},
	 { (char *)"TimeShower_rndmPtr_set", _wrap_TimeShower_rndmPtr_set, METH_VARARGS, NULL},
	 { (char *)"TimeShower_rndmPtr_get", _wrap_TimeShower_rndmPtr_get, METH_VARARGS, NULL},
	 { (char *)"TimeShower_coupSMPtr_set", _wrap_TimeShower_coupSMPtr_set, METH_VARARGS, NULL},
	 { (char *)"TimeShower_coupSMPtr_get", _wrap_TimeShower_coupSMPtr_get, METH_VARARGS, NULL},
	 { (char *)"TimeShower_beamAPtr_set", _wrap_TimeShower_beamAPtr_set, METH_VARARGS, NULL},
	 { (char *)"TimeShower_beamAPtr_get", _wrap_TimeShower_beamAPtr_get, METH_VARARGS, NULL},
	 { (char *)"TimeShower_beamBPtr_set", _wrap_TimeShower_beamBPtr_set, METH_VARARGS, NULL},
	 { (char *)"TimeShower_beamBPtr_get", _wrap_TimeShower_beamBPtr_get, METH_VARARGS, NULL},
	 { (char *)"TimeShower_beamOffset_set", _wrap_TimeShower_beamOffset_set, METH_VARARGS, NULL},
	 { (char *)"TimeShower_beamOffset_get", _wrap_TimeShower_beamOffset_get, METH_VARARGS, NULL},
	 { (char *)"TimeShower_partonSystemsPtr_set", _wrap_TimeShower_partonSystemsPtr_set, METH_VARARGS, NULL},
	 { (char *)"TimeShower_partonSystemsPtr_get", _wrap_TimeShower_partonSystemsPtr_get, METH_VARARGS, NULL},
	 { (char *)"TimeShower_userHooksPtr_set", _wrap_TimeShower_userHooksPtr_set, METH_VARARGS, NULL},
	 { (char *)"TimeShower_userHooksPtr_get", _wrap_TimeShower_userHooksPtr_get, METH_VARARGS, NULL},
	 { (char *)"TimeShower_partonVertexPtr_set", _wrap_TimeShower_partonVertexPtr_set, METH_VARARGS, NULL},
	 { (char *)"TimeShower_partonVertexPtr_get", _wrap_TimeShower_partonVertexPtr_get, METH_VARARGS, NULL},
	 { (char *)"TimeShower_weakShowerMEs_set", _wrap_TimeShower_weakShowerMEs_set, METH_VARARGS, NULL},
	 { (char *)"TimeShower_weakShowerMEs_get", _wrap_TimeShower_weakShowerMEs_get, METH_VARARGS, NULL},
	 { (char *)"TimeShower_iSysSel_set", _wrap_TimeShower_iSysSel_set, METH_VARARGS, NULL},
	 { (char *)"TimeShower_iSysSel_get", _wrap_TimeShower_iSysSel_get, METH_VARARGS, NULL},
	 { (char *)"TimeShower_pTmaxFudge_set", _wrap_TimeShower_pTmaxFudge_set, METH_VARARGS, NULL},
	 { (char *)"TimeShower_pTmaxFudge_get", _wrap_TimeShower_pTmaxFudge_get, METH_VARARGS, NULL},
	 { (char *)"TimeShower_pTLastBranch_set", _wrap_TimeShower_pTLastBranch_set, METH_VARARGS, NULL},
	 { (char *)"TimeShower_pTLastBranch_get", _wrap_TimeShower_pTLastBranch_get, METH_VARARGS, NULL},
	 { (char *)"TimeShower___str__", _wrap_TimeShower___str__, METH_VARARGS, NULL},
	 { (char *)"disown_TimeShower", _wrap_disown_TimeShower, METH_VARARGS, NULL},
	 { (char *)"TimeShower_swigregister", TimeShower_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ColourDipole", _wrap_new_ColourDipole, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_mDip", _wrap_ColourDipole_mDip, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_col_set", _wrap_ColourDipole_col_set, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_col_get", _wrap_ColourDipole_col_get, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_iCol_set", _wrap_ColourDipole_iCol_set, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_iCol_get", _wrap_ColourDipole_iCol_get, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_iAcol_set", _wrap_ColourDipole_iAcol_set, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_iAcol_get", _wrap_ColourDipole_iAcol_get, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_iColLeg_set", _wrap_ColourDipole_iColLeg_set, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_iColLeg_get", _wrap_ColourDipole_iColLeg_get, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_iAcolLeg_set", _wrap_ColourDipole_iAcolLeg_set, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_iAcolLeg_get", _wrap_ColourDipole_iAcolLeg_get, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_colReconnection_set", _wrap_ColourDipole_colReconnection_set, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_colReconnection_get", _wrap_ColourDipole_colReconnection_get, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_isJun_set", _wrap_ColourDipole_isJun_set, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_isJun_get", _wrap_ColourDipole_isJun_get, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_isAntiJun_set", _wrap_ColourDipole_isAntiJun_set, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_isAntiJun_get", _wrap_ColourDipole_isAntiJun_get, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_isActive_set", _wrap_ColourDipole_isActive_set, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_isActive_get", _wrap_ColourDipole_isActive_get, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_isReal_set", _wrap_ColourDipole_isReal_set, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_isReal_get", _wrap_ColourDipole_isReal_get, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_printed_set", _wrap_ColourDipole_printed_set, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_printed_get", _wrap_ColourDipole_printed_get, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_leftDip_set", _wrap_ColourDipole_leftDip_set, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_leftDip_get", _wrap_ColourDipole_leftDip_get, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_rightDip_set", _wrap_ColourDipole_rightDip_set, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_rightDip_get", _wrap_ColourDipole_rightDip_get, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_colDips_set", _wrap_ColourDipole_colDips_set, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_colDips_get", _wrap_ColourDipole_colDips_get, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_acolDips_set", _wrap_ColourDipole_acolDips_set, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_acolDips_get", _wrap_ColourDipole_acolDips_get, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_p1p2_set", _wrap_ColourDipole_p1p2_set, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_p1p2_get", _wrap_ColourDipole_p1p2_get, METH_VARARGS, NULL},
	 { (char *)"ColourDipole___str__", _wrap_ColourDipole___str__, METH_VARARGS, NULL},
	 { (char *)"delete_ColourDipole", _wrap_delete_ColourDipole, METH_VARARGS, NULL},
	 { (char *)"ColourDipole_swigregister", ColourDipole_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ColourJunction", _wrap_new_ColourJunction, METH_VARARGS, NULL},
	 { (char *)"ColourJunction_getColDip", _wrap_ColourJunction_getColDip, METH_VARARGS, NULL},
	 { (char *)"ColourJunction_setColDip", _wrap_ColourJunction_setColDip, METH_VARARGS, NULL},
	 { (char *)"ColourJunction_dips_set", _wrap_ColourJunction_dips_set, METH_VARARGS, NULL},
	 { (char *)"ColourJunction_dips_get", _wrap_ColourJunction_dips_get, METH_VARARGS, NULL},
	 { (char *)"ColourJunction_dipsOrig_set", _wrap_ColourJunction_dipsOrig_set, METH_VARARGS, NULL},
	 { (char *)"ColourJunction_dipsOrig_get", _wrap_ColourJunction_dipsOrig_get, METH_VARARGS, NULL},
	 { (char *)"ColourJunction___str__", _wrap_ColourJunction___str__, METH_VARARGS, NULL},
	 { (char *)"delete_ColourJunction", _wrap_delete_ColourJunction, METH_VARARGS, NULL},
	 { (char *)"ColourJunction_swigregister", ColourJunction_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TrialReconnection", _wrap_new_TrialReconnection, METH_VARARGS, NULL},
	 { (char *)"TrialReconnection_dips_set", _wrap_TrialReconnection_dips_set, METH_VARARGS, NULL},
	 { (char *)"TrialReconnection_dips_get", _wrap_TrialReconnection_dips_get, METH_VARARGS, NULL},
	 { (char *)"TrialReconnection_mode_set", _wrap_TrialReconnection_mode_set, METH_VARARGS, NULL},
	 { (char *)"TrialReconnection_mode_get", _wrap_TrialReconnection_mode_get, METH_VARARGS, NULL},
	 { (char *)"TrialReconnection_lambdaDiff_set", _wrap_TrialReconnection_lambdaDiff_set, METH_VARARGS, NULL},
	 { (char *)"TrialReconnection_lambdaDiff_get", _wrap_TrialReconnection_lambdaDiff_get, METH_VARARGS, NULL},
	 { (char *)"delete_TrialReconnection", _wrap_delete_TrialReconnection, METH_VARARGS, NULL},
	 { (char *)"TrialReconnection_swigregister", TrialReconnection_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ColourParticle", _wrap_new_ColourParticle, METH_VARARGS, NULL},
	 { (char *)"ColourParticle_dips_set", _wrap_ColourParticle_dips_set, METH_VARARGS, NULL},
	 { (char *)"ColourParticle_dips_get", _wrap_ColourParticle_dips_get, METH_VARARGS, NULL},
	 { (char *)"ColourParticle_colEndIncluded_set", _wrap_ColourParticle_colEndIncluded_set, METH_VARARGS, NULL},
	 { (char *)"ColourParticle_colEndIncluded_get", _wrap_ColourParticle_colEndIncluded_get, METH_VARARGS, NULL},
	 { (char *)"ColourParticle_acolEndIncluded_set", _wrap_ColourParticle_acolEndIncluded_set, METH_VARARGS, NULL},
	 { (char *)"ColourParticle_acolEndIncluded_get", _wrap_ColourParticle_acolEndIncluded_get, METH_VARARGS, NULL},
	 { (char *)"ColourParticle_activeDips_set", _wrap_ColourParticle_activeDips_set, METH_VARARGS, NULL},
	 { (char *)"ColourParticle_activeDips_get", _wrap_ColourParticle_activeDips_get, METH_VARARGS, NULL},
	 { (char *)"ColourParticle_isJun_set", _wrap_ColourParticle_isJun_set, METH_VARARGS, NULL},
	 { (char *)"ColourParticle_isJun_get", _wrap_ColourParticle_isJun_get, METH_VARARGS, NULL},
	 { (char *)"ColourParticle_junKind_set", _wrap_ColourParticle_junKind_set, METH_VARARGS, NULL},
	 { (char *)"ColourParticle_junKind_get", _wrap_ColourParticle_junKind_get, METH_VARARGS, NULL},
	 { (char *)"ColourParticle_listParticle", _wrap_ColourParticle_listParticle, METH_VARARGS, NULL},
	 { (char *)"ColourParticle_listActiveDips", _wrap_ColourParticle_listActiveDips, METH_VARARGS, NULL},
	 { (char *)"ColourParticle_listDips", _wrap_ColourParticle_listDips, METH_VARARGS, NULL},
	 { (char *)"delete_ColourParticle", _wrap_delete_ColourParticle, METH_VARARGS, NULL},
	 { (char *)"ColourParticle_swigregister", ColourParticle_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ColourReconnection", _wrap_new_ColourReconnection, METH_VARARGS, NULL},
	 { (char *)"ColourReconnection_init", _wrap_ColourReconnection_init, METH_VARARGS, NULL},
	 { (char *)"ColourReconnection_reassignBeamPtrs", _wrap_ColourReconnection_reassignBeamPtrs, METH_VARARGS, NULL},
	 { (char *)"ColourReconnection_next", _wrap_ColourReconnection_next, METH_VARARGS, NULL},
	 { (char *)"delete_ColourReconnection", _wrap_delete_ColourReconnection, METH_VARARGS, NULL},
	 { (char *)"ColourReconnection_swigregister", ColourReconnection_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HVStringFlav", _wrap_new_HVStringFlav, METH_VARARGS, NULL},
	 { (char *)"delete_HVStringFlav", _wrap_delete_HVStringFlav, METH_VARARGS, NULL},
	 { (char *)"HVStringFlav_init", _wrap_HVStringFlav_init, METH_VARARGS, NULL},
	 { (char *)"HVStringFlav_pick", _wrap_HVStringFlav_pick, METH_VARARGS, NULL},
	 { (char *)"HVStringFlav_combine", _wrap_HVStringFlav_combine, METH_VARARGS, NULL},
	 { (char *)"HVStringFlav_swigregister", HVStringFlav_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HVStringPT", _wrap_new_HVStringPT, METH_VARARGS, NULL},
	 { (char *)"delete_HVStringPT", _wrap_delete_HVStringPT, METH_VARARGS, NULL},
	 { (char *)"HVStringPT_init", _wrap_HVStringPT_init, METH_VARARGS, NULL},
	 { (char *)"HVStringPT_swigregister", HVStringPT_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HVStringZ", _wrap_new_HVStringZ, METH_VARARGS, NULL},
	 { (char *)"delete_HVStringZ", _wrap_delete_HVStringZ, METH_VARARGS, NULL},
	 { (char *)"HVStringZ_init", _wrap_HVStringZ_init, METH_VARARGS, NULL},
	 { (char *)"HVStringZ_zFrag", _wrap_HVStringZ_zFrag, METH_VARARGS, NULL},
	 { (char *)"HVStringZ_stopMass", _wrap_HVStringZ_stopMass, METH_VARARGS, NULL},
	 { (char *)"HVStringZ_stopNewFlav", _wrap_HVStringZ_stopNewFlav, METH_VARARGS, NULL},
	 { (char *)"HVStringZ_stopSmear", _wrap_HVStringZ_stopSmear, METH_VARARGS, NULL},
	 { (char *)"HVStringZ_swigregister", HVStringZ_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HiddenValleyFragmentation", _wrap_new_HiddenValleyFragmentation, METH_VARARGS, NULL},
	 { (char *)"delete_HiddenValleyFragmentation", _wrap_delete_HiddenValleyFragmentation, METH_VARARGS, NULL},
	 { (char *)"HiddenValleyFragmentation_init", _wrap_HiddenValleyFragmentation_init, METH_VARARGS, NULL},
	 { (char *)"HiddenValleyFragmentation_fragment", _wrap_HiddenValleyFragmentation_fragment, METH_VARARGS, NULL},
	 { (char *)"HiddenValleyFragmentation_swigregister", HiddenValleyFragmentation_swigregister, METH_VARARGS, NULL},
	 { (char *)"JunctionSplitting_init", _wrap_JunctionSplitting_init, METH_VARARGS, NULL},
	 { (char *)"JunctionSplitting_checkColours", _wrap_JunctionSplitting_checkColours, METH_VARARGS, NULL},
	 { (char *)"new_JunctionSplitting", _wrap_new_JunctionSplitting, METH_VARARGS, NULL},
	 { (char *)"delete_JunctionSplitting", _wrap_delete_JunctionSplitting, METH_VARARGS, NULL},
	 { (char *)"JunctionSplitting_swigregister", JunctionSplitting_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_DecayHandler", _wrap_delete_DecayHandler, METH_VARARGS, NULL},
	 { (char *)"DecayHandler_decay", _wrap_DecayHandler_decay, METH_VARARGS, NULL},
	 { (char *)"DecayHandler_chainDecay", _wrap_DecayHandler_chainDecay, METH_VARARGS, NULL},
	 { (char *)"new_DecayHandler", _wrap_new_DecayHandler, METH_VARARGS, NULL},
	 { (char *)"disown_DecayHandler", _wrap_disown_DecayHandler, METH_VARARGS, NULL},
	 { (char *)"DecayHandler_swigregister", DecayHandler_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ParticleDecays", _wrap_new_ParticleDecays, METH_VARARGS, NULL},
	 { (char *)"ParticleDecays_init", _wrap_ParticleDecays_init, METH_VARARGS, NULL},
	 { (char *)"ParticleDecays_decay", _wrap_ParticleDecays_decay, METH_VARARGS, NULL},
	 { (char *)"ParticleDecays_moreToDo", _wrap_ParticleDecays_moreToDo, METH_VARARGS, NULL},
	 { (char *)"delete_ParticleDecays", _wrap_delete_ParticleDecays, METH_VARARGS, NULL},
	 { (char *)"ParticleDecays_swigregister", ParticleDecays_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ProcessContainer", _wrap_new_ProcessContainer, METH_VARARGS, NULL},
	 { (char *)"delete_ProcessContainer", _wrap_delete_ProcessContainer, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_init", _wrap_ProcessContainer_init, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_setLHAPtr", _wrap_ProcessContainer_setLHAPtr, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_newECM", _wrap_ProcessContainer_newECM, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_trialProcess", _wrap_ProcessContainer_trialProcess, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_constructState", _wrap_ProcessContainer_constructState, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_constructProcess", _wrap_ProcessContainer_constructProcess, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_constructDecays", _wrap_ProcessContainer_constructDecays, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_decayResonances", _wrap_ProcessContainer_decayResonances, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_accumulate", _wrap_ProcessContainer_accumulate, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_reset", _wrap_ProcessContainer_reset, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_setBeamModes", _wrap_ProcessContainer_setBeamModes, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_chooseVMDstates", _wrap_ProcessContainer_chooseVMDstates, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_name", _wrap_ProcessContainer_name, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_code", _wrap_ProcessContainer_code, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_nFinal", _wrap_ProcessContainer_nFinal, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_isSUSY", _wrap_ProcessContainer_isSUSY, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_isNonDiffractive", _wrap_ProcessContainer_isNonDiffractive, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_isSoftQCD", _wrap_ProcessContainer_isSoftQCD, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_newSigmaMax", _wrap_ProcessContainer_newSigmaMax, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_sigmaMax", _wrap_ProcessContainer_sigmaMax, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_nTried", _wrap_ProcessContainer_nTried, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_nSelected", _wrap_ProcessContainer_nSelected, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_nAccepted", _wrap_ProcessContainer_nAccepted, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_weightSum", _wrap_ProcessContainer_weightSum, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_sigmaSelMC", _wrap_ProcessContainer_sigmaSelMC, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_sigmaMC", _wrap_ProcessContainer_sigmaMC, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_deltaMC", _wrap_ProcessContainer_deltaMC, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_id1", _wrap_ProcessContainer_id1, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_id2", _wrap_ProcessContainer_id2, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_x1", _wrap_ProcessContainer_x1, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_x2", _wrap_ProcessContainer_x2, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_Q2Fac", _wrap_ProcessContainer_Q2Fac, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_mHat", _wrap_ProcessContainer_mHat, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_pTHat", _wrap_ProcessContainer_pTHat, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_isLHAContainer", _wrap_ProcessContainer_isLHAContainer, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_lhaStrategy", _wrap_ProcessContainer_lhaStrategy, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_codeLHASize", _wrap_ProcessContainer_codeLHASize, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_subCodeLHA", _wrap_ProcessContainer_subCodeLHA, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_nTriedLHA", _wrap_ProcessContainer_nTriedLHA, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_nSelectedLHA", _wrap_ProcessContainer_nSelectedLHA, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_nAcceptedLHA", _wrap_ProcessContainer_nAcceptedLHA, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_isSame", _wrap_ProcessContainer_isSame, METH_VARARGS, NULL},
	 { (char *)"ProcessContainer_swigregister", ProcessContainer_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SetupContainers", _wrap_new_SetupContainers, METH_VARARGS, NULL},
	 { (char *)"SetupContainers_init", _wrap_SetupContainers_init, METH_VARARGS, NULL},
	 { (char *)"SetupContainers_init2", _wrap_SetupContainers_init2, METH_VARARGS, NULL},
	 { (char *)"delete_SetupContainers", _wrap_delete_SetupContainers, METH_VARARGS, NULL},
	 { (char *)"SetupContainers_swigregister", SetupContainers_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ProcessLevel", _wrap_new_ProcessLevel, METH_VARARGS, NULL},
	 { (char *)"delete_ProcessLevel", _wrap_delete_ProcessLevel, METH_VARARGS, NULL},
	 { (char *)"ProcessLevel_init", _wrap_ProcessLevel_init, METH_VARARGS, NULL},
	 { (char *)"ProcessLevel_setLHAPtr", _wrap_ProcessLevel_setLHAPtr, METH_VARARGS, NULL},
	 { (char *)"ProcessLevel_next", _wrap_ProcessLevel_next, METH_VARARGS, NULL},
	 { (char *)"ProcessLevel_nextLHAdec", _wrap_ProcessLevel_nextLHAdec, METH_VARARGS, NULL},
	 { (char *)"ProcessLevel_accumulate", _wrap_ProcessLevel_accumulate, METH_VARARGS, NULL},
	 { (char *)"ProcessLevel_statistics", _wrap_ProcessLevel_statistics, METH_VARARGS, NULL},
	 { (char *)"ProcessLevel_resetStatistics", _wrap_ProcessLevel_resetStatistics, METH_VARARGS, NULL},
	 { (char *)"ProcessLevel_findJunctions", _wrap_ProcessLevel_findJunctions, METH_VARARGS, NULL},
	 { (char *)"ProcessLevel_initDecays", _wrap_ProcessLevel_initDecays, METH_VARARGS, NULL},
	 { (char *)"ProcessLevel_nextDecays", _wrap_ProcessLevel_nextDecays, METH_VARARGS, NULL},
	 { (char *)"ProcessLevel_swigregister", ProcessLevel_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_BeamRemnants", _wrap_new_BeamRemnants, METH_VARARGS, NULL},
	 { (char *)"BeamRemnants_init", _wrap_BeamRemnants_init, METH_VARARGS, NULL},
	 { (char *)"BeamRemnants_reassignBeamPtrs", _wrap_BeamRemnants_reassignBeamPtrs, METH_VARARGS, NULL},
	 { (char *)"BeamRemnants_add", _wrap_BeamRemnants_add, METH_VARARGS, NULL},
	 { (char *)"delete_BeamRemnants", _wrap_delete_BeamRemnants, METH_VARARGS, NULL},
	 { (char *)"BeamRemnants_swigregister", BeamRemnants_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HadronLevel", _wrap_new_HadronLevel, METH_VARARGS, NULL},
	 { (char *)"HadronLevel_init", _wrap_HadronLevel_init, METH_VARARGS, NULL},
	 { (char *)"HadronLevel_getStringFlavPtr", _wrap_HadronLevel_getStringFlavPtr, METH_VARARGS, NULL},
	 { (char *)"HadronLevel_next", _wrap_HadronLevel_next, METH_VARARGS, NULL},
	 { (char *)"HadronLevel_moreDecays", _wrap_HadronLevel_moreDecays, METH_VARARGS, NULL},
	 { (char *)"delete_HadronLevel", _wrap_delete_HadronLevel, METH_VARARGS, NULL},
	 { (char *)"HadronLevel_swigregister", HadronLevel_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HardDiffraction", _wrap_new_HardDiffraction, METH_VARARGS, NULL},
	 { (char *)"delete_HardDiffraction", _wrap_delete_HardDiffraction, METH_VARARGS, NULL},
	 { (char *)"HardDiffraction_init", _wrap_HardDiffraction_init, METH_VARARGS, NULL},
	 { (char *)"HardDiffraction_isDiffractive", _wrap_HardDiffraction_isDiffractive, METH_VARARGS, NULL},
	 { (char *)"HardDiffraction_getXPomeronA", _wrap_HardDiffraction_getXPomeronA, METH_VARARGS, NULL},
	 { (char *)"HardDiffraction_getXPomeronB", _wrap_HardDiffraction_getXPomeronB, METH_VARARGS, NULL},
	 { (char *)"HardDiffraction_getTPomeronA", _wrap_HardDiffraction_getTPomeronA, METH_VARARGS, NULL},
	 { (char *)"HardDiffraction_getTPomeronB", _wrap_HardDiffraction_getTPomeronB, METH_VARARGS, NULL},
	 { (char *)"HardDiffraction_getThetaPomeronA", _wrap_HardDiffraction_getThetaPomeronA, METH_VARARGS, NULL},
	 { (char *)"HardDiffraction_getThetaPomeronB", _wrap_HardDiffraction_getThetaPomeronB, METH_VARARGS, NULL},
	 { (char *)"HardDiffraction_swigregister", HardDiffraction_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PartonLevel", _wrap_new_PartonLevel, METH_VARARGS, NULL},
	 { (char *)"PartonLevel_init", _wrap_PartonLevel_init, METH_VARARGS, NULL},
	 { (char *)"PartonLevel_next", _wrap_PartonLevel_next, METH_VARARGS, NULL},
	 { (char *)"PartonLevel_setupShowerSys", _wrap_PartonLevel_setupShowerSys, METH_VARARGS, NULL},
	 { (char *)"PartonLevel_resonanceShowers", _wrap_PartonLevel_resonanceShowers, METH_VARARGS, NULL},
	 { (char *)"PartonLevel_wzDecayShowers", _wrap_PartonLevel_wzDecayShowers, METH_VARARGS, NULL},
	 { (char *)"PartonLevel_hasVetoed", _wrap_PartonLevel_hasVetoed, METH_VARARGS, NULL},
	 { (char *)"PartonLevel_hasVetoedDiff", _wrap_PartonLevel_hasVetoedDiff, METH_VARARGS, NULL},
	 { (char *)"PartonLevel_accumulate", _wrap_PartonLevel_accumulate, METH_VARARGS, NULL},
	 { (char *)"PartonLevel_statistics", _wrap_PartonLevel_statistics, METH_VARARGS, NULL},
	 { (char *)"PartonLevel_resetStatistics", _wrap_PartonLevel_resetStatistics, METH_VARARGS, NULL},
	 { (char *)"PartonLevel_resetTrial", _wrap_PartonLevel_resetTrial, METH_VARARGS, NULL},
	 { (char *)"PartonLevel_pTLastInShower", _wrap_PartonLevel_pTLastInShower, METH_VARARGS, NULL},
	 { (char *)"PartonLevel_typeLastInShower", _wrap_PartonLevel_typeLastInShower, METH_VARARGS, NULL},
	 { (char *)"PartonLevel_timesDecPtr_set", _wrap_PartonLevel_timesDecPtr_set, METH_VARARGS, NULL},
	 { (char *)"PartonLevel_timesDecPtr_get", _wrap_PartonLevel_timesDecPtr_get, METH_VARARGS, NULL},
	 { (char *)"PartonLevel_timesPtr_set", _wrap_PartonLevel_timesPtr_set, METH_VARARGS, NULL},
	 { (char *)"PartonLevel_timesPtr_get", _wrap_PartonLevel_timesPtr_get, METH_VARARGS, NULL},
	 { (char *)"PartonLevel_spacePtr_set", _wrap_PartonLevel_spacePtr_set, METH_VARARGS, NULL},
	 { (char *)"PartonLevel_spacePtr_get", _wrap_PartonLevel_spacePtr_get, METH_VARARGS, NULL},
	 { (char *)"PartonLevel_userHooksPtr_set", _wrap_PartonLevel_userHooksPtr_set, METH_VARARGS, NULL},
	 { (char *)"PartonLevel_userHooksPtr_get", _wrap_PartonLevel_userHooksPtr_get, METH_VARARGS, NULL},
	 { (char *)"delete_PartonLevel", _wrap_delete_PartonLevel, METH_VARARGS, NULL},
	 { (char *)"PartonLevel_swigregister", PartonLevel_swigregister, METH_VARARGS, NULL},
	 { (char *)"Clustering_emitted_set", _wrap_Clustering_emitted_set, METH_VARARGS, NULL},
	 { (char *)"Clustering_emitted_get", _wrap_Clustering_emitted_get, METH_VARARGS, NULL},
	 { (char *)"Clustering_emittor_set", _wrap_Clustering_emittor_set, METH_VARARGS, NULL},
	 { (char *)"Clustering_emittor_get", _wrap_Clustering_emittor_get, METH_VARARGS, NULL},
	 { (char *)"Clustering_recoiler_set", _wrap_Clustering_recoiler_set, METH_VARARGS, NULL},
	 { (char *)"Clustering_recoiler_get", _wrap_Clustering_recoiler_get, METH_VARARGS, NULL},
	 { (char *)"Clustering_partner_set", _wrap_Clustering_partner_set, METH_VARARGS, NULL},
	 { (char *)"Clustering_partner_get", _wrap_Clustering_partner_get, METH_VARARGS, NULL},
	 { (char *)"Clustering_pTscale_set", _wrap_Clustering_pTscale_set, METH_VARARGS, NULL},
	 { (char *)"Clustering_pTscale_get", _wrap_Clustering_pTscale_get, METH_VARARGS, NULL},
	 { (char *)"Clustering_flavRadBef_set", _wrap_Clustering_flavRadBef_set, METH_VARARGS, NULL},
	 { (char *)"Clustering_flavRadBef_get", _wrap_Clustering_flavRadBef_get, METH_VARARGS, NULL},
	 { (char *)"Clustering_spinRad_set", _wrap_Clustering_spinRad_set, METH_VARARGS, NULL},
	 { (char *)"Clustering_spinRad_get", _wrap_Clustering_spinRad_get, METH_VARARGS, NULL},
	 { (char *)"Clustering_spinEmt_set", _wrap_Clustering_spinEmt_set, METH_VARARGS, NULL},
	 { (char *)"Clustering_spinEmt_get", _wrap_Clustering_spinEmt_get, METH_VARARGS, NULL},
	 { (char *)"Clustering_spinRec_set", _wrap_Clustering_spinRec_set, METH_VARARGS, NULL},
	 { (char *)"Clustering_spinRec_get", _wrap_Clustering_spinRec_get, METH_VARARGS, NULL},
	 { (char *)"Clustering_spinRadBef_set", _wrap_Clustering_spinRadBef_set, METH_VARARGS, NULL},
	 { (char *)"Clustering_spinRadBef_get", _wrap_Clustering_spinRadBef_get, METH_VARARGS, NULL},
	 { (char *)"Clustering_radBef_set", _wrap_Clustering_radBef_set, METH_VARARGS, NULL},
	 { (char *)"Clustering_radBef_get", _wrap_Clustering_radBef_get, METH_VARARGS, NULL},
	 { (char *)"Clustering_recBef_set", _wrap_Clustering_recBef_set, METH_VARARGS, NULL},
	 { (char *)"Clustering_recBef_get", _wrap_Clustering_recBef_get, METH_VARARGS, NULL},
	 { (char *)"delete_Clustering", _wrap_delete_Clustering, METH_VARARGS, NULL},
	 { (char *)"new_Clustering", _wrap_new_Clustering, METH_VARARGS, NULL},
	 { (char *)"Clustering_pT", _wrap_Clustering_pT, METH_VARARGS, NULL},
	 { (char *)"Clustering___str__", _wrap_Clustering___str__, METH_VARARGS, NULL},
	 { (char *)"Clustering_swigregister", Clustering_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_History", _wrap_new_History, METH_VARARGS, NULL},
	 { (char *)"delete_History", _wrap_delete_History, METH_VARARGS, NULL},
	 { (char *)"History_projectOntoDesiredHistories", _wrap_History_projectOntoDesiredHistories, METH_VARARGS, NULL},
	 { (char *)"History_weightTREE", _wrap_History_weightTREE, METH_VARARGS, NULL},
	 { (char *)"History_weightLOOP", _wrap_History_weightLOOP, METH_VARARGS, NULL},
	 { (char *)"History_weightFIRST", _wrap_History_weightFIRST, METH_VARARGS, NULL},
	 { (char *)"History_weight_UMEPS_TREE", _wrap_History_weight_UMEPS_TREE, METH_VARARGS, NULL},
	 { (char *)"History_weight_UMEPS_SUBT", _wrap_History_weight_UMEPS_SUBT, METH_VARARGS, NULL},
	 { (char *)"History_weight_UNLOPS_TREE", _wrap_History_weight_UNLOPS_TREE, METH_VARARGS, NULL},
	 { (char *)"History_weight_UNLOPS_SUBT", _wrap_History_weight_UNLOPS_SUBT, METH_VARARGS, NULL},
	 { (char *)"History_weight_UNLOPS_LOOP", _wrap_History_weight_UNLOPS_LOOP, METH_VARARGS, NULL},
	 { (char *)"History_weight_UNLOPS_SUBTNLO", _wrap_History_weight_UNLOPS_SUBTNLO, METH_VARARGS, NULL},
	 { (char *)"History_weight_UNLOPS_CORRECTION", _wrap_History_weight_UNLOPS_CORRECTION, METH_VARARGS, NULL},
	 { (char *)"History_foundAllowedHistories", _wrap_History_foundAllowedHistories, METH_VARARGS, NULL},
	 { (char *)"History_foundOrderedHistories", _wrap_History_foundOrderedHistories, METH_VARARGS, NULL},
	 { (char *)"History_foundCompleteHistories", _wrap_History_foundCompleteHistories, METH_VARARGS, NULL},
	 { (char *)"History_getStartingConditions", _wrap_History_getStartingConditions, METH_VARARGS, NULL},
	 { (char *)"History_getClusteredEvent", _wrap_History_getClusteredEvent, METH_VARARGS, NULL},
	 { (char *)"History_getFirstClusteredEventAboveTMS", _wrap_History_getFirstClusteredEventAboveTMS, METH_VARARGS, NULL},
	 { (char *)"History_nClusterings", _wrap_History_nClusterings, METH_VARARGS, NULL},
	 { (char *)"History_lowestMultProc", _wrap_History_lowestMultProc, METH_VARARGS, NULL},
	 { (char *)"History_getPDFratio", _wrap_History_getPDFratio, METH_VARARGS, NULL},
	 { (char *)"History_getWeakProb", _wrap_History_getWeakProb, METH_VARARGS, NULL},
	 { (char *)"History_getSingleWeakProb", _wrap_History_getSingleWeakProb, METH_VARARGS, NULL},
	 { (char *)"History_findStateTransfer", _wrap_History_findStateTransfer, METH_VARARGS, NULL},
	 { (char *)"History_printHistory", _wrap_History_printHistory, METH_VARARGS, NULL},
	 { (char *)"History_printStates", _wrap_History_printStates, METH_VARARGS, NULL},
	 { (char *)"History_swigregister", History_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_Merging", _wrap_delete_Merging, METH_VARARGS, NULL},
	 { (char *)"Merging_initPtr", _wrap_Merging_initPtr, METH_VARARGS, NULL},
	 { (char *)"Merging_init", _wrap_Merging_init, METH_VARARGS, NULL},
	 { (char *)"Merging_statistics", _wrap_Merging_statistics, METH_VARARGS, NULL},
	 { (char *)"Merging_mergeProcess", _wrap_Merging_mergeProcess, METH_VARARGS, NULL},
	 { (char *)"Merging_swigregister", Merging_swigregister, METH_VARARGS, NULL},
	 { (char *)"PYTHIA_VERSION_swigconstant", PYTHIA_VERSION_swigconstant, METH_VARARGS, NULL},
	 { (char *)"PYTHIA_VERSION_INTEGER_swigconstant", PYTHIA_VERSION_INTEGER_swigconstant, METH_VARARGS, NULL},
	 { (char *)"new_Pythia", _wrap_new_Pythia, METH_VARARGS, NULL},
	 { (char *)"delete_Pythia", _wrap_delete_Pythia, METH_VARARGS, NULL},
	 { (char *)"Pythia_initPtrs", _wrap_Pythia_initPtrs, METH_VARARGS, NULL},
	 { (char *)"Pythia_checkVersion", _wrap_Pythia_checkVersion, METH_VARARGS, NULL},
	 { (char *)"Pythia_readString", _wrap_Pythia_readString, METH_VARARGS, NULL},
	 { (char *)"Pythia_readFile", _wrap_Pythia_readFile, METH_VARARGS, NULL},
	 { (char *)"Pythia_setPDFPtr", _wrap_Pythia_setPDFPtr, METH_VARARGS, NULL},
	 { (char *)"Pythia_setPhotonFluxPtr", _wrap_Pythia_setPhotonFluxPtr, METH_VARARGS, NULL},
	 { (char *)"Pythia_setLHAupPtr", _wrap_Pythia_setLHAupPtr, METH_VARARGS, NULL},
	 { (char *)"Pythia_setDecayPtr", _wrap_Pythia_setDecayPtr, METH_VARARGS, NULL},
	 { (char *)"Pythia_setRndmEnginePtr", _wrap_Pythia_setRndmEnginePtr, METH_VARARGS, NULL},
	 { (char *)"Pythia_setUserHooksPtr", _wrap_Pythia_setUserHooksPtr, METH_VARARGS, NULL},
	 { (char *)"Pythia_addUserHooksPtr", _wrap_Pythia_addUserHooksPtr, METH_VARARGS, NULL},
	 { (char *)"Pythia_setMergingPtr", _wrap_Pythia_setMergingPtr, METH_VARARGS, NULL},
	 { (char *)"Pythia_setMergingHooksPtr", _wrap_Pythia_setMergingHooksPtr, METH_VARARGS, NULL},
	 { (char *)"Pythia_setBeamShapePtr", _wrap_Pythia_setBeamShapePtr, METH_VARARGS, NULL},
	 { (char *)"Pythia_setSigmaPtr", _wrap_Pythia_setSigmaPtr, METH_VARARGS, NULL},
	 { (char *)"Pythia_setResonancePtr", _wrap_Pythia_setResonancePtr, METH_VARARGS, NULL},
	 { (char *)"Pythia_setShowerPtr", _wrap_Pythia_setShowerPtr, METH_VARARGS, NULL},
	 { (char *)"Pythia_setHeavyIonsPtr", _wrap_Pythia_setHeavyIonsPtr, METH_VARARGS, NULL},
	 { (char *)"Pythia_setHIHooks", _wrap_Pythia_setHIHooks, METH_VARARGS, NULL},
	 { (char *)"Pythia_getHeavyIonsPtr", _wrap_Pythia_getHeavyIonsPtr, METH_VARARGS, NULL},
	 { (char *)"Pythia_setPartonVertexPtr", _wrap_Pythia_setPartonVertexPtr, METH_VARARGS, NULL},
	 { (char *)"Pythia_init", _wrap_Pythia_init, METH_VARARGS, NULL},
	 { (char *)"Pythia_next", _wrap_Pythia_next, METH_VARARGS, NULL},
	 { (char *)"Pythia_forceTimeShower", _wrap_Pythia_forceTimeShower, METH_VARARGS, NULL},
	 { (char *)"Pythia_forceHadronLevel", _wrap_Pythia_forceHadronLevel, METH_VARARGS, NULL},
	 { (char *)"Pythia_moreDecays", _wrap_Pythia_moreDecays, METH_VARARGS, NULL},
	 { (char *)"Pythia_forceRHadronDecays", _wrap_Pythia_forceRHadronDecays, METH_VARARGS, NULL},
	 { (char *)"Pythia_LHAeventList", _wrap_Pythia_LHAeventList, METH_VARARGS, NULL},
	 { (char *)"Pythia_LHAeventSkip", _wrap_Pythia_LHAeventSkip, METH_VARARGS, NULL},
	 { (char *)"Pythia_stat", _wrap_Pythia_stat, METH_VARARGS, NULL},
	 { (char *)"Pythia_flag", _wrap_Pythia_flag, METH_VARARGS, NULL},
	 { (char *)"Pythia_mode", _wrap_Pythia_mode, METH_VARARGS, NULL},
	 { (char *)"Pythia_parm", _wrap_Pythia_parm, METH_VARARGS, NULL},
	 { (char *)"Pythia_word", _wrap_Pythia_word, METH_VARARGS, NULL},
	 { (char *)"Pythia_getPDFPtr", _wrap_Pythia_getPDFPtr, METH_VARARGS, NULL},
	 { (char *)"Pythia_process_set", _wrap_Pythia_process_set, METH_VARARGS, NULL},
	 { (char *)"Pythia_process_get", _wrap_Pythia_process_get, METH_VARARGS, NULL},
	 { (char *)"Pythia_event_set", _wrap_Pythia_event_set, METH_VARARGS, NULL},
	 { (char *)"Pythia_event_get", _wrap_Pythia_event_get, METH_VARARGS, NULL},
	 { (char *)"Pythia_info_set", _wrap_Pythia_info_set, METH_VARARGS, NULL},
	 { (char *)"Pythia_info_get", _wrap_Pythia_info_get, METH_VARARGS, NULL},
	 { (char *)"Pythia_settings_set", _wrap_Pythia_settings_set, METH_VARARGS, NULL},
	 { (char *)"Pythia_settings_get", _wrap_Pythia_settings_get, METH_VARARGS, NULL},
	 { (char *)"Pythia_particleData_set", _wrap_Pythia_particleData_set, METH_VARARGS, NULL},
	 { (char *)"Pythia_particleData_get", _wrap_Pythia_particleData_get, METH_VARARGS, NULL},
	 { (char *)"Pythia_rndm_set", _wrap_Pythia_rndm_set, METH_VARARGS, NULL},
	 { (char *)"Pythia_rndm_get", _wrap_Pythia_rndm_get, METH_VARARGS, NULL},
	 { (char *)"Pythia_couplings_set", _wrap_Pythia_couplings_set, METH_VARARGS, NULL},
	 { (char *)"Pythia_couplings_get", _wrap_Pythia_couplings_get, METH_VARARGS, NULL},
	 { (char *)"Pythia_couplingsPtr_set", _wrap_Pythia_couplingsPtr_set, METH_VARARGS, NULL},
	 { (char *)"Pythia_couplingsPtr_get", _wrap_Pythia_couplingsPtr_get, METH_VARARGS, NULL},
	 { (char *)"Pythia_slhaInterface_set", _wrap_Pythia_slhaInterface_set, METH_VARARGS, NULL},
	 { (char *)"Pythia_slhaInterface_get", _wrap_Pythia_slhaInterface_get, METH_VARARGS, NULL},
	 { (char *)"Pythia_partonSystems_set", _wrap_Pythia_partonSystems_set, METH_VARARGS, NULL},
	 { (char *)"Pythia_partonSystems_get", _wrap_Pythia_partonSystems_get, METH_VARARGS, NULL},
	 { (char *)"Pythia_mergingPtr_set", _wrap_Pythia_mergingPtr_set, METH_VARARGS, NULL},
	 { (char *)"Pythia_mergingPtr_get", _wrap_Pythia_mergingPtr_get, METH_VARARGS, NULL},
	 { (char *)"Pythia_mergingHooksPtr_set", _wrap_Pythia_mergingHooksPtr_set, METH_VARARGS, NULL},
	 { (char *)"Pythia_mergingHooksPtr_get", _wrap_Pythia_mergingHooksPtr_get, METH_VARARGS, NULL},
	 { (char *)"Pythia_heavyIonsPtr_set", _wrap_Pythia_heavyIonsPtr_set, METH_VARARGS, NULL},
	 { (char *)"Pythia_heavyIonsPtr_get", _wrap_Pythia_heavyIonsPtr_get, METH_VARARGS, NULL},
	 { (char *)"Pythia_hiHooksPtr_set", _wrap_Pythia_hiHooksPtr_set, METH_VARARGS, NULL},
	 { (char *)"Pythia_hiHooksPtr_get", _wrap_Pythia_hiHooksPtr_get, METH_VARARGS, NULL},
	 { (char *)"Pythia_beamA_set", _wrap_Pythia_beamA_set, METH_VARARGS, NULL},
	 { (char *)"Pythia_beamA_get", _wrap_Pythia_beamA_get, METH_VARARGS, NULL},
	 { (char *)"Pythia_beamB_set", _wrap_Pythia_beamB_set, METH_VARARGS, NULL},
	 { (char *)"Pythia_beamB_get", _wrap_Pythia_beamB_get, METH_VARARGS, NULL},
	 { (char *)"Pythia_swigregister", Pythia_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Nucleon", _wrap_new_Nucleon, METH_VARARGS, NULL},
	 { (char *)"Nucleon_id", _wrap_Nucleon_id, METH_VARARGS, NULL},
	 { (char *)"Nucleon_index", _wrap_Nucleon_index, METH_VARARGS, NULL},
	 { (char *)"Nucleon_nPos", _wrap_Nucleon_nPos, METH_VARARGS, NULL},
	 { (char *)"Nucleon_bPos", _wrap_Nucleon_bPos, METH_VARARGS, NULL},
	 { (char *)"Nucleon_bShift", _wrap_Nucleon_bShift, METH_VARARGS, NULL},
	 { (char *)"Nucleon_done", _wrap_Nucleon_done, METH_VARARGS, NULL},
	 { (char *)"Nucleon_event", _wrap_Nucleon_event, METH_VARARGS, NULL},
	 { (char *)"Nucleon_altState", _wrap_Nucleon_altState, METH_VARARGS, NULL},
	 { (char *)"Nucleon_status", _wrap_Nucleon_status, METH_VARARGS, NULL},
	 { (char *)"Nucleon_state", _wrap_Nucleon_state, METH_VARARGS, NULL},
	 { (char *)"Nucleon_addAltState", _wrap_Nucleon_addAltState, METH_VARARGS, NULL},
	 { (char *)"Nucleon_select", _wrap_Nucleon_select, METH_VARARGS, NULL},
	 { (char *)"Nucleon_debug", _wrap_Nucleon_debug, METH_VARARGS, NULL},
	 { (char *)"delete_Nucleon", _wrap_delete_Nucleon, METH_VARARGS, NULL},
	 { (char *)"Nucleon_swigregister", Nucleon_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_SubCollision", _wrap_new_SubCollision, METH_VARARGS, NULL},
	 { (char *)"SubCollision___lt__", _wrap_SubCollision___lt__, METH_VARARGS, NULL},
	 { (char *)"SubCollision_nucleons", _wrap_SubCollision_nucleons, METH_VARARGS, NULL},
	 { (char *)"SubCollision_proj_set", _wrap_SubCollision_proj_set, METH_VARARGS, NULL},
	 { (char *)"SubCollision_proj_get", _wrap_SubCollision_proj_get, METH_VARARGS, NULL},
	 { (char *)"SubCollision_targ_set", _wrap_SubCollision_targ_set, METH_VARARGS, NULL},
	 { (char *)"SubCollision_targ_get", _wrap_SubCollision_targ_get, METH_VARARGS, NULL},
	 { (char *)"SubCollision_b_set", _wrap_SubCollision_b_set, METH_VARARGS, NULL},
	 { (char *)"SubCollision_b_get", _wrap_SubCollision_b_get, METH_VARARGS, NULL},
	 { (char *)"SubCollision_bp_set", _wrap_SubCollision_bp_set, METH_VARARGS, NULL},
	 { (char *)"SubCollision_bp_get", _wrap_SubCollision_bp_get, METH_VARARGS, NULL},
	 { (char *)"SubCollision_type_set", _wrap_SubCollision_type_set, METH_VARARGS, NULL},
	 { (char *)"SubCollision_type_get", _wrap_SubCollision_type_get, METH_VARARGS, NULL},
	 { (char *)"delete_SubCollision", _wrap_delete_SubCollision, METH_VARARGS, NULL},
	 { (char *)"SubCollision_swigregister", SubCollision_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_NucleusModel", _wrap_delete_NucleusModel, METH_VARARGS, NULL},
	 { (char *)"NucleusModel_initPtr", _wrap_NucleusModel_initPtr, METH_VARARGS, NULL},
	 { (char *)"NucleusModel_init", _wrap_NucleusModel_init, METH_VARARGS, NULL},
	 { (char *)"NucleusModel_produceIon", _wrap_NucleusModel_produceIon, METH_VARARGS, NULL},
	 { (char *)"NucleusModel_generate", _wrap_NucleusModel_generate, METH_VARARGS, NULL},
	 { (char *)"NucleusModel_id", _wrap_NucleusModel_id, METH_VARARGS, NULL},
	 { (char *)"NucleusModel_I", _wrap_NucleusModel_I, METH_VARARGS, NULL},
	 { (char *)"NucleusModel_A", _wrap_NucleusModel_A, METH_VARARGS, NULL},
	 { (char *)"NucleusModel_Z", _wrap_NucleusModel_Z, METH_VARARGS, NULL},
	 { (char *)"NucleusModel_L", _wrap_NucleusModel_L, METH_VARARGS, NULL},
	 { (char *)"NucleusModel_R", _wrap_NucleusModel_R, METH_VARARGS, NULL},
	 { (char *)"NucleusModel_swigregister", NucleusModel_swigregister, METH_VARARGS, NULL},
	 { (char *)"WoodsSaxonModel_a", _wrap_WoodsSaxonModel_a, METH_VARARGS, NULL},
	 { (char *)"WoodsSaxonModel_swigregister", WoodsSaxonModel_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_GLISSANDOModel", _wrap_new_GLISSANDOModel, METH_VARARGS, NULL},
	 { (char *)"delete_GLISSANDOModel", _wrap_delete_GLISSANDOModel, METH_VARARGS, NULL},
	 { (char *)"GLISSANDOModel_init", _wrap_GLISSANDOModel_init, METH_VARARGS, NULL},
	 { (char *)"GLISSANDOModel_generate", _wrap_GLISSANDOModel_generate, METH_VARARGS, NULL},
	 { (char *)"GLISSANDOModel_Rh", _wrap_GLISSANDOModel_Rh, METH_VARARGS, NULL},
	 { (char *)"GLISSANDOModel_RhGauss", _wrap_GLISSANDOModel_RhGauss, METH_VARARGS, NULL},
	 { (char *)"GLISSANDOModel_swigregister", GLISSANDOModel_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_ImpactParameterGenerator", _wrap_new_ImpactParameterGenerator, METH_VARARGS, NULL},
	 { (char *)"delete_ImpactParameterGenerator", _wrap_delete_ImpactParameterGenerator, METH_VARARGS, NULL},
	 { (char *)"ImpactParameterGenerator_init", _wrap_ImpactParameterGenerator_init, METH_VARARGS, NULL},
	 { (char *)"ImpactParameterGenerator_initPtr", _wrap_ImpactParameterGenerator_initPtr, METH_VARARGS, NULL},
	 { (char *)"ImpactParameterGenerator_generate", _wrap_ImpactParameterGenerator_generate, METH_VARARGS, NULL},
	 { (char *)"ImpactParameterGenerator_width", _wrap_ImpactParameterGenerator_width, METH_VARARGS, NULL},
	 { (char *)"ImpactParameterGenerator_swigregister", ImpactParameterGenerator_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_SubCollisionModel", _wrap_delete_SubCollisionModel, METH_VARARGS, NULL},
	 { (char *)"SubCollisionModel_init", _wrap_SubCollisionModel_init, METH_VARARGS, NULL},
	 { (char *)"SubCollisionModel_initPtr", _wrap_SubCollisionModel_initPtr, METH_VARARGS, NULL},
	 { (char *)"SubCollisionModel_getCollisions", _wrap_SubCollisionModel_getCollisions, METH_VARARGS, NULL},
	 { (char *)"SubCollisionModel_sigTot", _wrap_SubCollisionModel_sigTot, METH_VARARGS, NULL},
	 { (char *)"SubCollisionModel_sigEl", _wrap_SubCollisionModel_sigEl, METH_VARARGS, NULL},
	 { (char *)"SubCollisionModel_sigCDE", _wrap_SubCollisionModel_sigCDE, METH_VARARGS, NULL},
	 { (char *)"SubCollisionModel_sigSDE", _wrap_SubCollisionModel_sigSDE, METH_VARARGS, NULL},
	 { (char *)"SubCollisionModel_sigSDEP", _wrap_SubCollisionModel_sigSDEP, METH_VARARGS, NULL},
	 { (char *)"SubCollisionModel_sigSDET", _wrap_SubCollisionModel_sigSDET, METH_VARARGS, NULL},
	 { (char *)"SubCollisionModel_sigDDE", _wrap_SubCollisionModel_sigDDE, METH_VARARGS, NULL},
	 { (char *)"SubCollisionModel_sigND", _wrap_SubCollisionModel_sigND, METH_VARARGS, NULL},
	 { (char *)"SubCollisionModel_bSlope", _wrap_SubCollisionModel_bSlope, METH_VARARGS, NULL},
	 { (char *)"SubCollisionModel_getSig", _wrap_SubCollisionModel_getSig, METH_VARARGS, NULL},
	 { (char *)"SubCollisionModel_avNDB", _wrap_SubCollisionModel_avNDB, METH_VARARGS, NULL},
	 { (char *)"SubCollisionModel_Chi2", _wrap_SubCollisionModel_Chi2, METH_VARARGS, NULL},
	 { (char *)"SubCollisionModel_evolve", _wrap_SubCollisionModel_evolve, METH_VARARGS, NULL},
	 { (char *)"SubCollisionModel_setParm", _wrap_SubCollisionModel_setParm, METH_VARARGS, NULL},
	 { (char *)"SubCollisionModel_getParm", _wrap_SubCollisionModel_getParm, METH_VARARGS, NULL},
	 { (char *)"SubCollisionModel_minParm", _wrap_SubCollisionModel_minParm, METH_VARARGS, NULL},
	 { (char *)"SubCollisionModel_maxParm", _wrap_SubCollisionModel_maxParm, METH_VARARGS, NULL},
	 { (char *)"SubCollisionModel_swigregister", SubCollisionModel_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_NaiveSubCollisionModel", _wrap_new_NaiveSubCollisionModel, METH_VARARGS, NULL},
	 { (char *)"delete_NaiveSubCollisionModel", _wrap_delete_NaiveSubCollisionModel, METH_VARARGS, NULL},
	 { (char *)"NaiveSubCollisionModel_getCollisions", _wrap_NaiveSubCollisionModel_getCollisions, METH_VARARGS, NULL},
	 { (char *)"NaiveSubCollisionModel_swigregister", NaiveSubCollisionModel_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_DoubleStrikman", _wrap_new_DoubleStrikman, METH_VARARGS, NULL},
	 { (char *)"delete_DoubleStrikman", _wrap_delete_DoubleStrikman, METH_VARARGS, NULL},
	 { (char *)"DoubleStrikman_getCollisions", _wrap_DoubleStrikman_getCollisions, METH_VARARGS, NULL},
	 { (char *)"DoubleStrikman_gamma", _wrap_DoubleStrikman_gamma, METH_VARARGS, NULL},
	 { (char *)"DoubleStrikman_opacity", _wrap_DoubleStrikman_opacity, METH_VARARGS, NULL},
	 { (char *)"DoubleStrikman_Tpt", _wrap_DoubleStrikman_Tpt, METH_VARARGS, NULL},
	 { (char *)"DoubleStrikman_getSig", _wrap_DoubleStrikman_getSig, METH_VARARGS, NULL},
	 { (char *)"DoubleStrikman_setParm", _wrap_DoubleStrikman_setParm, METH_VARARGS, NULL},
	 { (char *)"DoubleStrikman_getParm", _wrap_DoubleStrikman_getParm, METH_VARARGS, NULL},
	 { (char *)"DoubleStrikman_minParm", _wrap_DoubleStrikman_minParm, METH_VARARGS, NULL},
	 { (char *)"DoubleStrikman_maxParm", _wrap_DoubleStrikman_maxParm, METH_VARARGS, NULL},
	 { (char *)"DoubleStrikman_shuffle", _wrap_DoubleStrikman_shuffle, METH_VARARGS, NULL},
	 { (char *)"DoubleStrikman_shuffel", _wrap_DoubleStrikman_shuffel, METH_VARARGS, NULL},
	 { (char *)"DoubleStrikman_PNW", _wrap_DoubleStrikman_PNW, METH_VARARGS, NULL},
	 { (char *)"DoubleStrikman_swigregister", DoubleStrikman_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MultiRadial", _wrap_new_MultiRadial, METH_VARARGS, NULL},
	 { (char *)"delete_MultiRadial", _wrap_delete_MultiRadial, METH_VARARGS, NULL},
	 { (char *)"MultiRadial_getCollisions", _wrap_MultiRadial_getCollisions, METH_VARARGS, NULL},
	 { (char *)"MultiRadial_Tpt", _wrap_MultiRadial_Tpt, METH_VARARGS, NULL},
	 { (char *)"MultiRadial_getSig", _wrap_MultiRadial_getSig, METH_VARARGS, NULL},
	 { (char *)"MultiRadial_setParm", _wrap_MultiRadial_setParm, METH_VARARGS, NULL},
	 { (char *)"MultiRadial_getParm", _wrap_MultiRadial_getParm, METH_VARARGS, NULL},
	 { (char *)"MultiRadial_minParm", _wrap_MultiRadial_minParm, METH_VARARGS, NULL},
	 { (char *)"MultiRadial_maxParm", _wrap_MultiRadial_maxParm, METH_VARARGS, NULL},
	 { (char *)"MultiRadial_swigregister", MultiRadial_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_EventInfo", _wrap_new_EventInfo, METH_VARARGS, NULL},
	 { (char *)"EventInfo_event_set", _wrap_EventInfo_event_set, METH_VARARGS, NULL},
	 { (char *)"EventInfo_event_get", _wrap_EventInfo_event_get, METH_VARARGS, NULL},
	 { (char *)"EventInfo_info_set", _wrap_EventInfo_info_set, METH_VARARGS, NULL},
	 { (char *)"EventInfo_info_get", _wrap_EventInfo_info_get, METH_VARARGS, NULL},
	 { (char *)"EventInfo_ordering_set", _wrap_EventInfo_ordering_set, METH_VARARGS, NULL},
	 { (char *)"EventInfo_ordering_get", _wrap_EventInfo_ordering_get, METH_VARARGS, NULL},
	 { (char *)"EventInfo___lt__", _wrap_EventInfo___lt__, METH_VARARGS, NULL},
	 { (char *)"EventInfo_coll_set", _wrap_EventInfo_coll_set, METH_VARARGS, NULL},
	 { (char *)"EventInfo_coll_get", _wrap_EventInfo_coll_get, METH_VARARGS, NULL},
	 { (char *)"EventInfo_ok_set", _wrap_EventInfo_ok_set, METH_VARARGS, NULL},
	 { (char *)"EventInfo_ok_get", _wrap_EventInfo_ok_get, METH_VARARGS, NULL},
	 { (char *)"EventInfo_projs_set", _wrap_EventInfo_projs_set, METH_VARARGS, NULL},
	 { (char *)"EventInfo_projs_get", _wrap_EventInfo_projs_get, METH_VARARGS, NULL},
	 { (char *)"EventInfo_targs_set", _wrap_EventInfo_targs_set, METH_VARARGS, NULL},
	 { (char *)"EventInfo_targs_get", _wrap_EventInfo_targs_get, METH_VARARGS, NULL},
	 { (char *)"delete_EventInfo", _wrap_delete_EventInfo, METH_VARARGS, NULL},
	 { (char *)"EventInfo_swigregister", EventInfo_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HIInfo", _wrap_new_HIInfo, METH_VARARGS, NULL},
	 { (char *)"HIInfo_b", _wrap_HIInfo_b, METH_VARARGS, NULL},
	 { (char *)"HIInfo_sigmaTot", _wrap_HIInfo_sigmaTot, METH_VARARGS, NULL},
	 { (char *)"HIInfo_sigmaTotErr", _wrap_HIInfo_sigmaTotErr, METH_VARARGS, NULL},
	 { (char *)"HIInfo_sigmaND", _wrap_HIInfo_sigmaND, METH_VARARGS, NULL},
	 { (char *)"HIInfo_sigmaNDErr", _wrap_HIInfo_sigmaNDErr, METH_VARARGS, NULL},
	 { (char *)"HIInfo_nAttempts", _wrap_HIInfo_nAttempts, METH_VARARGS, NULL},
	 { (char *)"HIInfo_nAccepted", _wrap_HIInfo_nAccepted, METH_VARARGS, NULL},
	 { (char *)"HIInfo_nCollTot", _wrap_HIInfo_nCollTot, METH_VARARGS, NULL},
	 { (char *)"HIInfo_nCollND", _wrap_HIInfo_nCollND, METH_VARARGS, NULL},
	 { (char *)"HIInfo_nCollNDTot", _wrap_HIInfo_nCollNDTot, METH_VARARGS, NULL},
	 { (char *)"HIInfo_nCollSDP", _wrap_HIInfo_nCollSDP, METH_VARARGS, NULL},
	 { (char *)"HIInfo_nCollSDT", _wrap_HIInfo_nCollSDT, METH_VARARGS, NULL},
	 { (char *)"HIInfo_nCollDD", _wrap_HIInfo_nCollDD, METH_VARARGS, NULL},
	 { (char *)"HIInfo_nCollCD", _wrap_HIInfo_nCollCD, METH_VARARGS, NULL},
	 { (char *)"HIInfo_nCollEL", _wrap_HIInfo_nCollEL, METH_VARARGS, NULL},
	 { (char *)"HIInfo_nPartProj", _wrap_HIInfo_nPartProj, METH_VARARGS, NULL},
	 { (char *)"HIInfo_nAbsProj", _wrap_HIInfo_nAbsProj, METH_VARARGS, NULL},
	 { (char *)"HIInfo_nDiffProj", _wrap_HIInfo_nDiffProj, METH_VARARGS, NULL},
	 { (char *)"HIInfo_nElProj", _wrap_HIInfo_nElProj, METH_VARARGS, NULL},
	 { (char *)"HIInfo_nPartTarg", _wrap_HIInfo_nPartTarg, METH_VARARGS, NULL},
	 { (char *)"HIInfo_nAbsTarg", _wrap_HIInfo_nAbsTarg, METH_VARARGS, NULL},
	 { (char *)"HIInfo_nDiffTarg", _wrap_HIInfo_nDiffTarg, METH_VARARGS, NULL},
	 { (char *)"HIInfo_nElTarg", _wrap_HIInfo_nElTarg, METH_VARARGS, NULL},
	 { (char *)"HIInfo_weight", _wrap_HIInfo_weight, METH_VARARGS, NULL},
	 { (char *)"HIInfo_weightSum", _wrap_HIInfo_weightSum, METH_VARARGS, NULL},
	 { (char *)"HIInfo_nFail", _wrap_HIInfo_nFail, METH_VARARGS, NULL},
	 { (char *)"HIInfo_failedExcitation", _wrap_HIInfo_failedExcitation, METH_VARARGS, NULL},
	 { (char *)"HIInfo_subCollisionsPtr", _wrap_HIInfo_subCollisionsPtr, METH_VARARGS, NULL},
	 { (char *)"delete_HIInfo", _wrap_delete_HIInfo, METH_VARARGS, NULL},
	 { (char *)"HIInfo_swigregister", HIInfo_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HIUserHooks", _wrap_new_HIUserHooks, METH_VARARGS, NULL},
	 { (char *)"delete_HIUserHooks", _wrap_delete_HIUserHooks, METH_VARARGS, NULL},
	 { (char *)"HIUserHooks_init", _wrap_HIUserHooks_init, METH_VARARGS, NULL},
	 { (char *)"HIUserHooks_hasImpactParameterGenerator", _wrap_HIUserHooks_hasImpactParameterGenerator, METH_VARARGS, NULL},
	 { (char *)"HIUserHooks_impactParameterGenerator", _wrap_HIUserHooks_impactParameterGenerator, METH_VARARGS, NULL},
	 { (char *)"HIUserHooks_hasProjectileModel", _wrap_HIUserHooks_hasProjectileModel, METH_VARARGS, NULL},
	 { (char *)"HIUserHooks_projectileModel", _wrap_HIUserHooks_projectileModel, METH_VARARGS, NULL},
	 { (char *)"HIUserHooks_hasTargetModel", _wrap_HIUserHooks_hasTargetModel, METH_VARARGS, NULL},
	 { (char *)"HIUserHooks_targetModel", _wrap_HIUserHooks_targetModel, METH_VARARGS, NULL},
	 { (char *)"HIUserHooks_hasSubCollisionModel", _wrap_HIUserHooks_hasSubCollisionModel, METH_VARARGS, NULL},
	 { (char *)"HIUserHooks_subCollisionModel", _wrap_HIUserHooks_subCollisionModel, METH_VARARGS, NULL},
	 { (char *)"HIUserHooks_hasEventOrdering", _wrap_HIUserHooks_hasEventOrdering, METH_VARARGS, NULL},
	 { (char *)"HIUserHooks_eventOrdering", _wrap_HIUserHooks_eventOrdering, METH_VARARGS, NULL},
	 { (char *)"HIUserHooks_canFixIsoSpin", _wrap_HIUserHooks_canFixIsoSpin, METH_VARARGS, NULL},
	 { (char *)"HIUserHooks_fixIsoSpin", _wrap_HIUserHooks_fixIsoSpin, METH_VARARGS, NULL},
	 { (char *)"HIUserHooks_canShiftEvent", _wrap_HIUserHooks_canShiftEvent, METH_VARARGS, NULL},
	 { (char *)"HIUserHooks_shiftEvent", _wrap_HIUserHooks_shiftEvent, METH_VARARGS, NULL},
	 { (char *)"HIUserHooks_canAddNucleonExcitation", _wrap_HIUserHooks_canAddNucleonExcitation, METH_VARARGS, NULL},
	 { (char *)"HIUserHooks_addNucleonExcitation", _wrap_HIUserHooks_addNucleonExcitation, METH_VARARGS, NULL},
	 { (char *)"HIUserHooks_canForceHadronLevel", _wrap_HIUserHooks_canForceHadronLevel, METH_VARARGS, NULL},
	 { (char *)"HIUserHooks_forceHadronLevel", _wrap_HIUserHooks_forceHadronLevel, METH_VARARGS, NULL},
	 { (char *)"HIUserHooks_canFindRecoilers", _wrap_HIUserHooks_canFindRecoilers, METH_VARARGS, NULL},
	 { (char *)"HIUserHooks_findRecoilers", _wrap_HIUserHooks_findRecoilers, METH_VARARGS, NULL},
	 { (char *)"HIUserHooks_swigregister", HIUserHooks_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_amcnlo_unitarised_interface", _wrap_new_amcnlo_unitarised_interface, METH_VARARGS, NULL},
	 { (char *)"delete_amcnlo_unitarised_interface", _wrap_delete_amcnlo_unitarised_interface, METH_VARARGS, NULL},
	 { (char *)"amcnlo_unitarised_interface_getNormFactor", _wrap_amcnlo_unitarised_interface_getNormFactor, METH_VARARGS, NULL},
	 { (char *)"amcnlo_unitarised_interface_canVetoProcessLevel", _wrap_amcnlo_unitarised_interface_canVetoProcessLevel, METH_VARARGS, NULL},
	 { (char *)"amcnlo_unitarised_interface_doVetoProcessLevel", _wrap_amcnlo_unitarised_interface_doVetoProcessLevel, METH_VARARGS, NULL},
	 { (char *)"amcnlo_unitarised_interface_swigregister", amcnlo_unitarised_interface_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MBReconUserHooks", _wrap_new_MBReconUserHooks, METH_VARARGS, NULL},
	 { (char *)"delete_MBReconUserHooks", _wrap_delete_MBReconUserHooks, METH_VARARGS, NULL},
	 { (char *)"MBReconUserHooks_canReconnectResonanceSystems", _wrap_MBReconUserHooks_canReconnectResonanceSystems, METH_VARARGS, NULL},
	 { (char *)"MBReconUserHooks_doReconnectResonanceSystems", _wrap_MBReconUserHooks_doReconnectResonanceSystems, METH_VARARGS, NULL},
	 { (char *)"MBReconUserHooks_swigregister", MBReconUserHooks_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_TopReconUserHooks", _wrap_new_TopReconUserHooks, METH_VARARGS, NULL},
	 { (char *)"delete_TopReconUserHooks", _wrap_delete_TopReconUserHooks, METH_VARARGS, NULL},
	 { (char *)"TopReconUserHooks_canReconnectResonanceSystems", _wrap_TopReconUserHooks_canReconnectResonanceSystems, METH_VARARGS, NULL},
	 { (char *)"TopReconUserHooks_doReconnectResonanceSystems", _wrap_TopReconUserHooks_doReconnectResonanceSystems, METH_VARARGS, NULL},
	 { (char *)"TopReconUserHooks_swigregister", TopReconUserHooks_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AlpgenPar", _wrap_new_AlpgenPar, METH_VARARGS, NULL},
	 { (char *)"AlpgenPar_parse", _wrap_AlpgenPar_parse, METH_VARARGS, NULL},
	 { (char *)"AlpgenPar_extractRunParam", _wrap_AlpgenPar_extractRunParam, METH_VARARGS, NULL},
	 { (char *)"AlpgenPar_haveParam", _wrap_AlpgenPar_haveParam, METH_VARARGS, NULL},
	 { (char *)"AlpgenPar_getParam", _wrap_AlpgenPar_getParam, METH_VARARGS, NULL},
	 { (char *)"AlpgenPar_getParamAsInt", _wrap_AlpgenPar_getParamAsInt, METH_VARARGS, NULL},
	 { (char *)"AlpgenPar_printParams", _wrap_AlpgenPar_printParams, METH_VARARGS, NULL},
	 { (char *)"delete_AlpgenPar", _wrap_delete_AlpgenPar, METH_VARARGS, NULL},
	 { (char *)"AlpgenPar_swigregister", AlpgenPar_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_LHAupAlpgen", _wrap_delete_LHAupAlpgen, METH_VARARGS, NULL},
	 { (char *)"LHAupAlpgen_fileFound", _wrap_LHAupAlpgen_fileFound, METH_VARARGS, NULL},
	 { (char *)"LHAupAlpgen_setInit", _wrap_LHAupAlpgen_setInit, METH_VARARGS, NULL},
	 { (char *)"LHAupAlpgen_setEvent", _wrap_LHAupAlpgen_setEvent, METH_VARARGS, NULL},
	 { (char *)"LHAupAlpgen_printParticles", _wrap_LHAupAlpgen_printParticles, METH_VARARGS, NULL},
	 { (char *)"LHAupAlpgen_swigregister", LHAupAlpgen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_AlpgenHooks", _wrap_new_AlpgenHooks, METH_VARARGS, NULL},
	 { (char *)"delete_AlpgenHooks", _wrap_delete_AlpgenHooks, METH_VARARGS, NULL},
	 { (char *)"AlpgenHooks_initAfterBeams", _wrap_AlpgenHooks_initAfterBeams, METH_VARARGS, NULL},
	 { (char *)"AlpgenHooks_swigregister", AlpgenHooks_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_MadgraphPar", _wrap_new_MadgraphPar, METH_VARARGS, NULL},
	 { (char *)"MadgraphPar_parse", _wrap_MadgraphPar_parse, METH_VARARGS, NULL},
	 { (char *)"MadgraphPar_extractRunParam", _wrap_MadgraphPar_extractRunParam, METH_VARARGS, NULL},
	 { (char *)"MadgraphPar_haveParam", _wrap_MadgraphPar_haveParam, METH_VARARGS, NULL},
	 { (char *)"MadgraphPar_getParam", _wrap_MadgraphPar_getParam, METH_VARARGS, NULL},
	 { (char *)"MadgraphPar_getParamAsInt", _wrap_MadgraphPar_getParamAsInt, METH_VARARGS, NULL},
	 { (char *)"MadgraphPar_printParams", _wrap_MadgraphPar_printParams, METH_VARARGS, NULL},
	 { (char *)"delete_MadgraphPar", _wrap_delete_MadgraphPar, METH_VARARGS, NULL},
	 { (char *)"MadgraphPar_swigregister", MadgraphPar_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_HJSlowJet", _wrap_new_HJSlowJet, METH_VARARGS, NULL},
	 { (char *)"delete_HJSlowJet", _wrap_delete_HJSlowJet, METH_VARARGS, NULL},
	 { (char *)"HJSlowJet_swigregister", HJSlowJet_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_JetMatching", _wrap_delete_JetMatching, METH_VARARGS, NULL},
	 { (char *)"JetMatching_initAfterBeams", _wrap_JetMatching_initAfterBeams, METH_VARARGS, NULL},
	 { (char *)"JetMatching_canVetoProcessLevel", _wrap_JetMatching_canVetoProcessLevel, METH_VARARGS, NULL},
	 { (char *)"JetMatching_doVetoProcessLevel", _wrap_JetMatching_doVetoProcessLevel, METH_VARARGS, NULL},
	 { (char *)"JetMatching_canVetoPartonLevelEarly", _wrap_JetMatching_canVetoPartonLevelEarly, METH_VARARGS, NULL},
	 { (char *)"JetMatching_doVetoPartonLevelEarly", _wrap_JetMatching_doVetoPartonLevelEarly, METH_VARARGS, NULL},
	 { (char *)"JetMatching_numberVetoStep", _wrap_JetMatching_numberVetoStep, METH_VARARGS, NULL},
	 { (char *)"JetMatching_canVetoStep", _wrap_JetMatching_canVetoStep, METH_VARARGS, NULL},
	 { (char *)"JetMatching_doVetoStep", _wrap_JetMatching_doVetoStep, METH_VARARGS, NULL},
	 { (char *)"JetMatching_swigregister", JetMatching_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_JetMatchingAlpgen", _wrap_new_JetMatchingAlpgen, METH_VARARGS, NULL},
	 { (char *)"delete_JetMatchingAlpgen", _wrap_delete_JetMatchingAlpgen, METH_VARARGS, NULL},
	 { (char *)"JetMatchingAlpgen_initAfterBeams", _wrap_JetMatchingAlpgen_initAfterBeams, METH_VARARGS, NULL},
	 { (char *)"JetMatchingAlpgen_swigregister", JetMatchingAlpgen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_JetMatchingMadgraph", _wrap_new_JetMatchingMadgraph, METH_VARARGS, NULL},
	 { (char *)"delete_JetMatchingMadgraph", _wrap_delete_JetMatchingMadgraph, METH_VARARGS, NULL},
	 { (char *)"JetMatchingMadgraph_initAfterBeams", _wrap_JetMatchingMadgraph_initAfterBeams, METH_VARARGS, NULL},
	 { (char *)"JetMatchingMadgraph_canVetoProcessLevel", _wrap_JetMatchingMadgraph_canVetoProcessLevel, METH_VARARGS, NULL},
	 { (char *)"JetMatchingMadgraph_doVetoProcessLevel", _wrap_JetMatchingMadgraph_doVetoProcessLevel, METH_VARARGS, NULL},
	 { (char *)"JetMatchingMadgraph_numberVetoStep", _wrap_JetMatchingMadgraph_numberVetoStep, METH_VARARGS, NULL},
	 { (char *)"JetMatchingMadgraph_canVetoStep", _wrap_JetMatchingMadgraph_canVetoStep, METH_VARARGS, NULL},
	 { (char *)"JetMatchingMadgraph_doVetoStep", _wrap_JetMatchingMadgraph_doVetoStep, METH_VARARGS, NULL},
	 { (char *)"JetMatchingMadgraph_slowJetDJR_set", _wrap_JetMatchingMadgraph_slowJetDJR_set, METH_VARARGS, NULL},
	 { (char *)"JetMatchingMadgraph_slowJetDJR_get", _wrap_JetMatchingMadgraph_slowJetDJR_get, METH_VARARGS, NULL},
	 { (char *)"JetMatchingMadgraph_getDJR", _wrap_JetMatchingMadgraph_getDJR, METH_VARARGS, NULL},
	 { (char *)"JetMatchingMadgraph_nMEpartons", _wrap_JetMatchingMadgraph_nMEpartons, METH_VARARGS, NULL},
	 { (char *)"JetMatchingMadgraph_getWorkEventJet", _wrap_JetMatchingMadgraph_getWorkEventJet, METH_VARARGS, NULL},
	 { (char *)"JetMatchingMadgraph_getProcessSubset", _wrap_JetMatchingMadgraph_getProcessSubset, METH_VARARGS, NULL},
	 { (char *)"JetMatchingMadgraph_getExclusive", _wrap_JetMatchingMadgraph_getExclusive, METH_VARARGS, NULL},
	 { (char *)"JetMatchingMadgraph_getPTfirst", _wrap_JetMatchingMadgraph_getPTfirst, METH_VARARGS, NULL},
	 { (char *)"JetMatchingMadgraph_swigregister", JetMatchingMadgraph_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LHAupHelaconia", _wrap_new_LHAupHelaconia, METH_VARARGS, NULL},
	 { (char *)"delete_LHAupHelaconia", _wrap_delete_LHAupHelaconia, METH_VARARGS, NULL},
	 { (char *)"LHAupHelaconia_readString", _wrap_LHAupHelaconia_readString, METH_VARARGS, NULL},
	 { (char *)"LHAupHelaconia_setEvents", _wrap_LHAupHelaconia_setEvents, METH_VARARGS, NULL},
	 { (char *)"LHAupHelaconia_setSeed", _wrap_LHAupHelaconia_setSeed, METH_VARARGS, NULL},
	 { (char *)"LHAupHelaconia_setInit", _wrap_LHAupHelaconia_setInit, METH_VARARGS, NULL},
	 { (char *)"LHAupHelaconia_setEvent", _wrap_LHAupHelaconia_setEvent, METH_VARARGS, NULL},
	 { (char *)"LHAupHelaconia_swigregister", LHAupHelaconia_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_LHAupMadgraph", _wrap_new_LHAupMadgraph, METH_VARARGS, NULL},
	 { (char *)"delete_LHAupMadgraph", _wrap_delete_LHAupMadgraph, METH_VARARGS, NULL},
	 { (char *)"LHAupMadgraph_readString", _wrap_LHAupMadgraph_readString, METH_VARARGS, NULL},
	 { (char *)"LHAupMadgraph_addCard", _wrap_LHAupMadgraph_addCard, METH_VARARGS, NULL},
	 { (char *)"LHAupMadgraph_setEvents", _wrap_LHAupMadgraph_setEvents, METH_VARARGS, NULL},
	 { (char *)"LHAupMadgraph_setSeed", _wrap_LHAupMadgraph_setSeed, METH_VARARGS, NULL},
	 { (char *)"LHAupMadgraph_setJets", _wrap_LHAupMadgraph_setJets, METH_VARARGS, NULL},
	 { (char *)"LHAupMadgraph_setInit", _wrap_LHAupMadgraph_setInit, METH_VARARGS, NULL},
	 { (char *)"LHAupMadgraph_setEvent", _wrap_LHAupMadgraph_setEvent, METH_VARARGS, NULL},
	 { (char *)"LHAupMadgraph_swigregister", LHAupMadgraph_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PowhegHooks", _wrap_new_PowhegHooks, METH_VARARGS, NULL},
	 { (char *)"delete_PowhegHooks", _wrap_delete_PowhegHooks, METH_VARARGS, NULL},
	 { (char *)"PowhegHooks_initAfterBeams", _wrap_PowhegHooks_initAfterBeams, METH_VARARGS, NULL},
	 { (char *)"PowhegHooks_pTpythia", _wrap_PowhegHooks_pTpythia, METH_VARARGS, NULL},
	 { (char *)"PowhegHooks_pTpowheg", _wrap_PowhegHooks_pTpowheg, METH_VARARGS, NULL},
	 { (char *)"PowhegHooks_pTcalc", _wrap_PowhegHooks_pTcalc, METH_VARARGS, NULL},
	 { (char *)"PowhegHooks_canVetoMPIStep", _wrap_PowhegHooks_canVetoMPIStep, METH_VARARGS, NULL},
	 { (char *)"PowhegHooks_numberVetoMPIStep", _wrap_PowhegHooks_numberVetoMPIStep, METH_VARARGS, NULL},
	 { (char *)"PowhegHooks_doVetoMPIStep", _wrap_PowhegHooks_doVetoMPIStep, METH_VARARGS, NULL},
	 { (char *)"PowhegHooks_canVetoISREmission", _wrap_PowhegHooks_canVetoISREmission, METH_VARARGS, NULL},
	 { (char *)"PowhegHooks_doVetoISREmission", _wrap_PowhegHooks_doVetoISREmission, METH_VARARGS, NULL},
	 { (char *)"PowhegHooks_canVetoFSREmission", _wrap_PowhegHooks_canVetoFSREmission, METH_VARARGS, NULL},
	 { (char *)"PowhegHooks_doVetoFSREmission", _wrap_PowhegHooks_doVetoFSREmission, METH_VARARGS, NULL},
	 { (char *)"PowhegHooks_canVetoMPIEmission", _wrap_PowhegHooks_canVetoMPIEmission, METH_VARARGS, NULL},
	 { (char *)"PowhegHooks_doVetoMPIEmission", _wrap_PowhegHooks_doVetoMPIEmission, METH_VARARGS, NULL},
	 { (char *)"PowhegHooks_getNISRveto", _wrap_PowhegHooks_getNISRveto, METH_VARARGS, NULL},
	 { (char *)"PowhegHooks_getNFSRveto", _wrap_PowhegHooks_getNFSRveto, METH_VARARGS, NULL},
	 { (char *)"PowhegHooks_swigregister", PowhegHooks_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_PowhegProcs", _wrap_new_PowhegProcs, METH_VARARGS, NULL},
	 { (char *)"delete_PowhegProcs", _wrap_delete_PowhegProcs, METH_VARARGS, NULL},
	 { (char *)"PowhegProcs_readString", _wrap_PowhegProcs_readString, METH_VARARGS, NULL},
	 { (char *)"PowhegProcs_readFile", _wrap_PowhegProcs_readFile, METH_VARARGS, NULL},
	 { (char *)"PowhegProcs_init", _wrap_PowhegProcs_init, METH_VARARGS, NULL},
	 { (char *)"PowhegProcs_lhaup_set", _wrap_PowhegProcs_lhaup_set, METH_VARARGS, NULL},
	 { (char *)"PowhegProcs_lhaup_get", _wrap_PowhegProcs_lhaup_get, METH_VARARGS, NULL},
	 { (char *)"PowhegProcs_swigregister", PowhegProcs_swigregister, METH_VARARGS, NULL},
	 { (char *)"delete_HeavyIons", _wrap_delete_HeavyIons, METH_VARARGS, NULL},
	 { (char *)"HeavyIons_init", _wrap_HeavyIons_init, METH_VARARGS, NULL},
	 { (char *)"HeavyIons_next", _wrap_HeavyIons_next, METH_VARARGS, NULL},
	 { (char *)"HeavyIons_addSpecialSettings", _wrap_HeavyIons_addSpecialSettings, METH_VARARGS, NULL},
	 { (char *)"HeavyIons_isHeavyIon", _wrap_HeavyIons_isHeavyIon, METH_VARARGS, NULL},
	 { (char *)"HeavyIons_setHIUserHooksPtr", _wrap_HeavyIons_setHIUserHooksPtr, METH_VARARGS, NULL},
	 { (char *)"HeavyIons_hiinfo_set", _wrap_HeavyIons_hiinfo_set, METH_VARARGS, NULL},
	 { (char *)"HeavyIons_hiinfo_get", _wrap_HeavyIons_hiinfo_get, METH_VARARGS, NULL},
	 { (char *)"HeavyIons_stat", _wrap_HeavyIons_stat, METH_VARARGS, NULL},
	 { (char *)"HeavyIons_swigregister", HeavyIons_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_Angantyr", _wrap_new_Angantyr, METH_VARARGS, NULL},
	 { (char *)"delete_Angantyr", _wrap_delete_Angantyr, METH_VARARGS, NULL},
	 { (char *)"Angantyr_init", _wrap_Angantyr_init, METH_VARARGS, NULL},
	 { (char *)"Angantyr_next", _wrap_Angantyr_next, METH_VARARGS, NULL},
	 { (char *)"Angantyr_setUserHooksPtr", _wrap_Angantyr_setUserHooksPtr, METH_VARARGS, NULL},
	 { (char *)"Angantyr_getTransforms", _wrap_Angantyr_getTransforms, METH_VARARGS, NULL},
	 { (char *)"Angantyr_mT2", _wrap_Angantyr_mT2, METH_VARARGS, NULL},
	 { (char *)"Angantyr_mT", _wrap_Angantyr_mT, METH_VARARGS, NULL},
	 { (char *)"Angantyr_swigregister", Angantyr_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_JetMatchingAlpgenInputAlpgen", _wrap_new_JetMatchingAlpgenInputAlpgen, METH_VARARGS, NULL},
	 { (char *)"delete_JetMatchingAlpgenInputAlpgen", _wrap_delete_JetMatchingAlpgenInputAlpgen, METH_VARARGS, NULL},
	 { (char *)"JetMatchingAlpgenInputAlpgen_initAfterBeams", _wrap_JetMatchingAlpgenInputAlpgen_initAfterBeams, METH_VARARGS, NULL},
	 { (char *)"JetMatchingAlpgenInputAlpgen_canVetoProcessLevel", _wrap_JetMatchingAlpgenInputAlpgen_canVetoProcessLevel, METH_VARARGS, NULL},
	 { (char *)"JetMatchingAlpgenInputAlpgen_doVetoProcessLevel", _wrap_JetMatchingAlpgenInputAlpgen_doVetoProcessLevel, METH_VARARGS, NULL},
	 { (char *)"JetMatchingAlpgenInputAlpgen_canVetoPartonLevelEarly", _wrap_JetMatchingAlpgenInputAlpgen_canVetoPartonLevelEarly, METH_VARARGS, NULL},
	 { (char *)"JetMatchingAlpgenInputAlpgen_doVetoPartonLevelEarly", _wrap_JetMatchingAlpgenInputAlpgen_doVetoPartonLevelEarly, METH_VARARGS, NULL},
	 { (char *)"JetMatchingAlpgenInputAlpgen_swigregister", JetMatchingAlpgenInputAlpgen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_JetMatchingMadgraphInputAlpgen", _wrap_new_JetMatchingMadgraphInputAlpgen, METH_VARARGS, NULL},
	 { (char *)"delete_JetMatchingMadgraphInputAlpgen", _wrap_delete_JetMatchingMadgraphInputAlpgen, METH_VARARGS, NULL},
	 { (char *)"JetMatchingMadgraphInputAlpgen_initAfterBeams", _wrap_JetMatchingMadgraphInputAlpgen_initAfterBeams, METH_VARARGS, NULL},
	 { (char *)"JetMatchingMadgraphInputAlpgen_canVetoProcessLevel", _wrap_JetMatchingMadgraphInputAlpgen_canVetoProcessLevel, METH_VARARGS, NULL},
	 { (char *)"JetMatchingMadgraphInputAlpgen_doVetoProcessLevel", _wrap_JetMatchingMadgraphInputAlpgen_doVetoProcessLevel, METH_VARARGS, NULL},
	 { (char *)"JetMatchingMadgraphInputAlpgen_canVetoPartonLevelEarly", _wrap_JetMatchingMadgraphInputAlpgen_canVetoPartonLevelEarly, METH_VARARGS, NULL},
	 { (char *)"JetMatchingMadgraphInputAlpgen_doVetoPartonLevelEarly", _wrap_JetMatchingMadgraphInputAlpgen_doVetoPartonLevelEarly, METH_VARARGS, NULL},
	 { (char *)"JetMatchingMadgraphInputAlpgen_swigregister", JetMatchingMadgraphInputAlpgen_swigregister, METH_VARARGS, NULL},
	 { (char *)"new_CombineMatchingInput", _wrap_new_CombineMatchingInput, METH_VARARGS, NULL},
	 { (char *)"delete_CombineMatchingInput", _wrap_delete_CombineMatchingInput, METH_VARARGS, NULL},
	 { (char *)"CombineMatchingInput_getHook", _wrap_CombineMatchingInput_getHook, METH_VARARGS, NULL},
	 { (char *)"CombineMatchingInput_swigregister", CombineMatchingInput_swigregister, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag_iterator", _wrap_MapStringFlag_iterator, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag___nonzero__", _wrap_MapStringFlag___nonzero__, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag___bool__", _wrap_MapStringFlag___bool__, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag___len__", _wrap_MapStringFlag___len__, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag___getitem__", _wrap_MapStringFlag___getitem__, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag___delitem__", _wrap_MapStringFlag___delitem__, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag_has_key", _wrap_MapStringFlag_has_key, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag_keys", _wrap_MapStringFlag_keys, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag_values", _wrap_MapStringFlag_values, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag_items", _wrap_MapStringFlag_items, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag___contains__", _wrap_MapStringFlag___contains__, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag_key_iterator", _wrap_MapStringFlag_key_iterator, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag_value_iterator", _wrap_MapStringFlag_value_iterator, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag___setitem__", _wrap_MapStringFlag___setitem__, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag_asdict", _wrap_MapStringFlag_asdict, METH_VARARGS, NULL},
	 { (char *)"new_MapStringFlag", _wrap_new_MapStringFlag, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag_empty", _wrap_MapStringFlag_empty, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag_size", _wrap_MapStringFlag_size, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag_swap", _wrap_MapStringFlag_swap, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag_begin", _wrap_MapStringFlag_begin, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag_end", _wrap_MapStringFlag_end, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag_rbegin", _wrap_MapStringFlag_rbegin, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag_rend", _wrap_MapStringFlag_rend, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag_clear", _wrap_MapStringFlag_clear, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag_get_allocator", _wrap_MapStringFlag_get_allocator, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag_count", _wrap_MapStringFlag_count, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag_erase", _wrap_MapStringFlag_erase, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag_find", _wrap_MapStringFlag_find, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag_lower_bound", _wrap_MapStringFlag_lower_bound, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag_upper_bound", _wrap_MapStringFlag_upper_bound, METH_VARARGS, NULL},
	 { (char *)"delete_MapStringFlag", _wrap_delete_MapStringFlag, METH_VARARGS, NULL},
	 { (char *)"MapStringFlag_swigregister", MapStringFlag_swigregister, METH_VARARGS, NULL},
	 { (char *)"MapStringMode_iterator", _wrap_MapStringMode_iterator, METH_VARARGS, NULL},
	 { (char *)"MapStringMode___nonzero__", _wrap_MapStringMode___nonzero__, METH_VARARGS, NULL},
	 { (char *)"MapStringMode___bool__", _wrap_MapStringMode___bool__, METH_VARARGS, NULL},
	 { (char *)"MapStringMode___len__", _wrap_MapStringMode___len__, METH_VARARGS, NULL},
	 { (char *)"MapStringMode___getitem__", _wrap_MapStringMode___getitem__, METH_VARARGS, NULL},
	 { (char *)"MapStringMode___delitem__", _wrap_MapStringMode___delitem__, METH_VARARGS, NULL},
	 { (char *)"MapStringMode_has_key", _wrap_MapStringMode_has_key, METH_VARARGS, NULL},
	 { (char *)"MapStringMode_keys", _wrap_MapStringMode_keys, METH_VARARGS, NULL},
	 { (char *)"MapStringMode_values", _wrap_MapStringMode_values, METH_VARARGS, NULL},
	 { (char *)"MapStringMode_items", _wrap_MapStringMode_items, METH_VARARGS, NULL},
	 { (char *)"MapStringMode___contains__", _wrap_MapStringMode___contains__, METH_VARARGS, NULL},
	 { (char *)"MapStringMode_key_iterator", _wrap_MapStringMode_key_iterator, METH_VARARGS, NULL},
	 { (char *)"MapStringMode_value_iterator", _wrap_MapStringMode_value_iterator, METH_VARARGS, NULL},
	 { (char *)"MapStringMode___setitem__", _wrap_MapStringMode___setitem__, METH_VARARGS, NULL},
	 { (char *)"MapStringMode_asdict", _wrap_MapStringMode_asdict, METH_VARARGS, NULL},
	 { (char *)"new_MapStringMode", _wrap_new_MapStringMode, METH_VARARGS, NULL},
	 { (char *)"MapStringMode_empty", _wrap_MapStringMode_empty, METH_VARARGS, NULL},
	 { (char *)"MapStringMode_size", _wrap_MapStringMode_size, METH_VARARGS, NULL},
	 { (char *)"MapStringMode_swap", _wrap_MapStringMode_swap, METH_VARARGS, NULL},
	 { (char *)"MapStringMode_begin", _wrap_MapStringMode_begin, METH_VARARGS, NULL},
	 { (char *)"MapStringMode_end", _wrap_MapStringMode_end, METH_VARARGS, NULL},
	 { (char *)"MapStringMode_rbegin", _wrap_MapStringMode_rbegin, METH_VARARGS, NULL},
	 { (char *)"MapStringMode_rend", _wrap_MapStringMode_rend, METH_VARARGS, NULL},
	 { (char *)"MapStringMode_clear", _wrap_MapStringMode_clear, METH_VARARGS, NULL},
	 { (char *)"MapStringMode_get_allocator", _wrap_MapStringMode_get_allocator, METH_VARARGS, NULL},
	 { (char *)"MapStringMode_count", _wrap_MapStringMode_count, METH_VARARGS, NULL},
	 { (char *)"MapStringMode_erase", _wrap_MapStringMode_erase, METH_VARARGS, NULL},
	 { (char *)"MapStringMode_find", _wrap_MapStringMode_find, METH_VARARGS, NULL},
	 { (char *)"MapStringMode_lower_bound", _wrap_MapStringMode_lower_bound, METH_VARARGS, NULL},
	 { (char *)"MapStringMode_upper_bound", _wrap_MapStringMode_upper_bound, METH_VARARGS, NULL},
	 { (char *)"delete_MapStringMode", _wrap_delete_MapStringMode, METH_VARARGS, NULL},
	 { (char *)"MapStringMode_swigregister", MapStringMode_swigregister, METH_VARARGS, NULL},
	 { (char *)"MapStringParm_iterator", _wrap_MapStringParm_iterator, METH_VARARGS, NULL},
	 { (char *)"MapStringParm___nonzero__", _wrap_MapStringParm___nonzero__, METH_VARARGS, NULL},
	 { (char *)"MapStringParm___bool__", _wrap_MapStringParm___bool__, METH_VARARGS, NULL},
	 { (char *)"MapStringParm___len__", _wrap_MapStringParm___len__, METH_VARARGS, NULL},
	 { (char *)"MapStringParm___getitem__", _wrap_MapStringParm___getitem__, METH_VARARGS, NULL},
	 { (char *)"MapStringParm___delitem__", _wrap_MapStringParm___delitem__, METH_VARARGS, NULL},
	 { (char *)"MapStringParm_has_key", _wrap_MapStringParm_has_key, METH_VARARGS, NULL},
	 { (char *)"MapStringParm_keys", _wrap_MapStringParm_keys, METH_VARARGS, NULL},
	 { (char *)"MapStringParm_values", _wrap_MapStringParm_values, METH_VARARGS, NULL},
	 { (char *)"MapStringParm_items", _wrap_MapStringParm_items, METH_VARARGS, NULL},
	 { (char *)"MapStringParm___contains__", _wrap_MapStringParm___contains__, METH_VARARGS, NULL},
	 { (char *)"MapStringParm_key_iterator", _wrap_MapStringParm_key_iterator, METH_VARARGS, NULL},
	 { (char *)"MapStringParm_value_iterator", _wrap_MapStringParm_value_iterator, METH_VARARGS, NULL},
	 { (char *)"MapStringParm___setitem__", _wrap_MapStringParm___setitem__, METH_VARARGS, NULL},
	 { (char *)"MapStringParm_asdict", _wrap_MapStringParm_asdict, METH_VARARGS, NULL},
	 { (char *)"new_MapStringParm", _wrap_new_MapStringParm, METH_VARARGS, NULL},
	 { (char *)"MapStringParm_empty", _wrap_MapStringParm_empty, METH_VARARGS, NULL},
	 { (char *)"MapStringParm_size", _wrap_MapStringParm_size, METH_VARARGS, NULL},
	 { (char *)"MapStringParm_swap", _wrap_MapStringParm_swap, METH_VARARGS, NULL},
	 { (char *)"MapStringParm_begin", _wrap_MapStringParm_begin, METH_VARARGS, NULL},
	 { (char *)"MapStringParm_end", _wrap_MapStringParm_end, METH_VARARGS, NULL},
	 { (char *)"MapStringParm_rbegin", _wrap_MapStringParm_rbegin, METH_VARARGS, NULL},
	 { (char *)"MapStringParm_rend", _wrap_MapStringParm_rend, METH_VARARGS, NULL},
	 { (char *)"MapStringParm_clear", _wrap_MapStringParm_clear, METH_VARARGS, NULL},
	 { (char *)"MapStringParm_get_allocator", _wrap_MapStringParm_get_allocator, METH_VARARGS, NULL},
	 { (char *)"MapStringParm_count", _wrap_MapStringParm_count, METH_VARARGS, NULL},
	 { (char *)"MapStringParm_erase", _wrap_MapStringParm_erase, METH_VARARGS, NULL},
	 { (char *)"MapStringParm_find", _wrap_MapStringParm_find, METH_VARARGS, NULL},
	 { (char *)"MapStringParm_lower_bound", _wrap_MapStringParm_lower_bound, METH_VARARGS, NULL},
	 { (char *)"MapStringParm_upper_bound", _wrap_MapStringParm_upper_bound, METH_VARARGS, NULL},
	 { (char *)"delete_MapStringParm", _wrap_delete_MapStringParm, METH_VARARGS, NULL},
	 { (char *)"MapStringParm_swigregister", MapStringParm_swigregister, METH_VARARGS, NULL},
	 { (char *)"MapStringWord_iterator", _wrap_MapStringWord_iterator, METH_VARARGS, NULL},
	 { (char *)"MapStringWord___nonzero__", _wrap_MapStringWord___nonzero__, METH_VARARGS, NULL},
	 { (char *)"MapStringWord___bool__", _wrap_MapStringWord___bool__, METH_VARARGS, NULL},
	 { (char *)"MapStringWord___len__", _wrap_MapStringWord___len__, METH_VARARGS, NULL},
	 { (char *)"MapStringWord___getitem__", _wrap_MapStringWord___getitem__, METH_VARARGS, NULL},
	 { (char *)"MapStringWord___delitem__", _wrap_MapStringWord___delitem__, METH_VARARGS, NULL},
	 { (char *)"MapStringWord_has_key", _wrap_MapStringWord_has_key, METH_VARARGS, NULL},
	 { (char *)"MapStringWord_keys", _wrap_MapStringWord_keys, METH_VARARGS, NULL},
	 { (char *)"MapStringWord_values", _wrap_MapStringWord_values, METH_VARARGS, NULL},
	 { (char *)"MapStringWord_items", _wrap_MapStringWord_items, METH_VARARGS, NULL},
	 { (char *)"MapStringWord___contains__", _wrap_MapStringWord___contains__, METH_VARARGS, NULL},
	 { (char *)"MapStringWord_key_iterator", _wrap_MapStringWord_key_iterator, METH_VARARGS, NULL},
	 { (char *)"MapStringWord_value_iterator", _wrap_MapStringWord_value_iterator, METH_VARARGS, NULL},
	 { (char *)"MapStringWord___setitem__", _wrap_MapStringWord___setitem__, METH_VARARGS, NULL},
	 { (char *)"MapStringWord_asdict", _wrap_MapStringWord_asdict, METH_VARARGS, NULL},
	 { (char *)"new_MapStringWord", _wrap_new_MapStringWord, METH_VARARGS, NULL},
	 { (char *)"MapStringWord_empty", _wrap_MapStringWord_empty, METH_VARARGS, NULL},
	 { (char *)"MapStringWord_size", _wrap_MapStringWord_size, METH_VARARGS, NULL},
	 { (char *)"MapStringWord_swap", _wrap_MapStringWord_swap, METH_VARARGS, NULL},
	 { (char *)"MapStringWord_begin", _wrap_MapStringWord_begin, METH_VARARGS, NULL},
	 { (char *)"MapStringWord_end", _wrap_MapStringWord_end, METH_VARARGS, NULL},
	 { (char *)"MapStringWord_rbegin", _wrap_MapStringWord_rbegin, METH_VARARGS, NULL},
	 { (char *)"MapStringWord_rend", _wrap_MapStringWord_rend, METH_VARARGS, NULL},
	 { (char *)"MapStringWord_clear", _wrap_MapStringWord_clear, METH_VARARGS, NULL},
	 { (char *)"MapStringWord_get_allocator", _wrap_MapStringWord_get_allocator, METH_VARARGS, NULL},
	 { (char *)"MapStringWord_count", _wrap_MapStringWord_count, METH_VARARGS, NULL},
	 { (char *)"MapStringWord_erase", _wrap_MapStringWord_erase, METH_VARARGS, NULL},
	 { (char *)"MapStringWord_find", _wrap_MapStringWord_find, METH_VARARGS, NULL},
	 { (char *)"MapStringWord_lower_bound", _wrap_MapStringWord_lower_bound, METH_VARARGS, NULL},
	 { (char *)"MapStringWord_upper_bound", _wrap_MapStringWord_upper_bound, METH_VARARGS, NULL},
	 { (char *)"delete_MapStringWord", _wrap_delete_MapStringWord, METH_VARARGS, NULL},
	 { (char *)"MapStringWord_swigregister", MapStringWord_swigregister, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec_iterator", _wrap_MapStringFVec_iterator, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec___nonzero__", _wrap_MapStringFVec___nonzero__, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec___bool__", _wrap_MapStringFVec___bool__, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec___len__", _wrap_MapStringFVec___len__, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec___getitem__", _wrap_MapStringFVec___getitem__, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec___delitem__", _wrap_MapStringFVec___delitem__, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec_has_key", _wrap_MapStringFVec_has_key, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec_keys", _wrap_MapStringFVec_keys, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec_values", _wrap_MapStringFVec_values, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec_items", _wrap_MapStringFVec_items, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec___contains__", _wrap_MapStringFVec___contains__, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec_key_iterator", _wrap_MapStringFVec_key_iterator, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec_value_iterator", _wrap_MapStringFVec_value_iterator, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec___setitem__", _wrap_MapStringFVec___setitem__, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec_asdict", _wrap_MapStringFVec_asdict, METH_VARARGS, NULL},
	 { (char *)"new_MapStringFVec", _wrap_new_MapStringFVec, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec_empty", _wrap_MapStringFVec_empty, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec_size", _wrap_MapStringFVec_size, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec_swap", _wrap_MapStringFVec_swap, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec_begin", _wrap_MapStringFVec_begin, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec_end", _wrap_MapStringFVec_end, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec_rbegin", _wrap_MapStringFVec_rbegin, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec_rend", _wrap_MapStringFVec_rend, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec_clear", _wrap_MapStringFVec_clear, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec_get_allocator", _wrap_MapStringFVec_get_allocator, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec_count", _wrap_MapStringFVec_count, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec_erase", _wrap_MapStringFVec_erase, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec_find", _wrap_MapStringFVec_find, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec_lower_bound", _wrap_MapStringFVec_lower_bound, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec_upper_bound", _wrap_MapStringFVec_upper_bound, METH_VARARGS, NULL},
	 { (char *)"delete_MapStringFVec", _wrap_delete_MapStringFVec, METH_VARARGS, NULL},
	 { (char *)"MapStringFVec_swigregister", MapStringFVec_swigregister, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec_iterator", _wrap_MapStringMVec_iterator, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec___nonzero__", _wrap_MapStringMVec___nonzero__, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec___bool__", _wrap_MapStringMVec___bool__, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec___len__", _wrap_MapStringMVec___len__, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec___getitem__", _wrap_MapStringMVec___getitem__, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec___delitem__", _wrap_MapStringMVec___delitem__, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec_has_key", _wrap_MapStringMVec_has_key, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec_keys", _wrap_MapStringMVec_keys, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec_values", _wrap_MapStringMVec_values, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec_items", _wrap_MapStringMVec_items, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec___contains__", _wrap_MapStringMVec___contains__, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec_key_iterator", _wrap_MapStringMVec_key_iterator, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec_value_iterator", _wrap_MapStringMVec_value_iterator, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec___setitem__", _wrap_MapStringMVec___setitem__, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec_asdict", _wrap_MapStringMVec_asdict, METH_VARARGS, NULL},
	 { (char *)"new_MapStringMVec", _wrap_new_MapStringMVec, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec_empty", _wrap_MapStringMVec_empty, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec_size", _wrap_MapStringMVec_size, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec_swap", _wrap_MapStringMVec_swap, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec_begin", _wrap_MapStringMVec_begin, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec_end", _wrap_MapStringMVec_end, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec_rbegin", _wrap_MapStringMVec_rbegin, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec_rend", _wrap_MapStringMVec_rend, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec_clear", _wrap_MapStringMVec_clear, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec_get_allocator", _wrap_MapStringMVec_get_allocator, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec_count", _wrap_MapStringMVec_count, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec_erase", _wrap_MapStringMVec_erase, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec_find", _wrap_MapStringMVec_find, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec_lower_bound", _wrap_MapStringMVec_lower_bound, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec_upper_bound", _wrap_MapStringMVec_upper_bound, METH_VARARGS, NULL},
	 { (char *)"delete_MapStringMVec", _wrap_delete_MapStringMVec, METH_VARARGS, NULL},
	 { (char *)"MapStringMVec_swigregister", MapStringMVec_swigregister, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec_iterator", _wrap_MapStringPVec_iterator, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec___nonzero__", _wrap_MapStringPVec___nonzero__, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec___bool__", _wrap_MapStringPVec___bool__, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec___len__", _wrap_MapStringPVec___len__, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec___getitem__", _wrap_MapStringPVec___getitem__, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec___delitem__", _wrap_MapStringPVec___delitem__, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec_has_key", _wrap_MapStringPVec_has_key, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec_keys", _wrap_MapStringPVec_keys, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec_values", _wrap_MapStringPVec_values, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec_items", _wrap_MapStringPVec_items, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec___contains__", _wrap_MapStringPVec___contains__, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec_key_iterator", _wrap_MapStringPVec_key_iterator, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec_value_iterator", _wrap_MapStringPVec_value_iterator, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec___setitem__", _wrap_MapStringPVec___setitem__, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec_asdict", _wrap_MapStringPVec_asdict, METH_VARARGS, NULL},
	 { (char *)"new_MapStringPVec", _wrap_new_MapStringPVec, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec_empty", _wrap_MapStringPVec_empty, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec_size", _wrap_MapStringPVec_size, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec_swap", _wrap_MapStringPVec_swap, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec_begin", _wrap_MapStringPVec_begin, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec_end", _wrap_MapStringPVec_end, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec_rbegin", _wrap_MapStringPVec_rbegin, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec_rend", _wrap_MapStringPVec_rend, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec_clear", _wrap_MapStringPVec_clear, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec_get_allocator", _wrap_MapStringPVec_get_allocator, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec_count", _wrap_MapStringPVec_count, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec_erase", _wrap_MapStringPVec_erase, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec_find", _wrap_MapStringPVec_find, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec_lower_bound", _wrap_MapStringPVec_lower_bound, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec_upper_bound", _wrap_MapStringPVec_upper_bound, METH_VARARGS, NULL},
	 { (char *)"delete_MapStringPVec", _wrap_delete_MapStringPVec, METH_VARARGS, NULL},
	 { (char *)"MapStringPVec_swigregister", MapStringPVec_swigregister, METH_VARARGS, NULL},
	 { (char *)"VectorClustering_iterator", _wrap_VectorClustering_iterator, METH_VARARGS, NULL},
	 { (char *)"VectorClustering___nonzero__", _wrap_VectorClustering___nonzero__, METH_VARARGS, NULL},
	 { (char *)"VectorClustering___bool__", _wrap_VectorClustering___bool__, METH_VARARGS, NULL},
	 { (char *)"VectorClustering___len__", _wrap_VectorClustering___len__, METH_VARARGS, NULL},
	 { (char *)"VectorClustering___getslice__", _wrap_VectorClustering___getslice__, METH_VARARGS, NULL},
	 { (char *)"VectorClustering___setslice__", _wrap_VectorClustering___setslice__, METH_VARARGS, NULL},
	 { (char *)"VectorClustering___delslice__", _wrap_VectorClustering___delslice__, METH_VARARGS, NULL},
	 { (char *)"VectorClustering___delitem__", _wrap_VectorClustering___delitem__, METH_VARARGS, NULL},
	 { (char *)"VectorClustering___getitem__", _wrap_VectorClustering___getitem__, METH_VARARGS, NULL},
	 { (char *)"VectorClustering___setitem__", _wrap_VectorClustering___setitem__, METH_VARARGS, NULL},
	 { (char *)"VectorClustering_pop", _wrap_VectorClustering_pop, METH_VARARGS, NULL},
	 { (char *)"VectorClustering_append", _wrap_VectorClustering_append, METH_VARARGS, NULL},
	 { (char *)"VectorClustering_empty", _wrap_VectorClustering_empty, METH_VARARGS, NULL},
	 { (char *)"VectorClustering_size", _wrap_VectorClustering_size, METH_VARARGS, NULL},
	 { (char *)"VectorClustering_swap", _wrap_VectorClustering_swap, METH_VARARGS, NULL},
	 { (char *)"VectorClustering_begin", _wrap_VectorClustering_begin, METH_VARARGS, NULL},
	 { (char *)"VectorClustering_end", _wrap_VectorClustering_end, METH_VARARGS, NULL},
	 { (char *)"VectorClustering_rbegin", _wrap_VectorClustering_rbegin, METH_VARARGS, NULL},
	 { (char *)"VectorClustering_rend", _wrap_VectorClustering_rend, METH_VARARGS, NULL},
	 { (char *)"VectorClustering_clear", _wrap_VectorClustering_clear, METH_VARARGS, NULL},
	 { (char *)"VectorClustering_get_allocator", _wrap_VectorClustering_get_allocator, METH_VARARGS, NULL},
	 { (char *)"VectorClustering_pop_back", _wrap_VectorClustering_pop_back, METH_VARARGS, NULL},
	 { (char *)"VectorClustering_erase", _wrap_VectorClustering_erase, METH_VARARGS, NULL},
	 { (char *)"new_VectorClustering", _wrap_new_VectorClustering, METH_VARARGS, NULL},
	 { (char *)"VectorClustering_push_back", _wrap_VectorClustering_push_back, METH_VARARGS, NULL},
	 { (char *)"VectorClustering_front", _wrap_VectorClustering_front, METH_VARARGS, NULL},
	 { (char *)"VectorClustering_back", _wrap_VectorClustering_back, METH_VARARGS, NULL},
	 { (char *)"VectorClustering_assign", _wrap_VectorClustering_assign, METH_VARARGS, NULL},
	 { (char *)"VectorClustering_resize", _wrap_VectorClustering_resize, METH_VARARGS, NULL},
	 { (char *)"VectorClustering_insert", _wrap_VectorClustering_insert, METH_VARARGS, NULL},
	 { (char *)"VectorClustering_reserve", _wrap_VectorClustering_reserve, METH_VARARGS, NULL},
	 { (char *)"VectorClustering_capacity", _wrap_VectorClustering_capacity, METH_VARARGS, NULL},
	 { (char *)"delete_VectorClustering", _wrap_delete_VectorClustering, METH_VARARGS, NULL},
	 { (char *)"VectorClustering_swigregister", VectorClustering_swigregister, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle_iterator", _wrap_VectorHelicityParticle_iterator, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle___nonzero__", _wrap_VectorHelicityParticle___nonzero__, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle___bool__", _wrap_VectorHelicityParticle___bool__, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle___len__", _wrap_VectorHelicityParticle___len__, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle___getslice__", _wrap_VectorHelicityParticle___getslice__, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle___setslice__", _wrap_VectorHelicityParticle___setslice__, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle___delslice__", _wrap_VectorHelicityParticle___delslice__, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle___delitem__", _wrap_VectorHelicityParticle___delitem__, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle___getitem__", _wrap_VectorHelicityParticle___getitem__, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle___setitem__", _wrap_VectorHelicityParticle___setitem__, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle_pop", _wrap_VectorHelicityParticle_pop, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle_append", _wrap_VectorHelicityParticle_append, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle_empty", _wrap_VectorHelicityParticle_empty, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle_size", _wrap_VectorHelicityParticle_size, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle_swap", _wrap_VectorHelicityParticle_swap, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle_begin", _wrap_VectorHelicityParticle_begin, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle_end", _wrap_VectorHelicityParticle_end, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle_rbegin", _wrap_VectorHelicityParticle_rbegin, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle_rend", _wrap_VectorHelicityParticle_rend, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle_clear", _wrap_VectorHelicityParticle_clear, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle_get_allocator", _wrap_VectorHelicityParticle_get_allocator, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle_pop_back", _wrap_VectorHelicityParticle_pop_back, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle_erase", _wrap_VectorHelicityParticle_erase, METH_VARARGS, NULL},
	 { (char *)"new_VectorHelicityParticle", _wrap_new_VectorHelicityParticle, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle_push_back", _wrap_VectorHelicityParticle_push_back, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle_front", _wrap_VectorHelicityParticle_front, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle_back", _wrap_VectorHelicityParticle_back, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle_assign", _wrap_VectorHelicityParticle_assign, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle_resize", _wrap_VectorHelicityParticle_resize, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle_insert", _wrap_VectorHelicityParticle_insert, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle_reserve", _wrap_VectorHelicityParticle_reserve, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle_capacity", _wrap_VectorHelicityParticle_capacity, METH_VARARGS, NULL},
	 { (char *)"delete_VectorHelicityParticle", _wrap_delete_VectorHelicityParticle, METH_VARARGS, NULL},
	 { (char *)"VectorHelicityParticle_swigregister", VectorHelicityParticle_swigregister, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr_iterator", _wrap_VectorProcessContainerPtr_iterator, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr___nonzero__", _wrap_VectorProcessContainerPtr___nonzero__, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr___bool__", _wrap_VectorProcessContainerPtr___bool__, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr___len__", _wrap_VectorProcessContainerPtr___len__, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr___getslice__", _wrap_VectorProcessContainerPtr___getslice__, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr___setslice__", _wrap_VectorProcessContainerPtr___setslice__, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr___delslice__", _wrap_VectorProcessContainerPtr___delslice__, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr___delitem__", _wrap_VectorProcessContainerPtr___delitem__, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr___getitem__", _wrap_VectorProcessContainerPtr___getitem__, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr___setitem__", _wrap_VectorProcessContainerPtr___setitem__, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr_pop", _wrap_VectorProcessContainerPtr_pop, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr_append", _wrap_VectorProcessContainerPtr_append, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr_empty", _wrap_VectorProcessContainerPtr_empty, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr_size", _wrap_VectorProcessContainerPtr_size, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr_swap", _wrap_VectorProcessContainerPtr_swap, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr_begin", _wrap_VectorProcessContainerPtr_begin, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr_end", _wrap_VectorProcessContainerPtr_end, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr_rbegin", _wrap_VectorProcessContainerPtr_rbegin, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr_rend", _wrap_VectorProcessContainerPtr_rend, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr_clear", _wrap_VectorProcessContainerPtr_clear, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr_get_allocator", _wrap_VectorProcessContainerPtr_get_allocator, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr_pop_back", _wrap_VectorProcessContainerPtr_pop_back, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr_erase", _wrap_VectorProcessContainerPtr_erase, METH_VARARGS, NULL},
	 { (char *)"new_VectorProcessContainerPtr", _wrap_new_VectorProcessContainerPtr, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr_push_back", _wrap_VectorProcessContainerPtr_push_back, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr_front", _wrap_VectorProcessContainerPtr_front, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr_back", _wrap_VectorProcessContainerPtr_back, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr_assign", _wrap_VectorProcessContainerPtr_assign, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr_resize", _wrap_VectorProcessContainerPtr_resize, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr_insert", _wrap_VectorProcessContainerPtr_insert, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr_reserve", _wrap_VectorProcessContainerPtr_reserve, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr_capacity", _wrap_VectorProcessContainerPtr_capacity, METH_VARARGS, NULL},
	 { (char *)"delete_VectorProcessContainerPtr", _wrap_delete_VectorProcessContainerPtr, METH_VARARGS, NULL},
	 { (char *)"VectorProcessContainerPtr_swigregister", VectorProcessContainerPtr_swigregister, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr_iterator", _wrap_VectorResonanceWidthsPtr_iterator, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr___nonzero__", _wrap_VectorResonanceWidthsPtr___nonzero__, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr___bool__", _wrap_VectorResonanceWidthsPtr___bool__, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr___len__", _wrap_VectorResonanceWidthsPtr___len__, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr___getslice__", _wrap_VectorResonanceWidthsPtr___getslice__, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr___setslice__", _wrap_VectorResonanceWidthsPtr___setslice__, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr___delslice__", _wrap_VectorResonanceWidthsPtr___delslice__, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr___delitem__", _wrap_VectorResonanceWidthsPtr___delitem__, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr___getitem__", _wrap_VectorResonanceWidthsPtr___getitem__, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr___setitem__", _wrap_VectorResonanceWidthsPtr___setitem__, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr_pop", _wrap_VectorResonanceWidthsPtr_pop, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr_append", _wrap_VectorResonanceWidthsPtr_append, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr_empty", _wrap_VectorResonanceWidthsPtr_empty, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr_size", _wrap_VectorResonanceWidthsPtr_size, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr_swap", _wrap_VectorResonanceWidthsPtr_swap, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr_begin", _wrap_VectorResonanceWidthsPtr_begin, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr_end", _wrap_VectorResonanceWidthsPtr_end, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr_rbegin", _wrap_VectorResonanceWidthsPtr_rbegin, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr_rend", _wrap_VectorResonanceWidthsPtr_rend, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr_clear", _wrap_VectorResonanceWidthsPtr_clear, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr_get_allocator", _wrap_VectorResonanceWidthsPtr_get_allocator, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr_pop_back", _wrap_VectorResonanceWidthsPtr_pop_back, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr_erase", _wrap_VectorResonanceWidthsPtr_erase, METH_VARARGS, NULL},
	 { (char *)"new_VectorResonanceWidthsPtr", _wrap_new_VectorResonanceWidthsPtr, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr_push_back", _wrap_VectorResonanceWidthsPtr_push_back, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr_front", _wrap_VectorResonanceWidthsPtr_front, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr_back", _wrap_VectorResonanceWidthsPtr_back, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr_assign", _wrap_VectorResonanceWidthsPtr_assign, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr_resize", _wrap_VectorResonanceWidthsPtr_resize, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr_insert", _wrap_VectorResonanceWidthsPtr_insert, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr_reserve", _wrap_VectorResonanceWidthsPtr_reserve, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr_capacity", _wrap_VectorResonanceWidthsPtr_capacity, METH_VARARGS, NULL},
	 { (char *)"delete_VectorResonanceWidthsPtr", _wrap_delete_VectorResonanceWidthsPtr, METH_VARARGS, NULL},
	 { (char *)"VectorResonanceWidthsPtr_swigregister", VectorResonanceWidthsPtr_swigregister, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr_iterator", _wrap_VectorSigmaProcessPtr_iterator, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr___nonzero__", _wrap_VectorSigmaProcessPtr___nonzero__, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr___bool__", _wrap_VectorSigmaProcessPtr___bool__, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr___len__", _wrap_VectorSigmaProcessPtr___len__, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr___getslice__", _wrap_VectorSigmaProcessPtr___getslice__, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr___setslice__", _wrap_VectorSigmaProcessPtr___setslice__, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr___delslice__", _wrap_VectorSigmaProcessPtr___delslice__, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr___delitem__", _wrap_VectorSigmaProcessPtr___delitem__, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr___getitem__", _wrap_VectorSigmaProcessPtr___getitem__, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr___setitem__", _wrap_VectorSigmaProcessPtr___setitem__, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr_pop", _wrap_VectorSigmaProcessPtr_pop, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr_append", _wrap_VectorSigmaProcessPtr_append, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr_empty", _wrap_VectorSigmaProcessPtr_empty, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr_size", _wrap_VectorSigmaProcessPtr_size, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr_swap", _wrap_VectorSigmaProcessPtr_swap, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr_begin", _wrap_VectorSigmaProcessPtr_begin, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr_end", _wrap_VectorSigmaProcessPtr_end, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr_rbegin", _wrap_VectorSigmaProcessPtr_rbegin, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr_rend", _wrap_VectorSigmaProcessPtr_rend, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr_clear", _wrap_VectorSigmaProcessPtr_clear, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr_get_allocator", _wrap_VectorSigmaProcessPtr_get_allocator, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr_pop_back", _wrap_VectorSigmaProcessPtr_pop_back, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr_erase", _wrap_VectorSigmaProcessPtr_erase, METH_VARARGS, NULL},
	 { (char *)"new_VectorSigmaProcessPtr", _wrap_new_VectorSigmaProcessPtr, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr_push_back", _wrap_VectorSigmaProcessPtr_push_back, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr_front", _wrap_VectorSigmaProcessPtr_front, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr_back", _wrap_VectorSigmaProcessPtr_back, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr_assign", _wrap_VectorSigmaProcessPtr_assign, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr_resize", _wrap_VectorSigmaProcessPtr_resize, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr_insert", _wrap_VectorSigmaProcessPtr_insert, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr_reserve", _wrap_VectorSigmaProcessPtr_reserve, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr_capacity", _wrap_VectorSigmaProcessPtr_capacity, METH_VARARGS, NULL},
	 { (char *)"delete_VectorSigmaProcessPtr", _wrap_delete_VectorSigmaProcessPtr, METH_VARARGS, NULL},
	 { (char *)"VectorSigmaProcessPtr_swigregister", VectorSigmaProcessPtr_swigregister, METH_VARARGS, NULL},
	 { (char *)"VectorVec4_iterator", _wrap_VectorVec4_iterator, METH_VARARGS, NULL},
	 { (char *)"VectorVec4___nonzero__", _wrap_VectorVec4___nonzero__, METH_VARARGS, NULL},
	 { (char *)"VectorVec4___bool__", _wrap_VectorVec4___bool__, METH_VARARGS, NULL},
	 { (char *)"VectorVec4___len__", _wrap_VectorVec4___len__, METH_VARARGS, NULL},
	 { (char *)"VectorVec4___getslice__", _wrap_VectorVec4___getslice__, METH_VARARGS, NULL},
	 { (char *)"VectorVec4___setslice__", _wrap_VectorVec4___setslice__, METH_VARARGS, NULL},
	 { (char *)"VectorVec4___delslice__", _wrap_VectorVec4___delslice__, METH_VARARGS, NULL},
	 { (char *)"VectorVec4___delitem__", _wrap_VectorVec4___delitem__, METH_VARARGS, NULL},
	 { (char *)"VectorVec4___getitem__", _wrap_VectorVec4___getitem__, METH_VARARGS, NULL},
	 { (char *)"VectorVec4___setitem__", _wrap_VectorVec4___setitem__, METH_VARARGS, NULL},
	 { (char *)"VectorVec4_pop", _wrap_VectorVec4_pop, METH_VARARGS, NULL},
	 { (char *)"VectorVec4_append", _wrap_VectorVec4_append, METH_VARARGS, NULL},
	 { (char *)"VectorVec4_empty", _wrap_VectorVec4_empty, METH_VARARGS, NULL},
	 { (char *)"VectorVec4_size", _wrap_VectorVec4_size, METH_VARARGS, NULL},
	 { (char *)"VectorVec4_swap", _wrap_VectorVec4_swap, METH_VARARGS, NULL},
	 { (char *)"VectorVec4_begin", _wrap_VectorVec4_begin, METH_VARARGS, NULL},
	 { (char *)"VectorVec4_end", _wrap_VectorVec4_end, METH_VARARGS, NULL},
	 { (char *)"VectorVec4_rbegin", _wrap_VectorVec4_rbegin, METH_VARARGS, NULL},
	 { (char *)"VectorVec4_rend", _wrap_VectorVec4_rend, METH_VARARGS, NULL},
	 { (char *)"VectorVec4_clear", _wrap_VectorVec4_clear, METH_VARARGS, NULL},
	 { (char *)"VectorVec4_get_allocator", _wrap_VectorVec4_get_allocator, METH_VARARGS, NULL},
	 { (char *)"VectorVec4_pop_back", _wrap_VectorVec4_pop_back, METH_VARARGS, NULL},
	 { (char *)"VectorVec4_erase", _wrap_VectorVec4_erase, METH_VARARGS, NULL},
	 { (char *)"new_VectorVec4", _wrap_new_VectorVec4, METH_VARARGS, NULL},
	 { (char *)"VectorVec4_push_back", _wrap_VectorVec4_push_back, METH_VARARGS, NULL},
	 { (char *)"VectorVec4_front", _wrap_VectorVec4_front, METH_VARARGS, NULL},
	 { (char *)"VectorVec4_back", _wrap_VectorVec4_back, METH_VARARGS, NULL},
	 { (char *)"VectorVec4_assign", _wrap_VectorVec4_assign, METH_VARARGS, NULL},
	 { (char *)"VectorVec4_resize", _wrap_VectorVec4_resize, METH_VARARGS, NULL},
	 { (char *)"VectorVec4_insert", _wrap_VectorVec4_insert, METH_VARARGS, NULL},
	 { (char *)"VectorVec4_reserve", _wrap_VectorVec4_reserve, METH_VARARGS, NULL},
	 { (char *)"VectorVec4_capacity", _wrap_VectorVec4_capacity, METH_VARARGS, NULL},
	 { (char *)"delete_VectorVec4", _wrap_delete_VectorVec4, METH_VARARGS, NULL},
	 { (char *)"VectorVec4_swigregister", VectorVec4_swigregister, METH_VARARGS, NULL},
	 { NULL, NULL, 0, NULL }
};


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

static void *_p_Pythia8__LHgenericBlockTo_p_Pythia8__LHblockT_std__string_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::LHblock< std::string > *)  ((Pythia8::LHgenericBlock *) x));
}
static void *_p_Pythia8__Sigma3qg2qqqbarDiffTo_p_Pythia8__Sigma3qq2qqgDiff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma3qq2qqgDiff *)  ((Pythia8::Sigma3qg2qqqbarDiff *) x));
}
static void *_p_Pythia8__Sigma3qqbar2qqbargDiffTo_p_Pythia8__Sigma3qq2qqgDiff(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma3qq2qqgDiff *)  ((Pythia8::Sigma3qqbar2qqbargDiff *) x));
}
static void *_p_Pythia8__CouplingsTo_p_Pythia8__CoupSM(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::CoupSM *)  ((Pythia8::Couplings *) x));
}
static void *_p_Pythia8__CoupSUSYTo_p_Pythia8__CoupSM(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::CoupSM *) (Pythia8::Couplings *) ((Pythia8::CoupSUSY *) x));
}
static void *_p_Pythia8__Sigma2qg2Sq2XXjTo_p_Pythia8__Sigma2gg2Sg2XXj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2gg2Sg2XXj *)  ((Pythia8::Sigma2qg2Sq2XXj *) x));
}
static void *_p_Pythia8__JetMatchingMadgraphInputAlpgenTo_p_Pythia8__JetMatchingMadgraph(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::JetMatchingMadgraph *)  ((Pythia8::JetMatchingMadgraphInputAlpgen *) x));
}
static void *_p_Pythia8__AngantyrTo_p_Pythia8__HeavyIons(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HeavyIons *)  ((Pythia8::Angantyr *) x));
}
static void *_p_Pythia8__amcnlo_unitarised_interfaceTo_p_Pythia8__UserHooks(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::UserHooks *)  ((Pythia8::amcnlo_unitarised_interface *) x));
}
static void *_p_Pythia8__JetMatchingAlpgenTo_p_Pythia8__UserHooks(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::UserHooks *) (Pythia8::JetMatching *) ((Pythia8::JetMatchingAlpgen *) x));
}
static void *_p_Pythia8__SuppressSmallPTTo_p_Pythia8__UserHooks(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::UserHooks *)  ((Pythia8::SuppressSmallPT *) x));
}
static void *_p_Pythia8__UserHooksVectorTo_p_Pythia8__UserHooks(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::UserHooks *)  ((Pythia8::UserHooksVector *) x));
}
static void *_p_Pythia8__AlpgenHooksTo_p_Pythia8__UserHooks(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::UserHooks *)  ((Pythia8::AlpgenHooks *) x));
}
static void *_p_Pythia8__PowhegHooksTo_p_Pythia8__UserHooks(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::UserHooks *)  ((Pythia8::PowhegHooks *) x));
}
static void *_p_Pythia8__MBReconUserHooksTo_p_Pythia8__UserHooks(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::UserHooks *)  ((Pythia8::MBReconUserHooks *) x));
}
static void *_p_Pythia8__TopReconUserHooksTo_p_Pythia8__UserHooks(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::UserHooks *)  ((Pythia8::TopReconUserHooks *) x));
}
static void *_p_Pythia8__JetMatchingTo_p_Pythia8__UserHooks(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::UserHooks *)  ((Pythia8::JetMatching *) x));
}
static void *_p_Pythia8__JetMatchingMadgraphTo_p_Pythia8__UserHooks(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::UserHooks *) (Pythia8::JetMatching *) ((Pythia8::JetMatchingMadgraph *) x));
}
static void *_p_Pythia8__JetMatchingAlpgenInputAlpgenTo_p_Pythia8__UserHooks(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::UserHooks *) (Pythia8::AlpgenHooks *) ((Pythia8::JetMatchingAlpgenInputAlpgen *) x));
}
static void *_p_Pythia8__JetMatchingMadgraphInputAlpgenTo_p_Pythia8__UserHooks(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::UserHooks *) (Pythia8::AlpgenHooks *) ((Pythia8::JetMatchingMadgraphInputAlpgen *) x));
}
static void *_p_Pythia8__JetMatchingAlpgenInputAlpgenTo_p_Pythia8__AlpgenHooks(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::AlpgenHooks *)  ((Pythia8::JetMatchingAlpgenInputAlpgen *) x));
}
static void *_p_Pythia8__JetMatchingMadgraphInputAlpgenTo_p_Pythia8__AlpgenHooks(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::AlpgenHooks *)  ((Pythia8::JetMatchingMadgraphInputAlpgen *) x));
}
static void *_p_Pythia8__HMETau2ThreeMesonsTo_p_Pythia8__HMETauDecay(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HMETauDecay *)  ((Pythia8::HMETau2ThreeMesons *) x));
}
static void *_p_Pythia8__HMETau2TwoLeptonsTo_p_Pythia8__HMETauDecay(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HMETauDecay *)  ((Pythia8::HMETau2TwoLeptons *) x));
}
static void *_p_Pythia8__HMETau2TwoMesonsViaVectorTo_p_Pythia8__HMETauDecay(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HMETauDecay *)  ((Pythia8::HMETau2TwoMesonsViaVector *) x));
}
static void *_p_Pythia8__HMETau2ThreePionsTo_p_Pythia8__HMETauDecay(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HMETauDecay *) (Pythia8::HMETau2ThreeMesons *) ((Pythia8::HMETau2ThreePions *) x));
}
static void *_p_Pythia8__HMETau2ThreeMesonsWithKaonsTo_p_Pythia8__HMETauDecay(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HMETauDecay *) (Pythia8::HMETau2ThreeMesons *) ((Pythia8::HMETau2ThreeMesonsWithKaons *) x));
}
static void *_p_Pythia8__HMETau2TwoPionsGammaTo_p_Pythia8__HMETauDecay(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HMETauDecay *)  ((Pythia8::HMETau2TwoPionsGamma *) x));
}
static void *_p_Pythia8__HMETau2FivePionsTo_p_Pythia8__HMETauDecay(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HMETauDecay *)  ((Pythia8::HMETau2FivePions *) x));
}
static void *_p_Pythia8__HMETau2TwoMesonsViaVectorScalarTo_p_Pythia8__HMETauDecay(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HMETauDecay *)  ((Pythia8::HMETau2TwoMesonsViaVectorScalar *) x));
}
static void *_p_Pythia8__HMETau2ThreeMesonsGenericTo_p_Pythia8__HMETauDecay(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HMETauDecay *) (Pythia8::HMETau2ThreeMesons *) ((Pythia8::HMETau2ThreeMesonsGeneric *) x));
}
static void *_p_Pythia8__HMETau2MesonTo_p_Pythia8__HMETauDecay(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HMETauDecay *)  ((Pythia8::HMETau2Meson *) x));
}
static void *_p_Pythia8__HMETau2PhaseSpaceTo_p_Pythia8__HMETauDecay(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HMETauDecay *)  ((Pythia8::HMETau2PhaseSpace *) x));
}
static void *_p_Pythia8__HMETau2FourPionsTo_p_Pythia8__HMETauDecay(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HMETauDecay *)  ((Pythia8::HMETau2FourPions *) x));
}
static void *_p_Pythia8__Sigma3gg2qqbargTo_p_Pythia8__Sigma3qqbar2ggg(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma3qqbar2ggg *)  ((Pythia8::Sigma3gg2qqbarg *) x));
}
static void *_p_Pythia8__Sigma3qg2qggTo_p_Pythia8__Sigma3qqbar2ggg(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma3qqbar2ggg *)  ((Pythia8::Sigma3qg2qgg *) x));
}
static void *_p_Pythia8__ColourJunctionTo_p_Pythia8__Junction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Junction *)  ((Pythia8::ColourJunction *) x));
}
static void *_p_Pythia8__StauWidthsTo_p_Pythia8__WidthFunction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::WidthFunction *)  ((Pythia8::StauWidths *) x));
}
static void *_p_Pythia8__IsospinTo_p_Pythia8__nPDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::nPDF *)  ((Pythia8::Isospin *) x));
}
static void *_p_Pythia8__EPPS16To_p_Pythia8__nPDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::nPDF *)  ((Pythia8::EPPS16 *) x));
}
static void *_p_Pythia8__EPS09To_p_Pythia8__nPDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::nPDF *)  ((Pythia8::EPS09 *) x));
}
static void *_p_Pythia8__Sigma1qg2qStarTo_p_Pythia8__Sigma1Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma1Process *)  ((Pythia8::Sigma1qg2qStar *) x));
}
static void *_p_Pythia8__Sigma1ffbar2RhorizontalTo_p_Pythia8__Sigma1Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma1Process *)  ((Pythia8::Sigma1ffbar2Rhorizontal *) x));
}
static void *_p_Pythia8__Sigma1ffbarZprimeWprimeTo_p_Pythia8__Sigma1Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma1Process *)  ((Pythia8::Sigma1ffbarZprimeWprime *) x));
}
static void *_p_Pythia8__Sigma1ffbar2WTo_p_Pythia8__Sigma1Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma1Process *)  ((Pythia8::Sigma1ffbar2W *) x));
}
static void *_p_Pythia8__Sigma1ffbar2HTo_p_Pythia8__Sigma1Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma1Process *)  ((Pythia8::Sigma1ffbar2H *) x));
}
static void *_p_Pythia8__Sigma1qq2antisquarkTo_p_Pythia8__Sigma1Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma1Process *)  ((Pythia8::Sigma1qq2antisquark *) x));
}
static void *_p_Pythia8__Sigma1lgm2lStarTo_p_Pythia8__Sigma1Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma1Process *)  ((Pythia8::Sigma1lgm2lStar *) x));
}
static void *_p_Pythia8__Sigma1ffbar2WRightTo_p_Pythia8__Sigma1Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma1Process *)  ((Pythia8::Sigma1ffbar2WRight *) x));
}
static void *_p_Pythia8__Sigma1ffbar2WprimeTo_p_Pythia8__Sigma1Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma1Process *) (Pythia8::Sigma1ffbarZprimeWprime *) ((Pythia8::Sigma1ffbar2Wprime *) x));
}
static void *_p_Pythia8__Sigma1gg2HTo_p_Pythia8__Sigma1Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma1Process *)  ((Pythia8::Sigma1gg2H *) x));
}
static void *_p_Pythia8__Sigma1ffbar2gmZTo_p_Pythia8__Sigma1Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma1Process *)  ((Pythia8::Sigma1ffbar2gmZ *) x));
}
static void *_p_Pythia8__Sigma1gg2S2XXTo_p_Pythia8__Sigma1Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma1Process *)  ((Pythia8::Sigma1gg2S2XX *) x));
}
static void *_p_Pythia8__Sigma1ffbar2HchgTo_p_Pythia8__Sigma1Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma1Process *)  ((Pythia8::Sigma1ffbar2Hchg *) x));
}
static void *_p_Pythia8__Sigma1ql2LeptoQuarkTo_p_Pythia8__Sigma1Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma1Process *)  ((Pythia8::Sigma1ql2LeptoQuark *) x));
}
static void *_p_Pythia8__Sigma1ffbar2Zp2XXTo_p_Pythia8__Sigma1Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma1Process *)  ((Pythia8::Sigma1ffbar2Zp2XX *) x));
}
static void *_p_Pythia8__Sigma1ffbar2GravitonStarTo_p_Pythia8__Sigma1Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma1Process *)  ((Pythia8::Sigma1ffbar2GravitonStar *) x));
}
static void *_p_Pythia8__Sigma1gg2GravitonStarTo_p_Pythia8__Sigma1Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma1Process *)  ((Pythia8::Sigma1gg2GravitonStar *) x));
}
static void *_p_Pythia8__Sigma1ffbar2ZRightTo_p_Pythia8__Sigma1Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma1Process *)  ((Pythia8::Sigma1ffbar2ZRight *) x));
}
static void *_p_Pythia8__Sigma1ll2HchgchgTo_p_Pythia8__Sigma1Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma1Process *)  ((Pythia8::Sigma1ll2Hchgchg *) x));
}
static void *_p_Pythia8__Sigma1ffbar2gmZZprimeTo_p_Pythia8__Sigma1Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma1Process *) (Pythia8::Sigma1ffbarZprimeWprime *) ((Pythia8::Sigma1ffbar2gmZZprime *) x));
}
static void *_p_Pythia8__Sigma1ffbar2ZvTo_p_Pythia8__Sigma1Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma1Process *)  ((Pythia8::Sigma1ffbar2Zv *) x));
}
static void *_p_Pythia8__Sigma1qqbar2KKgluonStarTo_p_Pythia8__Sigma1Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma1Process *)  ((Pythia8::Sigma1qqbar2KKgluonStar *) x));
}
static void *_p_Pythia8__Sigma1gmgm2HTo_p_Pythia8__Sigma1Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma1Process *)  ((Pythia8::Sigma1gmgm2H *) x));
}
static void *_p_Pythia8__Sigma3qg2qqqbarSameTo_p_Pythia8__Sigma3Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma3Process *) (Pythia8::Sigma3qq2qqgSame *) ((Pythia8::Sigma3qg2qqqbarSame *) x));
}
static void *_p_Pythia8__Sigma3ff2HfftWWTo_p_Pythia8__Sigma3Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma3Process *)  ((Pythia8::Sigma3ff2HfftWW *) x));
}
static void *_p_Pythia8__Sigma3qqbar2HQQbarTo_p_Pythia8__Sigma3Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma3Process *)  ((Pythia8::Sigma3qqbar2HQQbar *) x));
}
static void *_p_Pythia8__Sigma3gg2HQQbarTo_p_Pythia8__Sigma3Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma3Process *)  ((Pythia8::Sigma3gg2HQQbar *) x));
}
static void *_p_Pythia8__Sigma3gg2gggTo_p_Pythia8__Sigma3Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma3Process *)  ((Pythia8::Sigma3gg2ggg *) x));
}
static void *_p_Pythia8__Sigma3gg2qqbargTo_p_Pythia8__Sigma3Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma3Process *) (Pythia8::Sigma3qqbar2ggg *) ((Pythia8::Sigma3gg2qqbarg *) x));
}
static void *_p_Pythia8__Sigma3qq2qqgDiffTo_p_Pythia8__Sigma3Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma3Process *)  ((Pythia8::Sigma3qq2qqgDiff *) x));
}
static void *_p_Pythia8__Sigma3qqbar2qqbargDiffTo_p_Pythia8__Sigma3Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma3Process *) (Pythia8::Sigma3qq2qqgDiff *) ((Pythia8::Sigma3qqbar2qqbargDiff *) x));
}
static void *_p_Pythia8__Sigma3ff2HchgchgfftWWTo_p_Pythia8__Sigma3Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma3Process *)  ((Pythia8::Sigma3ff2HchgchgfftWW *) x));
}
static void *_p_Pythia8__Sigma3qqbar2gggTo_p_Pythia8__Sigma3Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma3Process *)  ((Pythia8::Sigma3qqbar2ggg *) x));
}
static void *_p_Pythia8__Sigma3qq2qqgSameTo_p_Pythia8__Sigma3Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma3Process *)  ((Pythia8::Sigma3qq2qqgSame *) x));
}
static void *_p_Pythia8__Sigma3qg2qqqbarDiffTo_p_Pythia8__Sigma3Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma3Process *) (Pythia8::Sigma3qq2qqgDiff *) ((Pythia8::Sigma3qg2qqqbarDiff *) x));
}
static void *_p_Pythia8__Sigma3qg2qggTo_p_Pythia8__Sigma3Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma3Process *) (Pythia8::Sigma3qqbar2ggg *) ((Pythia8::Sigma3qg2qgg *) x));
}
static void *_p_Pythia8__Sigma3ff2HfftZZTo_p_Pythia8__Sigma3Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma3Process *)  ((Pythia8::Sigma3ff2HfftZZ *) x));
}
static void *_p_Pythia8__Sigma3qqbar2qqbargSameTo_p_Pythia8__Sigma3Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma3Process *) (Pythia8::Sigma3qq2qqgSame *) ((Pythia8::Sigma3qqbar2qqbargSame *) x));
}
static void *_p_Pythia8__Sigma2SUSYTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2SUSY *) x));
}
static void *_p_Pythia8__Sigma2qg2Sq2XXjTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *) (Pythia8::Sigma2gg2Sg2XXj *) ((Pythia8::Sigma2qg2Sq2XXj *) x));
}
static void *_p_Pythia8__Sigma2qg2HqTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qg2Hq *) x));
}
static void *_p_Pythia8__Sigma2gg2HgltTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2gg2Hglt *) x));
}
static void *_p_Pythia8__Sigma2ffbar2HchgH12To_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2ffbar2HchgH12 *) x));
}
static void *_p_Pythia8__Sigma2qq2QqtWTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qq2QqtW *) x));
}
static void *_p_Pythia8__Sigma2qq2qStarqTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qq2qStarq *) x));
}
static void *_p_Pythia8__Sigma2qq2LEDqqTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qq2LEDqq *) x));
}
static void *_p_Pythia8__Sigma2qqbar2lStarlbarTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qqbar2lStarlbar *) x));
}
static void *_p_Pythia8__Sigma2gg2QQbar3S11gmTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2gg2QQbar3S11gm *) x));
}
static void *_p_Pythia8__Sigma2qqbar2QQbarTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qqbar2QQbar *) x));
}
static void *_p_Pythia8__Sigma2qgm2qgTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qgm2qg *) x));
}
static void *_p_Pythia8__Sigma2qg2WqTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *) (Pythia8::Sigma2ffbarWggm *) ((Pythia8::Sigma2qg2Wq *) x));
}
static void *_p_Pythia8__Sigma2qqbar2sleptonantisleptonTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *) (Pythia8::Sigma2qqbar2squarkantisquark *) ((Pythia8::Sigma2qqbar2sleptonantislepton *) x));
}
static void *_p_Pythia8__Sigma2ffbar2ZWTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *) (Pythia8::Sigma2ffbargmZWgmZW *) ((Pythia8::Sigma2ffbar2ZW *) x));
}
static void *_p_Pythia8__Sigma2qqbar2HgltTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qqbar2Hglt *) x));
}
static void *_p_Pythia8__Sigma2gg2QQbar3DJ1gTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *) (Pythia8::Sigma2gg2QQbar3PJ1g *) ((Pythia8::Sigma2gg2QQbar3DJ1g *) x));
}
static void *_p_Pythia8__Sigma2ffbar2ffbarsWTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2ffbar2ffbarsW *) x));
}
static void *_p_Pythia8__Sigma2ffbar2FfbarsWTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2ffbar2FfbarsW *) x));
}
static void *_p_Pythia8__Sigma2ffbar2LEDUnparticleZTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2ffbar2LEDUnparticleZ *) x));
}
static void *_p_Pythia8__Sigma2qqbar2charchi0To_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *) (Pythia8::Sigma2SUSY *)(Pythia8::Sigma2qqbar2chi0chi0 *) ((Pythia8::Sigma2qqbar2charchi0 *) x));
}
static void *_p_Pythia8__Sigma2ggm2qqbarTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2ggm2qqbar *) x));
}
static void *_p_Pythia8__Sigma2gg2qqbarTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2gg2qqbar *) x));
}
static void *_p_Pythia8__Sigma2ffbar2ffbarsgmTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2ffbar2ffbarsgm *) x));
}
static void *_p_Pythia8__Sigma2gg2LQLQbarTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2gg2LQLQbar *) x));
}
static void *_p_Pythia8__Sigma2qqbar2LQLQbarTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qqbar2LQLQbar *) x));
}
static void *_p_Pythia8__Sigma2ffbar2gmZgmTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *) (Pythia8::Sigma2ffbargmZggm *) ((Pythia8::Sigma2ffbar2gmZgm *) x));
}
static void *_p_Pythia8__Sigma2qqbar2LEDqqbarNewTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qqbar2LEDqqbarNew *) x));
}
static void *_p_Pythia8__Sigma2qqbar2qqbarNewTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qqbar2qqbarNew *) x));
}
static void *_p_Pythia8__Sigma2qqbar2ggammaTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qqbar2ggamma *) x));
}
static void *_p_Pythia8__Sigma2gg2ggammaTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2gg2ggamma *) x));
}
static void *_p_Pythia8__Sigma2qqbar2chi0gluinoTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *) (Pythia8::Sigma2SUSY *) ((Pythia8::Sigma2qqbar2chi0gluino *) x));
}
static void *_p_Pythia8__Sigma2qqbar2chargluinoTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *) (Pythia8::Sigma2SUSY *)(Pythia8::Sigma2qqbar2chi0gluino *) ((Pythia8::Sigma2qqbar2chargluino *) x));
}
static void *_p_Pythia8__Sigma2gmgm2ffbarTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2gmgm2ffbar *) x));
}
static void *_p_Pythia8__Sigma2gg2ggTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2gg2gg *) x));
}
static void *_p_Pythia8__Sigma2gg2LEDllbarTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2gg2LEDllbar *) x));
}
static void *_p_Pythia8__Sigma2ffbar2LEDllbarTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2ffbar2LEDllbar *) x));
}
static void *_p_Pythia8__Sigma2qqbar2GravitonStargTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qqbar2GravitonStarg *) x));
}
static void *_p_Pythia8__Sigma2gg2GravitonStargTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2gg2GravitonStarg *) x));
}
static void *_p_Pythia8__Sigma2ffbar2WgmTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *) (Pythia8::Sigma2ffbarWggm *) ((Pythia8::Sigma2ffbar2Wgm *) x));
}
static void *_p_Pythia8__Sigma2qqbar2LEDUnparticlegTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qqbar2LEDUnparticleg *) x));
}
static void *_p_Pythia8__Sigma2gg2LEDUnparticlegTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2gg2LEDUnparticleg *) x));
}
static void *_p_Pythia8__Sigma2QCffbar2llbarTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2QCffbar2llbar *) x));
}
static void *_p_Pythia8__Sigma2ffbar2ZpHTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2ffbar2ZpH *) x));
}
static void *_p_Pythia8__Sigma2ffbargmZggmTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2ffbargmZggm *) x));
}
static void *_p_Pythia8__Sigma2gg2QQbarTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2gg2QQbar *) x));
}
static void *_p_Pythia8__Sigma2fgm2WfTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *) (Pythia8::Sigma2ffbarWggm *) ((Pythia8::Sigma2fgm2Wf *) x));
}
static void *_p_Pythia8__Sigma2qg2GravitonStarqTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qg2GravitonStarq *) x));
}
static void *_p_Pythia8__Sigma2QCqq2qqTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2QCqq2qq *) x));
}
static void *_p_Pythia8__Sigma2qqbar2WgTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *) (Pythia8::Sigma2ffbarWggm *) ((Pythia8::Sigma2qqbar2Wg *) x));
}
static void *_p_Pythia8__Sigma2ffbar2A3H12To_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2ffbar2A3H12 *) x));
}
static void *_p_Pythia8__Sigma2gg2QQbarX8gTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2gg2QQbarX8g *) x));
}
static void *_p_Pythia8__Sigma2qqbar2QQbarX8gTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *) (Pythia8::Sigma2gg2QQbarX8g *) ((Pythia8::Sigma2qqbar2QQbarX8g *) x));
}
static void *_p_Pythia8__Sigma2qg2LEDUnparticleqTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qg2LEDUnparticleq *) x));
}
static void *_p_Pythia8__Sigma2qg2LeptoQuarklTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qg2LeptoQuarkl *) x));
}
static void *_p_Pythia8__Sigma2qg2chi0squarkTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qg2chi0squark *) x));
}
static void *_p_Pythia8__Sigma2qg2charsquarkTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *) (Pythia8::Sigma2qg2chi0squark *) ((Pythia8::Sigma2qg2charsquark *) x));
}
static void *_p_Pythia8__Sigma2qq2qqTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qq2qq *) x));
}
static void *_p_Pythia8__Sigma2ff2fftWTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2ff2fftW *) x));
}
static void *_p_Pythia8__Sigma2qg2qgTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qg2qg *) x));
}
static void *_p_Pythia8__Sigma2fgm2gmZfTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *) (Pythia8::Sigma2ffbargmZggm *) ((Pythia8::Sigma2fgm2gmZf *) x));
}
static void *_p_Pythia8__Sigma2qqbar2LEDggTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qqbar2LEDgg *) x));
}
static void *_p_Pythia8__Sigma2ffbar2TEVffbarTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2ffbar2TEVffbar *) x));
}
static void *_p_Pythia8__Sigma2gg2QQbar3PJ1gTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2gg2QQbar3PJ1g *) x));
}
static void *_p_Pythia8__Sigma2qqbar2QQbar3PJ1gTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *) (Pythia8::Sigma2gg2QQbar3PJ1g *) ((Pythia8::Sigma2qqbar2QQbar3PJ1g *) x));
}
static void *_p_Pythia8__Sigma2ff2fftgmZTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2ff2fftgmZ *) x));
}
static void *_p_Pythia8__Sigma2qg2QQbarX8qTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *) (Pythia8::Sigma2gg2QQbarX8g *) ((Pythia8::Sigma2qg2QQbarX8q *) x));
}
static void *_p_Pythia8__Sigma2ffbargmZWgmZWTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2ffbargmZWgmZW *) x));
}
static void *_p_Pythia8__Sigma2ffbar2gmZgmZTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *) (Pythia8::Sigma2ffbargmZWgmZW *) ((Pythia8::Sigma2ffbar2gmZgmZ *) x));
}
static void *_p_Pythia8__Sigma2qqbar2Zpg2XXjTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qqbar2Zpg2XXj *) x));
}
static void *_p_Pythia8__Sigma2qg2squarkgluinoTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qg2squarkgluino *) x));
}
static void *_p_Pythia8__Sigma2gg2gluinogluinoTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2gg2gluinogluino *) x));
}
static void *_p_Pythia8__Sigma2qqbar2gluinogluinoTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qqbar2gluinogluino *) x));
}
static void *_p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11To_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *) x));
}
static void *_p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11To_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *) x));
}
static void *_p_Pythia8__Sigma2qg2HqltTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qg2Hqlt *) x));
}
static void *_p_Pythia8__Sigma2qqbar2lStarlStarBarTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qqbar2lStarlStarBar *) x));
}
static void *_p_Pythia8__Sigma2qg2QQbar3PJ1qTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *) (Pythia8::Sigma2gg2QQbar3PJ1g *) ((Pythia8::Sigma2qg2QQbar3PJ1q *) x));
}
static void *_p_Pythia8__Sigma2qg2HchgqTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qg2Hchgq *) x));
}
static void *_p_Pythia8__Sigma2qg2qgammaTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qg2qgamma *) x));
}
static void *_p_Pythia8__Sigma2lgm2HchgchglTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2lgm2Hchgchgl *) x));
}
static void *_p_Pythia8__Sigma2gg2LEDgammagammaTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2gg2LEDgammagamma *) x));
}
static void *_p_Pythia8__Sigma2ffbar2LEDgammagammaTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2ffbar2LEDgammagamma *) x));
}
static void *_p_Pythia8__Sigma2qg2Zpq2XXjTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *) (Pythia8::Sigma2qqbar2Zpg2XXj *) ((Pythia8::Sigma2qg2Zpq2XXj *) x));
}
static void *_p_Pythia8__Sigma2ffbar2gammagammaTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2ffbar2gammagamma *) x));
}
static void *_p_Pythia8__Sigma2gg2gammagammaTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2gg2gammagamma *) x));
}
static void *_p_Pythia8__Sigma2ffbarWggmTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2ffbarWggm *) x));
}
static void *_p_Pythia8__Sigma2qqbar2gmZgTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *) (Pythia8::Sigma2ffbargmZggm *) ((Pythia8::Sigma2qqbar2gmZg *) x));
}
static void *_p_Pythia8__Sigma2qqbar2charcharTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *) (Pythia8::Sigma2SUSY *)(Pythia8::Sigma2qqbar2chi0chi0 *) ((Pythia8::Sigma2qqbar2charchar *) x));
}
static void *_p_Pythia8__Sigma2qqbar2qGqGbarTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qqbar2qGqGbar *) x));
}
static void *_p_Pythia8__Sigma2gg2qGqGbarTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2gg2qGqGbar *) x));
}
static void *_p_Pythia8__Sigma2qg2gmZqTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *) (Pythia8::Sigma2ffbargmZggm *) ((Pythia8::Sigma2qg2gmZq *) x));
}
static void *_p_Pythia8__Sigma2gg2LEDqqbarTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2gg2LEDqqbar *) x));
}
static void *_p_Pythia8__Sigma2qq2squarksquarkTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qq2squarksquark *) x));
}
static void *_p_Pythia8__Sigma2qqbar2squarkantisquarkTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qqbar2squarkantisquark *) x));
}
static void *_p_Pythia8__Sigma2gg2squarkantisquarkTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2gg2squarkantisquark *) x));
}
static void *_p_Pythia8__Sigma2qqbar2chi0chi0To_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *) (Pythia8::Sigma2SUSY *) ((Pythia8::Sigma2qqbar2chi0chi0 *) x));
}
static void *_p_Pythia8__Sigma2ffbar2HWTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2ffbar2HW *) x));
}
static void *_p_Pythia8__Sigma2QCqqbar2qqbarTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2QCqqbar2qqbar *) x));
}
static void *_p_Pythia8__Sigma2gg2QQbar3S11gTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2gg2QQbar3S11g *) x));
}
static void *_p_Pythia8__Sigma2ffbar2HZTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2ffbar2HZ *) x));
}
static void *_p_Pythia8__Sigma2gg2LEDggTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2gg2LEDgg *) x));
}
static void *_p_Pythia8__Sigma2ffbar2fGfGbarTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2ffbar2fGfGbar *) x));
}
static void *_p_Pythia8__Sigma2gg2Sg2XXjTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2gg2Sg2XXj *) x));
}
static void *_p_Pythia8__Sigma2ffbar2WWTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *) (Pythia8::Sigma2ffbargmZWgmZW *) ((Pythia8::Sigma2ffbar2WW *) x));
}
static void *_p_Pythia8__Sigma2qg2LEDqgTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qg2LEDqg *) x));
}
static void *_p_Pythia8__Sigma2ffbar2ffbarsgmZTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2ffbar2ffbarsgmZ *) x));
}
static void *_p_Pythia8__Sigma2ffbar2FFbarsgmZTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2ffbar2FFbarsgmZ *) x));
}
static void *_p_Pythia8__Sigma2qqbar2ggTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qqbar2gg *) x));
}
static void *_p_Pythia8__Sigma2ffbar2HchgchgHchgchgTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2ffbar2HchgchgHchgchg *) x));
}
static void *_p_Pythia8__Sigma2ffbar2LEDUnparticlegammaTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2ffbar2LEDUnparticlegamma *) x));
}
static void *_p_Pythia8__Sigma2qgm2qgmTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2qgm2qgm *) x));
}
static void *_p_Pythia8__Sigma2ffbar2HposHnegTo_p_Pythia8__Sigma2Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2Process *)  ((Pythia8::Sigma2ffbar2HposHneg *) x));
}
static void *_p_Pythia8__Sigma0AB2ABTo_p_Pythia8__Sigma0Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma0Process *)  ((Pythia8::Sigma0AB2AB *) x));
}
static void *_p_Pythia8__Sigma0AB2XBTo_p_Pythia8__Sigma0Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma0Process *)  ((Pythia8::Sigma0AB2XB *) x));
}
static void *_p_Pythia8__Sigma0AB2AXTo_p_Pythia8__Sigma0Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma0Process *)  ((Pythia8::Sigma0AB2AX *) x));
}
static void *_p_Pythia8__Sigma0AB2XXTo_p_Pythia8__Sigma0Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma0Process *)  ((Pythia8::Sigma0AB2XX *) x));
}
static void *_p_Pythia8__Sigma0nonDiffractiveTo_p_Pythia8__Sigma0Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma0Process *)  ((Pythia8::Sigma0nonDiffractive *) x));
}
static void *_p_Pythia8__Sigma0AB2AXBTo_p_Pythia8__Sigma0Process(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma0Process *)  ((Pythia8::Sigma0AB2AXB *) x));
}
static void *_p_Pythia8__Sigma2ffbar2ZWTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *)(Pythia8::Sigma2ffbargmZWgmZW *) ((Pythia8::Sigma2ffbar2ZW *) x));
}
static void *_p_Pythia8__Sigma2ffbar2ffbarsgmZTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2ffbar2ffbarsgmZ *) x));
}
static void *_p_Pythia8__Sigma2ffbar2FFbarsgmZTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2ffbar2FFbarsgmZ *) x));
}
static void *_p_Pythia8__Sigma1ffbar2gmZTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma1Process *) ((Pythia8::Sigma1ffbar2gmZ *) x));
}
static void *_p_Pythia8__Sigma2qg2Sq2XXjTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *)(Pythia8::Sigma2gg2Sg2XXj *) ((Pythia8::Sigma2qg2Sq2XXj *) x));
}
static void *_p_Pythia8__Sigma3qq2qqgSameTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma3Process *) ((Pythia8::Sigma3qq2qqgSame *) x));
}
static void *_p_Pythia8__Sigma2ffbar2ffbarsgmTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2ffbar2ffbarsgm *) x));
}
static void *_p_Pythia8__Sigma2ffbar2LEDUnparticlegammaTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2ffbar2LEDUnparticlegamma *) x));
}
static void *_p_Pythia8__Sigma1gmgm2HTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma1Process *) ((Pythia8::Sigma1gmgm2H *) x));
}
static void *_p_Pythia8__Sigma2qqbar2QQbar3PJ1gTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *)(Pythia8::Sigma2gg2QQbar3PJ1g *) ((Pythia8::Sigma2qqbar2QQbar3PJ1g *) x));
}
static void *_p_Pythia8__Sigma2gg2QQbar3PJ1gTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2gg2QQbar3PJ1g *) x));
}
static void *_p_Pythia8__Sigma2gmgm2ffbarTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2gmgm2ffbar *) x));
}
static void *_p_Pythia8__Sigma2qg2QQbarX8qTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *)(Pythia8::Sigma2gg2QQbarX8g *) ((Pythia8::Sigma2qg2QQbarX8q *) x));
}
static void *_p_Pythia8__Sigma2ffbar2ffbarsWTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2ffbar2ffbarsW *) x));
}
static void *_p_Pythia8__Sigma2ffbar2FfbarsWTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2ffbar2FfbarsW *) x));
}
static void *_p_Pythia8__Sigma2gg2QQbar3S11gTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2gg2QQbar3S11g *) x));
}
static void *_p_Pythia8__Sigma2ffbarWggmTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2ffbarWggm *) x));
}
static void *_p_Pythia8__Sigma2qqbar2LEDqqbarNewTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qqbar2LEDqqbarNew *) x));
}
static void *_p_Pythia8__Sigma2qqbar2qqbarNewTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qqbar2qqbarNew *) x));
}
static void *_p_Pythia8__Sigma2qg2QQbar3PJ1qTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *)(Pythia8::Sigma2gg2QQbar3PJ1g *) ((Pythia8::Sigma2qg2QQbar3PJ1q *) x));
}
static void *_p_Pythia8__Sigma2qg2LEDqgTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qg2LEDqg *) x));
}
static void *_p_Pythia8__Sigma2qqbar2Zpg2XXjTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qqbar2Zpg2XXj *) x));
}
static void *_p_Pythia8__Sigma2gg2HgltTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2gg2Hglt *) x));
}
static void *_p_Pythia8__Sigma2gg2LEDggTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2gg2LEDgg *) x));
}
static void *_p_Pythia8__Sigma1qqbar2KKgluonStarTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma1Process *) ((Pythia8::Sigma1qqbar2KKgluonStar *) x));
}
static void *_p_Pythia8__Sigma2ffbar2A3H12To_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2ffbar2A3H12 *) x));
}
static void *_p_Pythia8__Sigma2qqbar2GravitonStargTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qqbar2GravitonStarg *) x));
}
static void *_p_Pythia8__Sigma2gg2GravitonStargTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2gg2GravitonStarg *) x));
}
static void *_p_Pythia8__Sigma2qqbar2lStarlbarTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qqbar2lStarlbar *) x));
}
static void *_p_Pythia8__Sigma2qgm2qgmTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qgm2qgm *) x));
}
static void *_p_Pythia8__Sigma2ggm2qqbarTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2ggm2qqbar *) x));
}
static void *_p_Pythia8__Sigma2gg2qqbarTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2gg2qqbar *) x));
}
static void *_p_Pythia8__Sigma2qq2LEDqqTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qq2LEDqq *) x));
}
static void *_p_Pythia8__Sigma1ffbar2ZvTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma1Process *) ((Pythia8::Sigma1ffbar2Zv *) x));
}
static void *_p_Pythia8__Sigma0AB2XBTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma0Process *) ((Pythia8::Sigma0AB2XB *) x));
}
static void *_p_Pythia8__Sigma2gg2Sg2XXjTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2gg2Sg2XXj *) x));
}
static void *_p_Pythia8__Sigma1ffbar2HTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma1Process *) ((Pythia8::Sigma1ffbar2H *) x));
}
static void *_p_Pythia8__Sigma2qg2GravitonStarqTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qg2GravitonStarq *) x));
}
static void *_p_Pythia8__Sigma2qg2gmZqTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *)(Pythia8::Sigma2ffbargmZggm *) ((Pythia8::Sigma2qg2gmZq *) x));
}
static void *_p_Pythia8__Sigma2gg2LEDgammagammaTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2gg2LEDgammagamma *) x));
}
static void *_p_Pythia8__Sigma2ffbar2LEDgammagammaTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2ffbar2LEDgammagamma *) x));
}
static void *_p_Pythia8__Sigma2ffbar2gammagammaTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2ffbar2gammagamma *) x));
}
static void *_p_Pythia8__Sigma2gg2gammagammaTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2gg2gammagamma *) x));
}
static void *_p_Pythia8__Sigma1ffbar2Zp2XXTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma1Process *) ((Pythia8::Sigma1ffbar2Zp2XX *) x));
}
static void *_p_Pythia8__Sigma2qqbar2chi0chi0To_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *)(Pythia8::Sigma2SUSY *) ((Pythia8::Sigma2qqbar2chi0chi0 *) x));
}
static void *_p_Pythia8__Sigma2QCffbar2llbarTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2QCffbar2llbar *) x));
}
static void *_p_Pythia8__Sigma2ffbar2gmZgmTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *)(Pythia8::Sigma2ffbargmZggm *) ((Pythia8::Sigma2ffbar2gmZgm *) x));
}
static void *_p_Pythia8__Sigma2qqbar2lStarlStarBarTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qqbar2lStarlStarBar *) x));
}
static void *_p_Pythia8__Sigma1ffbar2WTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma1Process *) ((Pythia8::Sigma1ffbar2W *) x));
}
static void *_p_Pythia8__Sigma2qqbar2LEDggTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qqbar2LEDgg *) x));
}
static void *_p_Pythia8__Sigma2ff2fftgmZTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2ff2fftgmZ *) x));
}
static void *_p_Pythia8__Sigma1ffbar2GravitonStarTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma1Process *) ((Pythia8::Sigma1ffbar2GravitonStar *) x));
}
static void *_p_Pythia8__Sigma1gg2GravitonStarTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma1Process *) ((Pythia8::Sigma1gg2GravitonStar *) x));
}
static void *_p_Pythia8__Sigma0ProcessTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *)  ((Pythia8::Sigma0Process *) x));
}
static void *_p_Pythia8__Sigma1ProcessTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *)  ((Pythia8::Sigma1Process *) x));
}
static void *_p_Pythia8__Sigma2ProcessTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *)  ((Pythia8::Sigma2Process *) x));
}
static void *_p_Pythia8__Sigma3ProcessTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *)  ((Pythia8::Sigma3Process *) x));
}
static void *_p_Pythia8__SigmaLHAProcessTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *)  ((Pythia8::SigmaLHAProcess *) x));
}
static void *_p_Pythia8__Sigma0AB2XXTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma0Process *) ((Pythia8::Sigma0AB2XX *) x));
}
static void *_p_Pythia8__Sigma2QCqqbar2qqbarTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2QCqqbar2qqbar *) x));
}
static void *_p_Pythia8__Sigma2ffbar2LEDUnparticleZTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2ffbar2LEDUnparticleZ *) x));
}
static void *_p_Pythia8__Sigma1qg2qStarTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma1Process *) ((Pythia8::Sigma1qg2qStar *) x));
}
static void *_p_Pythia8__Sigma2qqbar2WgTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *)(Pythia8::Sigma2ffbarWggm *) ((Pythia8::Sigma2qqbar2Wg *) x));
}
static void *_p_Pythia8__Sigma2ffbargmZWgmZWTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2ffbargmZWgmZW *) x));
}
static void *_p_Pythia8__Sigma1ffbar2WRightTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma1Process *) ((Pythia8::Sigma1ffbar2WRight *) x));
}
static void *_p_Pythia8__Sigma2qg2WqTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *)(Pythia8::Sigma2ffbarWggm *) ((Pythia8::Sigma2qg2Wq *) x));
}
static void *_p_Pythia8__Sigma3qg2qggTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma3Process *)(Pythia8::Sigma3qqbar2ggg *) ((Pythia8::Sigma3qg2qgg *) x));
}
static void *_p_Pythia8__Sigma2qg2HchgqTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qg2Hchgq *) x));
}
static void *_p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11To_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *) x));
}
static void *_p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11To_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *) x));
}
static void *_p_Pythia8__Sigma2qqbar2gluinogluinoTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qqbar2gluinogluino *) x));
}
static void *_p_Pythia8__Sigma2gg2gluinogluinoTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2gg2gluinogluino *) x));
}
static void *_p_Pythia8__Sigma2qg2squarkgluinoTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qg2squarkgluino *) x));
}
static void *_p_Pythia8__Sigma2qg2qgTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qg2qg *) x));
}
static void *_p_Pythia8__Sigma3qg2qqqbarSameTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma3Process *)(Pythia8::Sigma3qq2qqgSame *) ((Pythia8::Sigma3qg2qqqbarSame *) x));
}
static void *_p_Pythia8__Sigma2ffbar2WWTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *)(Pythia8::Sigma2ffbargmZWgmZW *) ((Pythia8::Sigma2ffbar2WW *) x));
}
static void *_p_Pythia8__Sigma2qqbar2LEDUnparticlegTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qqbar2LEDUnparticleg *) x));
}
static void *_p_Pythia8__Sigma2gg2LEDUnparticlegTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2gg2LEDUnparticleg *) x));
}
static void *_p_Pythia8__Sigma2qg2HqTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qg2Hq *) x));
}
static void *_p_Pythia8__Sigma1gg2S2XXTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma1Process *) ((Pythia8::Sigma1gg2S2XX *) x));
}
static void *_p_Pythia8__Sigma3gg2gggTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma3Process *) ((Pythia8::Sigma3gg2ggg *) x));
}
static void *_p_Pythia8__Sigma1lgm2lStarTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma1Process *) ((Pythia8::Sigma1lgm2lStar *) x));
}
static void *_p_Pythia8__Sigma2ffbar2WgmTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *)(Pythia8::Sigma2ffbarWggm *) ((Pythia8::Sigma2ffbar2Wgm *) x));
}
static void *_p_Pythia8__Sigma3qqbar2qqbargSameTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma3Process *)(Pythia8::Sigma3qq2qqgSame *) ((Pythia8::Sigma3qqbar2qqbargSame *) x));
}
static void *_p_Pythia8__Sigma3gg2qqbargTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma3Process *)(Pythia8::Sigma3qqbar2ggg *) ((Pythia8::Sigma3gg2qqbarg *) x));
}
static void *_p_Pythia8__Sigma3qq2qqgDiffTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma3Process *) ((Pythia8::Sigma3qq2qqgDiff *) x));
}
static void *_p_Pythia8__Sigma1ffbar2RhorizontalTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma1Process *) ((Pythia8::Sigma1ffbar2Rhorizontal *) x));
}
static void *_p_Pythia8__Sigma2ffbar2HWTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2ffbar2HW *) x));
}
static void *_p_Pythia8__Sigma2qqbar2LQLQbarTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qqbar2LQLQbar *) x));
}
static void *_p_Pythia8__Sigma2gg2LQLQbarTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2gg2LQLQbar *) x));
}
static void *_p_Pythia8__Sigma2qg2LEDUnparticleqTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qg2LEDUnparticleq *) x));
}
static void *_p_Pythia8__Sigma2ffbar2HZTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2ffbar2HZ *) x));
}
static void *_p_Pythia8__Sigma2qqbar2ggTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qqbar2gg *) x));
}
static void *_p_Pythia8__Sigma3ff2HfftZZTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma3Process *) ((Pythia8::Sigma3ff2HfftZZ *) x));
}
static void *_p_Pythia8__Sigma2qgm2qgTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qgm2qg *) x));
}
static void *_p_Pythia8__Sigma2gg2LEDllbarTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2gg2LEDllbar *) x));
}
static void *_p_Pythia8__Sigma2ffbar2LEDllbarTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2ffbar2LEDllbar *) x));
}
static void *_p_Pythia8__Sigma2qqbar2qGqGbarTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qqbar2qGqGbar *) x));
}
static void *_p_Pythia8__Sigma2gg2qGqGbarTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2gg2qGqGbar *) x));
}
static void *_p_Pythia8__Sigma1ffbar2WprimeTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma1Process *)(Pythia8::Sigma1ffbarZprimeWprime *) ((Pythia8::Sigma1ffbar2Wprime *) x));
}
static void *_p_Pythia8__Sigma2qqbar2chi0gluinoTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *)(Pythia8::Sigma2SUSY *) ((Pythia8::Sigma2qqbar2chi0gluino *) x));
}
static void *_p_Pythia8__Sigma2qqbar2chargluinoTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *)(Pythia8::Sigma2SUSY *)(Pythia8::Sigma2qqbar2chi0gluino *) ((Pythia8::Sigma2qqbar2chargluino *) x));
}
static void *_p_Pythia8__Sigma2ffbar2fGfGbarTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2ffbar2fGfGbar *) x));
}
static void *_p_Pythia8__Sigma2gg2LEDqqbarTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2gg2LEDqqbar *) x));
}
static void *_p_Pythia8__Sigma2qqbar2charcharTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *)(Pythia8::Sigma2SUSY *)(Pythia8::Sigma2qqbar2chi0chi0 *) ((Pythia8::Sigma2qqbar2charchar *) x));
}
static void *_p_Pythia8__Sigma1ffbar2ZRightTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma1Process *) ((Pythia8::Sigma1ffbar2ZRight *) x));
}
static void *_p_Pythia8__Sigma2ffbar2HchgchgHchgchgTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2ffbar2HchgchgHchgchg *) x));
}
static void *_p_Pythia8__Sigma1ll2HchgchgTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma1Process *) ((Pythia8::Sigma1ll2Hchgchg *) x));
}
static void *_p_Pythia8__Sigma2qq2qStarqTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qq2qStarq *) x));
}
static void *_p_Pythia8__Sigma2gg2ggTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2gg2gg *) x));
}
static void *_p_Pythia8__Sigma3ff2HchgchgfftWWTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma3Process *) ((Pythia8::Sigma3ff2HchgchgfftWW *) x));
}
static void *_p_Pythia8__Sigma2fgm2gmZfTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *)(Pythia8::Sigma2ffbargmZggm *) ((Pythia8::Sigma2fgm2gmZf *) x));
}
static void *_p_Pythia8__Sigma2gg2QQbar3S11gmTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2gg2QQbar3S11gm *) x));
}
static void *_p_Pythia8__Sigma2lgm2HchgchglTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2lgm2Hchgchgl *) x));
}
static void *_p_Pythia8__Sigma2qqbar2HgltTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qqbar2Hglt *) x));
}
static void *_p_Pythia8__Sigma1ffbar2HchgTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma1Process *) ((Pythia8::Sigma1ffbar2Hchg *) x));
}
static void *_p_Pythia8__Sigma3qqbar2HQQbarTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma3Process *) ((Pythia8::Sigma3qqbar2HQQbar *) x));
}
static void *_p_Pythia8__Sigma3gg2HQQbarTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma3Process *) ((Pythia8::Sigma3gg2HQQbar *) x));
}
static void *_p_Pythia8__Sigma0AB2ABTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma0Process *) ((Pythia8::Sigma0AB2AB *) x));
}
static void *_p_Pythia8__Sigma2gg2QQbar3DJ1gTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *)(Pythia8::Sigma2gg2QQbar3PJ1g *) ((Pythia8::Sigma2gg2QQbar3DJ1g *) x));
}
static void *_p_Pythia8__Sigma1ffbarZprimeWprimeTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma1Process *) ((Pythia8::Sigma1ffbarZprimeWprime *) x));
}
static void *_p_Pythia8__Sigma2qqbar2gmZgTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *)(Pythia8::Sigma2ffbargmZggm *) ((Pythia8::Sigma2qqbar2gmZg *) x));
}
static void *_p_Pythia8__Sigma2qqbar2sleptonantisleptonTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *)(Pythia8::Sigma2qqbar2squarkantisquark *) ((Pythia8::Sigma2qqbar2sleptonantislepton *) x));
}
static void *_p_Pythia8__Sigma0nonDiffractiveTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma0Process *) ((Pythia8::Sigma0nonDiffractive *) x));
}
static void *_p_Pythia8__Sigma2gg2squarkantisquarkTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2gg2squarkantisquark *) x));
}
static void *_p_Pythia8__Sigma2qqbar2squarkantisquarkTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qqbar2squarkantisquark *) x));
}
static void *_p_Pythia8__Sigma2qq2squarksquarkTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qq2squarksquark *) x));
}
static void *_p_Pythia8__Sigma1qq2antisquarkTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma1Process *) ((Pythia8::Sigma1qq2antisquark *) x));
}
static void *_p_Pythia8__Sigma2ffbargmZggmTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2ffbargmZggm *) x));
}
static void *_p_Pythia8__Sigma2qq2QqtWTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qq2QqtW *) x));
}
static void *_p_Pythia8__Sigma0AB2AXBTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma0Process *) ((Pythia8::Sigma0AB2AXB *) x));
}
static void *_p_Pythia8__Sigma2QCqq2qqTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2QCqq2qq *) x));
}
static void *_p_Pythia8__Sigma2qqbar2charchi0To_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *)(Pythia8::Sigma2SUSY *)(Pythia8::Sigma2qqbar2chi0chi0 *) ((Pythia8::Sigma2qqbar2charchi0 *) x));
}
static void *_p_Pythia8__Sigma2qq2qqTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qq2qq *) x));
}
static void *_p_Pythia8__Sigma1ffbar2gmZZprimeTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma1Process *)(Pythia8::Sigma1ffbarZprimeWprime *) ((Pythia8::Sigma1ffbar2gmZZprime *) x));
}
static void *_p_Pythia8__Sigma2gg2QQbarTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2gg2QQbar *) x));
}
static void *_p_Pythia8__Sigma2ffbar2gmZgmZTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *)(Pythia8::Sigma2ffbargmZWgmZW *) ((Pythia8::Sigma2ffbar2gmZgmZ *) x));
}
static void *_p_Pythia8__Sigma2qg2LeptoQuarklTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qg2LeptoQuarkl *) x));
}
static void *_p_Pythia8__Sigma0AB2AXTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma0Process *) ((Pythia8::Sigma0AB2AX *) x));
}
static void *_p_Pythia8__Sigma2ffbar2ZpHTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2ffbar2ZpH *) x));
}
static void *_p_Pythia8__Sigma1ql2LeptoQuarkTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma1Process *) ((Pythia8::Sigma1ql2LeptoQuark *) x));
}
static void *_p_Pythia8__Sigma3qg2qqqbarDiffTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma3Process *)(Pythia8::Sigma3qq2qqgDiff *) ((Pythia8::Sigma3qg2qqqbarDiff *) x));
}
static void *_p_Pythia8__Sigma2ffbar2TEVffbarTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2ffbar2TEVffbar *) x));
}
static void *_p_Pythia8__Sigma2qqbar2ggammaTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qqbar2ggamma *) x));
}
static void *_p_Pythia8__Sigma2gg2ggammaTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2gg2ggamma *) x));
}
static void *_p_Pythia8__Sigma2SUSYTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2SUSY *) x));
}
static void *_p_Pythia8__Sigma3qqbar2qqbargDiffTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma3Process *)(Pythia8::Sigma3qq2qqgDiff *) ((Pythia8::Sigma3qqbar2qqbargDiff *) x));
}
static void *_p_Pythia8__Sigma2ffbar2HchgH12To_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2ffbar2HchgH12 *) x));
}
static void *_p_Pythia8__Sigma2qg2charsquarkTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *)(Pythia8::Sigma2qg2chi0squark *) ((Pythia8::Sigma2qg2charsquark *) x));
}
static void *_p_Pythia8__Sigma2qg2chi0squarkTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qg2chi0squark *) x));
}
static void *_p_Pythia8__Sigma2fgm2WfTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *)(Pythia8::Sigma2ffbarWggm *) ((Pythia8::Sigma2fgm2Wf *) x));
}
static void *_p_Pythia8__Sigma3ff2HfftWWTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma3Process *) ((Pythia8::Sigma3ff2HfftWW *) x));
}
static void *_p_Pythia8__Sigma2ffbar2HposHnegTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2ffbar2HposHneg *) x));
}
static void *_p_Pythia8__Sigma3qqbar2gggTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma3Process *) ((Pythia8::Sigma3qqbar2ggg *) x));
}
static void *_p_Pythia8__Sigma2ff2fftWTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2ff2fftW *) x));
}
static void *_p_Pythia8__Sigma2qg2Zpq2XXjTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *)(Pythia8::Sigma2qqbar2Zpg2XXj *) ((Pythia8::Sigma2qg2Zpq2XXj *) x));
}
static void *_p_Pythia8__Sigma2qqbar2QQbarTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qqbar2QQbar *) x));
}
static void *_p_Pythia8__Sigma2qg2HqltTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qg2Hqlt *) x));
}
static void *_p_Pythia8__Sigma2qg2qgammaTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2qg2qgamma *) x));
}
static void *_p_Pythia8__Sigma2qqbar2QQbarX8gTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *)(Pythia8::Sigma2gg2QQbarX8g *) ((Pythia8::Sigma2qqbar2QQbarX8g *) x));
}
static void *_p_Pythia8__Sigma2gg2QQbarX8gTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma2Process *) ((Pythia8::Sigma2gg2QQbarX8g *) x));
}
static void *_p_Pythia8__Sigma1gg2HTo_p_Pythia8__SigmaProcess(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaProcess *) (Pythia8::Sigma1Process *) ((Pythia8::Sigma1gg2H *) x));
}
static void *_p_Pythia8__Sigma2qqbar2QQbarX8gTo_p_Pythia8__Sigma2gg2QQbarX8g(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2gg2QQbarX8g *)  ((Pythia8::Sigma2qqbar2QQbarX8g *) x));
}
static void *_p_Pythia8__Sigma2qg2QQbarX8qTo_p_Pythia8__Sigma2gg2QQbarX8g(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2gg2QQbarX8g *)  ((Pythia8::Sigma2qg2QQbarX8q *) x));
}
static void *_p_Pythia8__Sigma2qg2QQbar3PJ1qTo_p_Pythia8__Sigma2gg2QQbar3PJ1g(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2gg2QQbar3PJ1g *)  ((Pythia8::Sigma2qg2QQbar3PJ1q *) x));
}
static void *_p_Pythia8__Sigma2qqbar2QQbar3PJ1gTo_p_Pythia8__Sigma2gg2QQbar3PJ1g(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2gg2QQbar3PJ1g *)  ((Pythia8::Sigma2qqbar2QQbar3PJ1g *) x));
}
static void *_p_Pythia8__Sigma2gg2QQbar3DJ1gTo_p_Pythia8__Sigma2gg2QQbar3PJ1g(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2gg2QQbar3PJ1g *)  ((Pythia8::Sigma2gg2QQbar3DJ1g *) x));
}
static void *_p_Pythia8__SigmaSaSDLTo_p_Pythia8__SigmaTotAux(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaTotAux *)  ((Pythia8::SigmaSaSDL *) x));
}
static void *_p_Pythia8__SigmaTotOwnTo_p_Pythia8__SigmaTotAux(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaTotAux *)  ((Pythia8::SigmaTotOwn *) x));
}
static void *_p_Pythia8__SigmaABMSTTo_p_Pythia8__SigmaTotAux(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaTotAux *)  ((Pythia8::SigmaABMST *) x));
}
static void *_p_Pythia8__SigmaMBRTo_p_Pythia8__SigmaTotAux(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaTotAux *)  ((Pythia8::SigmaMBR *) x));
}
static void *_p_Pythia8__SigmaRPPTo_p_Pythia8__SigmaTotAux(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SigmaTotAux *)  ((Pythia8::SigmaRPP *) x));
}
static void *_p_Pythia8__WoodsSaxonModelTo_p_Pythia8__NucleusModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::NucleusModel *)  ((Pythia8::WoodsSaxonModel *) x));
}
static void *_p_Pythia8__GLISSANDOModelTo_p_Pythia8__NucleusModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::NucleusModel *) (Pythia8::WoodsSaxonModel *) ((Pythia8::GLISSANDOModel *) x));
}
static void *_p_Pythia8__NaiveSubCollisionModelTo_p_Pythia8__SubCollisionModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SubCollisionModel *)  ((Pythia8::NaiveSubCollisionModel *) x));
}
static void *_p_Pythia8__DoubleStrikmanTo_p_Pythia8__SubCollisionModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SubCollisionModel *)  ((Pythia8::DoubleStrikman *) x));
}
static void *_p_Pythia8__MultiRadialTo_p_Pythia8__SubCollisionModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SubCollisionModel *)  ((Pythia8::MultiRadial *) x));
}
static void *_p_Pythia8__GLISSANDOModelTo_p_Pythia8__WoodsSaxonModel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::WoodsSaxonModel *)  ((Pythia8::GLISSANDOModel *) x));
}
static void *_p_Pythia8__HMEW2TwoFermionsTo_p_Pythia8__HMEX2TwoFermions(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HMEX2TwoFermions *)  ((Pythia8::HMEW2TwoFermions *) x));
}
static void *_p_Pythia8__HMEGamma2TwoFermionsTo_p_Pythia8__HMEX2TwoFermions(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HMEX2TwoFermions *)  ((Pythia8::HMEGamma2TwoFermions *) x));
}
static void *_p_Pythia8__HMEZ2TwoFermionsTo_p_Pythia8__HMEX2TwoFermions(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HMEX2TwoFermions *)  ((Pythia8::HMEZ2TwoFermions *) x));
}
static void *_p_Pythia8__Sigma2qqbar2charcharTo_p_Pythia8__Sigma2qqbar2chi0chi0(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2qqbar2chi0chi0 *)  ((Pythia8::Sigma2qqbar2charchar *) x));
}
static void *_p_Pythia8__Sigma2qqbar2charchi0To_p_Pythia8__Sigma2qqbar2chi0chi0(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2qqbar2chi0chi0 *)  ((Pythia8::Sigma2qqbar2charchi0 *) x));
}
static void *_p_Pythia8__Sigma2qqbar2chargluinoTo_p_Pythia8__Sigma2qqbar2chi0gluino(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2qqbar2chi0gluino *)  ((Pythia8::Sigma2qqbar2chargluino *) x));
}
static void *_p_Pythia8__HelicityParticleTo_p_Pythia8__Particle(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Particle *)  ((Pythia8::HelicityParticle *) x));
}
static void *_p_Pythia8__ColourParticleTo_p_Pythia8__Particle(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Particle *)  ((Pythia8::ColourParticle *) x));
}
static void *_p_Pythia8__HMETau2TwoLeptonsTo_p_Pythia8__HelicityMatrixElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HelicityMatrixElement *) (Pythia8::HMETauDecay *) ((Pythia8::HMETau2TwoLeptons *) x));
}
static void *_p_Pythia8__HMETau2PhaseSpaceTo_p_Pythia8__HelicityMatrixElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HelicityMatrixElement *) (Pythia8::HMETauDecay *) ((Pythia8::HMETau2PhaseSpace *) x));
}
static void *_p_Pythia8__HMETau2ThreeMesonsTo_p_Pythia8__HelicityMatrixElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HelicityMatrixElement *) (Pythia8::HMETauDecay *) ((Pythia8::HMETau2ThreeMesons *) x));
}
static void *_p_Pythia8__HMETau2FivePionsTo_p_Pythia8__HelicityMatrixElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HelicityMatrixElement *) (Pythia8::HMETauDecay *) ((Pythia8::HMETau2FivePions *) x));
}
static void *_p_Pythia8__HMEHiggs2TwoFermionsTo_p_Pythia8__HelicityMatrixElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HelicityMatrixElement *)  ((Pythia8::HMEHiggs2TwoFermions *) x));
}
static void *_p_Pythia8__HMEZ2TwoFermionsTo_p_Pythia8__HelicityMatrixElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HelicityMatrixElement *) (Pythia8::HMEX2TwoFermions *) ((Pythia8::HMEZ2TwoFermions *) x));
}
static void *_p_Pythia8__HMEGamma2TwoFermionsTo_p_Pythia8__HelicityMatrixElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HelicityMatrixElement *) (Pythia8::HMEX2TwoFermions *) ((Pythia8::HMEGamma2TwoFermions *) x));
}
static void *_p_Pythia8__HMEW2TwoFermionsTo_p_Pythia8__HelicityMatrixElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HelicityMatrixElement *) (Pythia8::HMEX2TwoFermions *) ((Pythia8::HMEW2TwoFermions *) x));
}
static void *_p_Pythia8__HMEX2TwoFermionsTo_p_Pythia8__HelicityMatrixElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HelicityMatrixElement *)  ((Pythia8::HMEX2TwoFermions *) x));
}
static void *_p_Pythia8__HMETwoFermions2GammaZ2TwoFermionsTo_p_Pythia8__HelicityMatrixElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HelicityMatrixElement *)  ((Pythia8::HMETwoFermions2GammaZ2TwoFermions *) x));
}
static void *_p_Pythia8__HMETwoFermions2W2TwoFermionsTo_p_Pythia8__HelicityMatrixElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HelicityMatrixElement *)  ((Pythia8::HMETwoFermions2W2TwoFermions *) x));
}
static void *_p_Pythia8__HMETau2ThreePionsTo_p_Pythia8__HelicityMatrixElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HelicityMatrixElement *) (Pythia8::HMETauDecay *)(Pythia8::HMETau2ThreeMesons *) ((Pythia8::HMETau2ThreePions *) x));
}
static void *_p_Pythia8__HMETau2TwoMesonsViaVectorScalarTo_p_Pythia8__HelicityMatrixElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HelicityMatrixElement *) (Pythia8::HMETauDecay *) ((Pythia8::HMETau2TwoMesonsViaVectorScalar *) x));
}
static void *_p_Pythia8__HMETau2MesonTo_p_Pythia8__HelicityMatrixElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HelicityMatrixElement *) (Pythia8::HMETauDecay *) ((Pythia8::HMETau2Meson *) x));
}
static void *_p_Pythia8__HMETau2ThreeMesonsWithKaonsTo_p_Pythia8__HelicityMatrixElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HelicityMatrixElement *) (Pythia8::HMETauDecay *)(Pythia8::HMETau2ThreeMesons *) ((Pythia8::HMETau2ThreeMesonsWithKaons *) x));
}
static void *_p_Pythia8__HMETau2TwoPionsGammaTo_p_Pythia8__HelicityMatrixElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HelicityMatrixElement *) (Pythia8::HMETauDecay *) ((Pythia8::HMETau2TwoPionsGamma *) x));
}
static void *_p_Pythia8__HMETau2TwoMesonsViaVectorTo_p_Pythia8__HelicityMatrixElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HelicityMatrixElement *) (Pythia8::HMETauDecay *) ((Pythia8::HMETau2TwoMesonsViaVector *) x));
}
static void *_p_Pythia8__HMETau2ThreeMesonsGenericTo_p_Pythia8__HelicityMatrixElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HelicityMatrixElement *) (Pythia8::HMETauDecay *)(Pythia8::HMETau2ThreeMesons *) ((Pythia8::HMETau2ThreeMesonsGeneric *) x));
}
static void *_p_Pythia8__HMETauDecayTo_p_Pythia8__HelicityMatrixElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HelicityMatrixElement *)  ((Pythia8::HMETauDecay *) x));
}
static void *_p_Pythia8__HMETau2FourPionsTo_p_Pythia8__HelicityMatrixElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HelicityMatrixElement *) (Pythia8::HMETauDecay *) ((Pythia8::HMETau2FourPions *) x));
}
static void *_p_Pythia8__HJSlowJetTo_p_Pythia8__SlowJet(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SlowJet *)  ((Pythia8::HJSlowJet *) x));
}
static void *_p_Pythia8__Sigma2qg2gmZqTo_p_Pythia8__Sigma2ffbargmZggm(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2ffbargmZggm *)  ((Pythia8::Sigma2qg2gmZq *) x));
}
static void *_p_Pythia8__Sigma2fgm2gmZfTo_p_Pythia8__Sigma2ffbargmZggm(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2ffbargmZggm *)  ((Pythia8::Sigma2fgm2gmZf *) x));
}
static void *_p_Pythia8__Sigma2qqbar2gmZgTo_p_Pythia8__Sigma2ffbargmZggm(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2ffbargmZggm *)  ((Pythia8::Sigma2qqbar2gmZg *) x));
}
static void *_p_Pythia8__Sigma2ffbar2gmZgmTo_p_Pythia8__Sigma2ffbargmZggm(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2ffbargmZggm *)  ((Pythia8::Sigma2ffbar2gmZgm *) x));
}
static void *_p_Pythia8__Sigma1ffbar2gmZZprimeTo_p_Pythia8__Sigma1ffbarZprimeWprime(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma1ffbarZprimeWprime *)  ((Pythia8::Sigma1ffbar2gmZZprime *) x));
}
static void *_p_Pythia8__Sigma1ffbar2WprimeTo_p_Pythia8__Sigma1ffbarZprimeWprime(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma1ffbarZprimeWprime *)  ((Pythia8::Sigma1ffbar2Wprime *) x));
}
static void *_p_Pythia8__CoupSUSYTo_p_Pythia8__Couplings(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Couplings *)  ((Pythia8::CoupSUSY *) x));
}
static void *_p_Pythia8__Sigma3qqbar2qqbargSameTo_p_Pythia8__Sigma3qq2qqgSame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma3qq2qqgSame *)  ((Pythia8::Sigma3qqbar2qqbargSame *) x));
}
static void *_p_Pythia8__Sigma3qg2qqqbarSameTo_p_Pythia8__Sigma3qq2qqgSame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma3qq2qqgSame *)  ((Pythia8::Sigma3qg2qqqbarSame *) x));
}
static void *_p_Pythia8__Sigma2ffbar2ZWTo_p_Pythia8__Sigma2ffbargmZWgmZW(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2ffbargmZWgmZW *)  ((Pythia8::Sigma2ffbar2ZW *) x));
}
static void *_p_Pythia8__Sigma2ffbar2gmZgmZTo_p_Pythia8__Sigma2ffbargmZWgmZW(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2ffbargmZWgmZW *)  ((Pythia8::Sigma2ffbar2gmZgmZ *) x));
}
static void *_p_Pythia8__Sigma2ffbar2WWTo_p_Pythia8__Sigma2ffbargmZWgmZW(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2ffbargmZWgmZW *)  ((Pythia8::Sigma2ffbar2WW *) x));
}
static void *_p_Pythia8__JetMatchingAlpgenInputAlpgenTo_p_Pythia8__JetMatchingAlpgen(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::JetMatchingAlpgen *)  ((Pythia8::JetMatchingAlpgenInputAlpgen *) x));
}
static void *_p_Pythia8__CTEQ6pdfTo_p_Pythia8__PDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PDF *)  ((Pythia8::CTEQ6pdf *) x));
}
static void *_p_Pythia8__GRVpiLTo_p_Pythia8__PDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PDF *)  ((Pythia8::GRVpiL *) x));
}
static void *_p_Pythia8__IsospinTo_p_Pythia8__PDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PDF *) (Pythia8::nPDF *) ((Pythia8::Isospin *) x));
}
static void *_p_Pythia8__LHAGrid1To_p_Pythia8__PDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PDF *)  ((Pythia8::LHAGrid1 *) x));
}
static void *_p_Pythia8__NeutrinoPointTo_p_Pythia8__PDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PDF *)  ((Pythia8::NeutrinoPoint *) x));
}
static void *_p_Pythia8__EPPS16To_p_Pythia8__PDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PDF *) (Pythia8::nPDF *) ((Pythia8::EPPS16 *) x));
}
static void *_p_Pythia8__PomFixTo_p_Pythia8__PDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PDF *)  ((Pythia8::PomFix *) x));
}
static void *_p_Pythia8__CTEQ5LTo_p_Pythia8__PDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PDF *)  ((Pythia8::CTEQ5L *) x));
}
static void *_p_Pythia8__LeptonPointTo_p_Pythia8__PDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PDF *)  ((Pythia8::LeptonPoint *) x));
}
static void *_p_Pythia8__ProtonPointTo_p_Pythia8__PDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PDF *)  ((Pythia8::ProtonPoint *) x));
}
static void *_p_Pythia8__GRV94LTo_p_Pythia8__PDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PDF *)  ((Pythia8::GRV94L *) x));
}
static void *_p_Pythia8__EPAexternalTo_p_Pythia8__PDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PDF *)  ((Pythia8::EPAexternal *) x));
}
static void *_p_Pythia8__EPS09To_p_Pythia8__PDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PDF *) (Pythia8::nPDF *) ((Pythia8::EPS09 *) x));
}
static void *_p_Pythia8__LeptonTo_p_Pythia8__PDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PDF *)  ((Pythia8::Lepton *) x));
}
static void *_p_Pythia8__NNPDFTo_p_Pythia8__PDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PDF *)  ((Pythia8::NNPDF *) x));
}
static void *_p_Pythia8__LHAPDFTo_p_Pythia8__PDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PDF *)  ((Pythia8::LHAPDF *) x));
}
static void *_p_Pythia8__nPDFTo_p_Pythia8__PDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PDF *)  ((Pythia8::nPDF *) x));
}
static void *_p_Pythia8__MSTWpdfTo_p_Pythia8__PDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PDF *)  ((Pythia8::MSTWpdf *) x));
}
static void *_p_Pythia8__Lepton2gammaTo_p_Pythia8__PDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PDF *)  ((Pythia8::Lepton2gamma *) x));
}
static void *_p_Pythia8__PomH1FitABTo_p_Pythia8__PDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PDF *)  ((Pythia8::PomH1FitAB *) x));
}
static void *_p_Pythia8__GammaPointTo_p_Pythia8__PDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PDF *)  ((Pythia8::GammaPoint *) x));
}
static void *_p_Pythia8__PomHISASDTo_p_Pythia8__PDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PDF *)  ((Pythia8::PomHISASD *) x));
}
static void *_p_Pythia8__PomH1JetsTo_p_Pythia8__PDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PDF *)  ((Pythia8::PomH1Jets *) x));
}
static void *_p_Pythia8__CJKLTo_p_Pythia8__PDF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PDF *)  ((Pythia8::CJKL *) x));
}
static void *_p_f_r_std__ios_base__r_std__basic_ostreamT_char_std__char_traitsT_char_t_tTo_p_f_r_std__ios_base__r_std__ios_base(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::ios_base &(*)(std::ios_base &)) (std::basic_ios< char > *) ((std::basic_ostream< char,std::char_traits< char > > &(*)(std::ios_base &)) x));
}
static void *_p_f_r_std__ios_base__r_std__basic_istreamT_char_std__char_traitsT_char_t_tTo_p_f_r_std__ios_base__r_std__ios_base(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::ios_base &(*)(std::ios_base &)) (std::basic_ios< char > *) ((std::basic_istream< char,std::char_traits< char > > &(*)(std::ios_base &)) x));
}
static void *_p_f_r_std__ios_base__r_std__basic_iostreamT_char_std__char_traitsT_char_t_tTo_p_f_r_std__ios_base__r_std__ios_base(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::ios_base &(*)(std::ios_base &)) (std::basic_ios< char > *)(std::basic_istream< char > *) ((std::basic_iostream< char,std::char_traits< char > > &(*)(std::ios_base &)) x));
}
static void *_p_f_r_std__ios_base__r_std__basic_iosT_char_std__char_traitsT_char_t_tTo_p_f_r_std__ios_base__r_std__ios_base(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::ios_base &(*)(std::ios_base &))  ((std::basic_ios< char,std::char_traits< char > > &(*)(std::ios_base &)) x));
}
static void *_p_f_r_std__ios_base__r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_f_r_std__ios_base__r_std__ios_base(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::ios_base &(*)(std::ios_base &)) (std::basic_ios< char > *)(std::basic_istream< char > *) ((std::basic_istringstream< char,std::char_traits< char >,std::allocator< char > > &(*)(std::ios_base &)) x));
}
static void *_p_f_r_std__ios_base__r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_f_r_std__ios_base__r_std__ios_base(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::ios_base &(*)(std::ios_base &)) (std::basic_ios< char > *)(std::basic_ostream< char > *) ((std::basic_ostringstream< char,std::char_traits< char >,std::allocator< char > > &(*)(std::ios_base &)) x));
}
static void *_p_f_r_std__ios_base__r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_f_r_std__ios_base__r_std__ios_base(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::ios_base &(*)(std::ios_base &)) (std::basic_ios< char > *)(std::basic_istream< char > *)(std::basic_iostream< char > *) ((std::basic_stringstream< char,std::char_traits< char >,std::allocator< char > > &(*)(std::ios_base &)) x));
}
static void *_p_std__basic_ostreamT_char_std__char_traitsT_char_t_tTo_p_std__ios_base(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::ios_base *) (std::basic_ios< char > *) ((std::basic_ostream< char,std::char_traits< char > > *) x));
}
static void *_p_std__basic_istreamT_char_std__char_traitsT_char_t_tTo_p_std__ios_base(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::ios_base *) (std::basic_ios< char > *) ((std::basic_istream< char,std::char_traits< char > > *) x));
}
static void *_p_std__basic_iostreamT_char_std__char_traitsT_char_t_tTo_p_std__ios_base(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::ios_base *) (std::basic_ios< char > *)(std::basic_istream< char > *) ((std::basic_iostream< char,std::char_traits< char > > *) x));
}
static void *_p_std__basic_iosT_char_std__char_traitsT_char_t_tTo_p_std__ios_base(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::ios_base *)  ((std::basic_ios< char,std::char_traits< char > > *) x));
}
static void *_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_std__ios_base(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::ios_base *) (std::basic_ios< char > *)(std::basic_istream< char > *) ((std::basic_istringstream< char,std::char_traits< char >,std::allocator< char > > *) x));
}
static void *_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_std__ios_base(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::ios_base *) (std::basic_ios< char > *)(std::basic_ostream< char > *) ((std::basic_ostringstream< char,std::char_traits< char >,std::allocator< char > > *) x));
}
static void *_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_std__ios_base(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::ios_base *) (std::basic_ios< char > *)(std::basic_istream< char > *)(std::basic_iostream< char > *) ((std::basic_stringstream< char,std::char_traits< char >,std::allocator< char > > *) x));
}
static void *_p_std__basic_ostreamT_char_std__char_traitsT_char_t_tTo_p_std__basic_iosT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_ios< char,std::char_traits< char > > *)  ((std::basic_ostream< char,std::char_traits< char > > *) x));
}
static void *_p_std__basic_istreamT_char_std__char_traitsT_char_t_tTo_p_std__basic_iosT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_ios< char,std::char_traits< char > > *)  ((std::basic_istream< char,std::char_traits< char > > *) x));
}
static void *_p_std__basic_iostreamT_char_std__char_traitsT_char_t_tTo_p_std__basic_iosT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_ios< char,std::char_traits< char > > *) (std::basic_istream< char > *) ((std::basic_iostream< char,std::char_traits< char > > *) x));
}
static void *_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_std__basic_iosT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_ios< char,std::char_traits< char > > *) (std::basic_istream< char > *) ((std::basic_istringstream< char,std::char_traits< char >,std::allocator< char > > *) x));
}
static void *_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_std__basic_iosT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_ios< char,std::char_traits< char > > *) (std::basic_ostream< char > *) ((std::basic_ostringstream< char,std::char_traits< char >,std::allocator< char > > *) x));
}
static void *_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_std__basic_iosT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_ios< char,std::char_traits< char > > *) (std::basic_istream< char > *)(std::basic_iostream< char > *) ((std::basic_stringstream< char,std::char_traits< char >,std::allocator< char > > *) x));
}
static void *_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_std__basic_iostreamT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_iostream< char,std::char_traits< char > > *)  ((std::basic_stringstream< char,std::char_traits< char >,std::allocator< char > > *) x));
}
static void *_p_Pythia8__Sigma2qg2charsquarkTo_p_Pythia8__Sigma2qg2chi0squark(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2qg2chi0squark *)  ((Pythia8::Sigma2qg2charsquark *) x));
}
static void *_p_Pythia8__HMETau2ThreePionsTo_p_Pythia8__HMETau2ThreeMesons(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HMETau2ThreeMesons *)  ((Pythia8::HMETau2ThreePions *) x));
}
static void *_p_Pythia8__HMETau2ThreeMesonsWithKaonsTo_p_Pythia8__HMETau2ThreeMesons(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HMETau2ThreeMesons *)  ((Pythia8::HMETau2ThreeMesonsWithKaons *) x));
}
static void *_p_Pythia8__HMETau2ThreeMesonsGenericTo_p_Pythia8__HMETau2ThreeMesons(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::HMETau2ThreeMesons *)  ((Pythia8::HMETau2ThreeMesonsGeneric *) x));
}
static void *_p_Pythia8__Sigma2qqbar2charcharTo_p_Pythia8__Sigma2SUSY(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2SUSY *) (Pythia8::Sigma2qqbar2chi0chi0 *) ((Pythia8::Sigma2qqbar2charchar *) x));
}
static void *_p_Pythia8__Sigma2qqbar2charchi0To_p_Pythia8__Sigma2SUSY(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2SUSY *) (Pythia8::Sigma2qqbar2chi0chi0 *) ((Pythia8::Sigma2qqbar2charchi0 *) x));
}
static void *_p_Pythia8__Sigma2qqbar2chi0gluinoTo_p_Pythia8__Sigma2SUSY(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2SUSY *)  ((Pythia8::Sigma2qqbar2chi0gluino *) x));
}
static void *_p_Pythia8__Sigma2qqbar2chargluinoTo_p_Pythia8__Sigma2SUSY(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2SUSY *) (Pythia8::Sigma2qqbar2chi0gluino *) ((Pythia8::Sigma2qqbar2chargluino *) x));
}
static void *_p_Pythia8__Sigma2qqbar2chi0chi0To_p_Pythia8__Sigma2SUSY(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2SUSY *)  ((Pythia8::Sigma2qqbar2chi0chi0 *) x));
}
static void *_p_Pythia8__HVStringFlavTo_p_Pythia8__StringFlav(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::StringFlav *)  ((Pythia8::HVStringFlav *) x));
}
static void *_p_Pythia8__Sigma2qqbar2WgTo_p_Pythia8__Sigma2ffbarWggm(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2ffbarWggm *)  ((Pythia8::Sigma2qqbar2Wg *) x));
}
static void *_p_Pythia8__Sigma2ffbar2WgmTo_p_Pythia8__Sigma2ffbarWggm(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2ffbarWggm *)  ((Pythia8::Sigma2ffbar2Wgm *) x));
}
static void *_p_Pythia8__Sigma2qg2WqTo_p_Pythia8__Sigma2ffbarWggm(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2ffbarWggm *)  ((Pythia8::Sigma2qg2Wq *) x));
}
static void *_p_Pythia8__Sigma2fgm2WfTo_p_Pythia8__Sigma2ffbarWggm(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2ffbarWggm *)  ((Pythia8::Sigma2fgm2Wf *) x));
}
static void *_p_Pythia8__Sigma2qqbar2sleptonantisleptonTo_p_Pythia8__Sigma2qqbar2squarkantisquark(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2qqbar2squarkantisquark *)  ((Pythia8::Sigma2qqbar2sleptonantislepton *) x));
}
static void *_p_Pythia8__PhaseSpace2to2tauyzTo_p_Pythia8__PhaseSpace(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PhaseSpace *)  ((Pythia8::PhaseSpace2to2tauyz *) x));
}
static void *_p_Pythia8__PhaseSpace2to2nondiffractiveGammaTo_p_Pythia8__PhaseSpace(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PhaseSpace *)  ((Pythia8::PhaseSpace2to2nondiffractiveGamma *) x));
}
static void *_p_Pythia8__PhaseSpace2to2diffractiveTo_p_Pythia8__PhaseSpace(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PhaseSpace *)  ((Pythia8::PhaseSpace2to2diffractive *) x));
}
static void *_p_Pythia8__PhaseSpace2to3diffractiveTo_p_Pythia8__PhaseSpace(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PhaseSpace *)  ((Pythia8::PhaseSpace2to3diffractive *) x));
}
static void *_p_Pythia8__PhaseSpace2to2nondiffractiveTo_p_Pythia8__PhaseSpace(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PhaseSpace *)  ((Pythia8::PhaseSpace2to2nondiffractive *) x));
}
static void *_p_Pythia8__PhaseSpace2to3tauycylTo_p_Pythia8__PhaseSpace(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PhaseSpace *)  ((Pythia8::PhaseSpace2to3tauycyl *) x));
}
static void *_p_Pythia8__PhaseSpace2to3yyycylTo_p_Pythia8__PhaseSpace(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PhaseSpace *)  ((Pythia8::PhaseSpace2to3yyycyl *) x));
}
static void *_p_Pythia8__PhaseSpace2to2elasticTo_p_Pythia8__PhaseSpace(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PhaseSpace *)  ((Pythia8::PhaseSpace2to2elastic *) x));
}
static void *_p_Pythia8__PhaseSpaceLHATo_p_Pythia8__PhaseSpace(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PhaseSpace *)  ((Pythia8::PhaseSpaceLHA *) x));
}
static void *_p_Pythia8__PhaseSpace2to1tauyTo_p_Pythia8__PhaseSpace(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::PhaseSpace *)  ((Pythia8::PhaseSpace2to1tauy *) x));
}
static void *_p_std__basic_iostreamT_char_std__char_traitsT_char_t_tTo_p_std__basic_istreamT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_istream< char,std::char_traits< char > > *)  ((std::basic_iostream< char,std::char_traits< char > > *) x));
}
static void *_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_std__basic_istreamT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_istream< char,std::char_traits< char > > *)  ((std::basic_istringstream< char,std::char_traits< char >,std::allocator< char > > *) x));
}
static void *_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_std__basic_istreamT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_istream< char,std::char_traits< char > > *) (std::basic_iostream< char > *) ((std::basic_stringstream< char,std::char_traits< char >,std::allocator< char > > *) x));
}
static void *_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_tTo_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_ios< char,std::char_traits< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &))  ((std::basic_ostream< char,std::char_traits< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &)) x));
}
static void *_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_tTo_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_ios< char,std::char_traits< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &))  ((std::basic_istream< char,std::char_traits< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &)) x));
}
static void *_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_tTo_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_ios< char,std::char_traits< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &)) (std::basic_istream< char > *) ((std::basic_iostream< char,std::char_traits< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &)) x));
}
static void *_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_ios< char,std::char_traits< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &)) (std::basic_istream< char > *) ((std::basic_istringstream< char,std::char_traits< char >,std::allocator< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &)) x));
}
static void *_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_ios< char,std::char_traits< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &)) (std::basic_ostream< char > *) ((std::basic_ostringstream< char,std::char_traits< char >,std::allocator< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &)) x));
}
static void *_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_ios< char,std::char_traits< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &)) (std::basic_istream< char > *)(std::basic_iostream< char > *) ((std::basic_stringstream< char,std::char_traits< char >,std::allocator< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &)) x));
}
static void *_p_std__basic_iostreamT_char_std__char_traitsT_char_t_tTo_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_ostream< char,std::char_traits< char > > *)  ((std::basic_iostream< char,std::char_traits< char > > *) x));
}
static void *_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_ostream< char,std::char_traits< char > > *)  ((std::basic_ostringstream< char,std::char_traits< char >,std::allocator< char > > *) x));
}
static void *_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_ostream< char,std::char_traits< char > > *) (std::basic_iostream< char > *) ((std::basic_stringstream< char,std::char_traits< char >,std::allocator< char > > *) x));
}
static void *_p_Pythia8__LHAupHelaconiaTo_p_Pythia8__LHAup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::LHAup *)  ((Pythia8::LHAupHelaconia *) x));
}
static void *_p_Pythia8__LHAupFromPYTHIA8To_p_Pythia8__LHAup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::LHAup *)  ((Pythia8::LHAupFromPYTHIA8 *) x));
}
static void *_p_Pythia8__LHAupLHEFTo_p_Pythia8__LHAup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::LHAup *)  ((Pythia8::LHAupLHEF *) x));
}
static void *_p_Pythia8__LHEF3FromPythia8To_p_Pythia8__LHAup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::LHAup *)  ((Pythia8::LHEF3FromPythia8 *) x));
}
static void *_p_Pythia8__LHAupAlpgenTo_p_Pythia8__LHAup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::LHAup *)  ((Pythia8::LHAupAlpgen *) x));
}
static void *_p_Pythia8__LHAupMadgraphTo_p_Pythia8__LHAup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::LHAup *)  ((Pythia8::LHAupMadgraph *) x));
}
static void *_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_tTo_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_istream< char,std::char_traits< char > > &(*)(std::basic_istream< char,std::char_traits< char > > &))  ((std::basic_iostream< char,std::char_traits< char > > &(*)(std::basic_istream< char,std::char_traits< char > > &)) x));
}
static void *_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_istream< char,std::char_traits< char > > &(*)(std::basic_istream< char,std::char_traits< char > > &))  ((std::basic_istringstream< char,std::char_traits< char >,std::allocator< char > > &(*)(std::basic_istream< char,std::char_traits< char > > &)) x));
}
static void *_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_istream< char,std::char_traits< char > > &(*)(std::basic_istream< char,std::char_traits< char > > &)) (std::basic_iostream< char > *) ((std::basic_stringstream< char,std::char_traits< char >,std::allocator< char > > &(*)(std::basic_istream< char,std::char_traits< char > > &)) x));
}
static void *_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_tTo_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_ostream< char,std::char_traits< char > > &(*)(std::basic_ostream< char,std::char_traits< char > > &))  ((std::basic_iostream< char,std::char_traits< char > > &(*)(std::basic_ostream< char,std::char_traits< char > > &)) x));
}
static void *_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_ostream< char,std::char_traits< char > > &(*)(std::basic_ostream< char,std::char_traits< char > > &))  ((std::basic_ostringstream< char,std::char_traits< char >,std::allocator< char > > &(*)(std::basic_ostream< char,std::char_traits< char > > &)) x));
}
static void *_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_ostream< char,std::char_traits< char > > &(*)(std::basic_ostream< char,std::char_traits< char > > &)) (std::basic_iostream< char > *) ((std::basic_stringstream< char,std::char_traits< char >,std::allocator< char > > &(*)(std::basic_ostream< char,std::char_traits< char > > &)) x));
}
static void *_p_Pythia8__HVStringZTo_p_Pythia8__StringZ(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::StringZ *)  ((Pythia8::HVStringZ *) x));
}
static void *_p_Pythia8__HVStringPTTo_p_Pythia8__StringPT(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::StringPT *)  ((Pythia8::HVStringPT *) x));
}
static void *_p_p_std__basic_iostreamT_char_std__char_traitsT_char_t_tTo_p_p_std__basic_istreamT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_istream< char,std::char_traits< char > > **)  ((std::basic_iostream< char,std::char_traits< char > > **) x));
}
static void *_p_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_p_std__basic_istreamT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_istream< char,std::char_traits< char > > **)  ((std::basic_istringstream< char,std::char_traits< char >,std::allocator< char > > **) x));
}
static void *_p_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_p_std__basic_istreamT_char_std__char_traitsT_char_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::basic_istream< char,std::char_traits< char > > **) (std::basic_iostream< char > *) ((std::basic_stringstream< char,std::char_traits< char >,std::allocator< char > > **) x));
}
static void *_p_Pythia8__ResonanceSquarkTo_p_Pythia8__SUSYResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SUSYResonanceWidths *)  ((Pythia8::ResonanceSquark *) x));
}
static void *_p_Pythia8__ResonanceNeutTo_p_Pythia8__SUSYResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SUSYResonanceWidths *)  ((Pythia8::ResonanceNeut *) x));
}
static void *_p_Pythia8__ResonanceGluinoTo_p_Pythia8__SUSYResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SUSYResonanceWidths *)  ((Pythia8::ResonanceGluino *) x));
}
static void *_p_Pythia8__ResonanceSleptonTo_p_Pythia8__SUSYResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SUSYResonanceWidths *)  ((Pythia8::ResonanceSlepton *) x));
}
static void *_p_Pythia8__ResonanceCharTo_p_Pythia8__SUSYResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::SUSYResonanceWidths *)  ((Pythia8::ResonanceChar *) x));
}
static void *_p_Pythia8__ResonanceRhorizontalTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *)  ((Pythia8::ResonanceRhorizontal *) x));
}
static void *_p_Pythia8__ResonanceSquarkTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *) (Pythia8::SUSYResonanceWidths *) ((Pythia8::ResonanceSquark *) x));
}
static void *_p_Pythia8__ResonanceWprimeTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *)  ((Pythia8::ResonanceWprime *) x));
}
static void *_p_Pythia8__ResonanceWRightTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *)  ((Pythia8::ResonanceWRight *) x));
}
static void *_p_Pythia8__SUSYResonanceWidthsTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *)  ((Pythia8::SUSYResonanceWidths *) x));
}
static void *_p_Pythia8__ResonanceKKgluonTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *)  ((Pythia8::ResonanceKKgluon *) x));
}
static void *_p_Pythia8__ResonanceHchgchgRightTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *)  ((Pythia8::ResonanceHchgchgRight *) x));
}
static void *_p_Pythia8__ResonanceGravitonTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *)  ((Pythia8::ResonanceGraviton *) x));
}
static void *_p_Pythia8__ResonanceFourTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *)  ((Pythia8::ResonanceFour *) x));
}
static void *_p_Pythia8__ResonanceNeutTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *) (Pythia8::SUSYResonanceWidths *) ((Pythia8::ResonanceNeut *) x));
}
static void *_p_Pythia8__ResonanceZprimeTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *)  ((Pythia8::ResonanceZprime *) x));
}
static void *_p_Pythia8__ResonanceHchgTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *)  ((Pythia8::ResonanceHchg *) x));
}
static void *_p_Pythia8__ResonanceZRightTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *)  ((Pythia8::ResonanceZRight *) x));
}
static void *_p_Pythia8__ResonanceCharTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *) (Pythia8::SUSYResonanceWidths *) ((Pythia8::ResonanceChar *) x));
}
static void *_p_Pythia8__ResonanceGmZTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *)  ((Pythia8::ResonanceGmZ *) x));
}
static void *_p_Pythia8__ResonanceSTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *)  ((Pythia8::ResonanceS *) x));
}
static void *_p_Pythia8__ResonanceGluinoTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *) (Pythia8::SUSYResonanceWidths *) ((Pythia8::ResonanceGluino *) x));
}
static void *_p_Pythia8__ResonanceSleptonTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *) (Pythia8::SUSYResonanceWidths *) ((Pythia8::ResonanceSlepton *) x));
}
static void *_p_Pythia8__ResonanceLeptoquarkTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *)  ((Pythia8::ResonanceLeptoquark *) x));
}
static void *_p_Pythia8__ResonanceTopTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *)  ((Pythia8::ResonanceTop *) x));
}
static void *_p_Pythia8__ResonanceZpTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *)  ((Pythia8::ResonanceZp *) x));
}
static void *_p_Pythia8__ResonanceWTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *)  ((Pythia8::ResonanceW *) x));
}
static void *_p_Pythia8__ResonanceHchgchgLeftTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *)  ((Pythia8::ResonanceHchgchgLeft *) x));
}
static void *_p_Pythia8__ResonanceHTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *)  ((Pythia8::ResonanceH *) x));
}
static void *_p_Pythia8__ResonanceNuRightTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *)  ((Pythia8::ResonanceNuRight *) x));
}
static void *_p_Pythia8__ResonanceExcitedTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *)  ((Pythia8::ResonanceExcited *) x));
}
static void *_p_Pythia8__ResonanceGenericTo_p_Pythia8__ResonanceWidths(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::ResonanceWidths *)  ((Pythia8::ResonanceGeneric *) x));
}
static void *_p_Pythia8__JetMatchingAlpgenTo_p_Pythia8__JetMatching(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::JetMatching *)  ((Pythia8::JetMatchingAlpgen *) x));
}
static void *_p_Pythia8__JetMatchingMadgraphTo_p_Pythia8__JetMatching(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::JetMatching *)  ((Pythia8::JetMatchingMadgraph *) x));
}
static void *_p_Pythia8__JetMatchingAlpgenInputAlpgenTo_p_Pythia8__JetMatching(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::JetMatching *) (Pythia8::JetMatchingAlpgen *) ((Pythia8::JetMatchingAlpgenInputAlpgen *) x));
}
static void *_p_Pythia8__JetMatchingMadgraphInputAlpgenTo_p_Pythia8__JetMatching(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::JetMatching *) (Pythia8::JetMatchingMadgraph *) ((Pythia8::JetMatchingMadgraphInputAlpgen *) x));
}
static void *_p_Pythia8__Sigma2qg2Zpq2XXjTo_p_Pythia8__Sigma2qqbar2Zpg2XXj(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Pythia8::Sigma2qqbar2Zpg2XXj *)  ((Pythia8::Sigma2qg2Zpq2XXj *) x));
}
static swig_type_info _swigt__p_Pythia8__AlpgenHooks = {"_p_Pythia8__AlpgenHooks", "Pythia8::AlpgenHooks *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__AlpgenPar = {"_p_Pythia8__AlpgenPar", "Pythia8::AlpgenPar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__AlphaEM = {"_p_Pythia8__AlphaEM", "Pythia8::AlphaEM *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__AlphaStrong = {"_p_Pythia8__AlphaStrong", "Pythia8::AlphaStrong *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Angantyr = {"_p_Pythia8__Angantyr", "Pythia8::Angantyr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__BeamParticle = {"_p_Pythia8__BeamParticle", "Pythia8::BeamParticle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__BeamRemnants = {"_p_Pythia8__BeamRemnants", "Pythia8::BeamRemnants *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__BeamShape = {"_p_Pythia8__BeamShape", "Pythia8::BeamShape *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__BoseEinstein = {"_p_Pythia8__BoseEinstein", "Pythia8::BoseEinstein *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__BoseEinsteinHadron = {"_p_Pythia8__BoseEinsteinHadron", "Pythia8::BoseEinsteinHadron *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__CJKL = {"_p_Pythia8__CJKL", "Pythia8::CJKL *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__CTEQ5L = {"_p_Pythia8__CTEQ5L", "Pythia8::CTEQ5L *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__CTEQ6pdf = {"_p_Pythia8__CTEQ6pdf", "Pythia8::CTEQ6pdf *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__CellJet = {"_p_Pythia8__CellJet", "Pythia8::CellJet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ClusterJet = {"_p_Pythia8__ClusterJet", "Pythia8::ClusterJet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Clustering = {"_p_Pythia8__Clustering", "std::vector< Pythia8::Clustering >::value_type *|Pythia8::Clustering *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ColConfig = {"_p_Pythia8__ColConfig", "Pythia8::ColConfig *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ColSinglet = {"_p_Pythia8__ColSinglet", "Pythia8::ColSinglet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ColourDipole = {"_p_Pythia8__ColourDipole", "Pythia8::ColourDipole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ColourJunction = {"_p_Pythia8__ColourJunction", "Pythia8::ColourJunction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ColourParticle = {"_p_Pythia8__ColourParticle", "Pythia8::ColourParticle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ColourReconnection = {"_p_Pythia8__ColourReconnection", "Pythia8::ColourReconnection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ColourTracing = {"_p_Pythia8__ColourTracing", "Pythia8::ColourTracing *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__CombineMatchingInput = {"_p_Pythia8__CombineMatchingInput", "Pythia8::CombineMatchingInput *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__CoupSM = {"_p_Pythia8__CoupSM", "Pythia8::CoupSM *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__CoupSUSY = {"_p_Pythia8__CoupSUSY", "Pythia8::CoupSUSY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Couplings = {"_p_Pythia8__Couplings", "Pythia8::Couplings *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__DecayChannel = {"_p_Pythia8__DecayChannel", "Pythia8::DecayChannel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__DecayHandler = {"_p_Pythia8__DecayHandler", "Pythia8::DecayHandler *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__DoubleStrikman = {"_p_Pythia8__DoubleStrikman", "Pythia8::DoubleStrikman *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__DummyForStreams = {"_p_Pythia8__DummyForStreams", "Pythia8::DummyForStreams *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__EPAexternal = {"_p_Pythia8__EPAexternal", "Pythia8::EPAexternal *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__EPPS16 = {"_p_Pythia8__EPPS16", "Pythia8::EPPS16 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__EPS09 = {"_p_Pythia8__EPS09", "Pythia8::EPS09 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Event = {"_p_Pythia8__Event", "Pythia8::Event *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__EventInfo = {"_p_Pythia8__EventInfo", "Pythia8::EventInfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__FVec = {"_p_Pythia8__FVec", "std::map< std::string,Pythia8::FVec >::mapped_type *|Pythia8::FVec *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Flag = {"_p_Pythia8__Flag", "Pythia8::Flag *|std::map< std::string,Pythia8::Flag >::mapped_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__FlavContainer = {"_p_Pythia8__FlavContainer", "Pythia8::FlavContainer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__FlavourRope = {"_p_Pythia8__FlavourRope", "Pythia8::FlavourRope *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__GLISSANDOModel = {"_p_Pythia8__GLISSANDOModel", "Pythia8::GLISSANDOModel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__GRV94L = {"_p_Pythia8__GRV94L", "Pythia8::GRV94L *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__GRVpiL = {"_p_Pythia8__GRVpiL", "Pythia8::GRVpiL *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__GammaKinematics = {"_p_Pythia8__GammaKinematics", "Pythia8::GammaKinematics *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__GammaMatrix = {"_p_Pythia8__GammaMatrix", "Pythia8::GammaMatrix *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__GammaPoint = {"_p_Pythia8__GammaPoint", "Pythia8::GammaPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HEPEUP = {"_p_Pythia8__HEPEUP", "Pythia8::HEPEUP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HEPRUP = {"_p_Pythia8__HEPRUP", "Pythia8::HEPRUP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HIInfo = {"_p_Pythia8__HIInfo", "Pythia8::HIInfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HIUserHooks = {"_p_Pythia8__HIUserHooks", "Pythia8::HIUserHooks *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HJSlowJet = {"_p_Pythia8__HJSlowJet", "Pythia8::HJSlowJet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HMEGamma2TwoFermions = {"_p_Pythia8__HMEGamma2TwoFermions", "Pythia8::HMEGamma2TwoFermions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HMEHiggs2TwoFermions = {"_p_Pythia8__HMEHiggs2TwoFermions", "Pythia8::HMEHiggs2TwoFermions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HMETau2FivePions = {"_p_Pythia8__HMETau2FivePions", "Pythia8::HMETau2FivePions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HMETau2FourPions = {"_p_Pythia8__HMETau2FourPions", "Pythia8::HMETau2FourPions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HMETau2Meson = {"_p_Pythia8__HMETau2Meson", "Pythia8::HMETau2Meson *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HMETau2PhaseSpace = {"_p_Pythia8__HMETau2PhaseSpace", "Pythia8::HMETau2PhaseSpace *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HMETau2ThreeMesons = {"_p_Pythia8__HMETau2ThreeMesons", "Pythia8::HMETau2ThreeMesons *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HMETau2ThreeMesonsGeneric = {"_p_Pythia8__HMETau2ThreeMesonsGeneric", "Pythia8::HMETau2ThreeMesonsGeneric *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HMETau2ThreeMesonsWithKaons = {"_p_Pythia8__HMETau2ThreeMesonsWithKaons", "Pythia8::HMETau2ThreeMesonsWithKaons *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HMETau2ThreePions = {"_p_Pythia8__HMETau2ThreePions", "Pythia8::HMETau2ThreePions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HMETau2TwoLeptons = {"_p_Pythia8__HMETau2TwoLeptons", "Pythia8::HMETau2TwoLeptons *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HMETau2TwoMesonsViaVector = {"_p_Pythia8__HMETau2TwoMesonsViaVector", "Pythia8::HMETau2TwoMesonsViaVector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HMETau2TwoMesonsViaVectorScalar = {"_p_Pythia8__HMETau2TwoMesonsViaVectorScalar", "Pythia8::HMETau2TwoMesonsViaVectorScalar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HMETau2TwoPionsGamma = {"_p_Pythia8__HMETau2TwoPionsGamma", "Pythia8::HMETau2TwoPionsGamma *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HMETauDecay = {"_p_Pythia8__HMETauDecay", "Pythia8::HMETauDecay *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HMETwoFermions2GammaZ2TwoFermions = {"_p_Pythia8__HMETwoFermions2GammaZ2TwoFermions", "Pythia8::HMETwoFermions2GammaZ2TwoFermions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HMETwoFermions2W2TwoFermions = {"_p_Pythia8__HMETwoFermions2W2TwoFermions", "Pythia8::HMETwoFermions2W2TwoFermions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HMEW2TwoFermions = {"_p_Pythia8__HMEW2TwoFermions", "Pythia8::HMEW2TwoFermions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HMEX2TwoFermions = {"_p_Pythia8__HMEX2TwoFermions", "Pythia8::HMEX2TwoFermions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HMEZ2TwoFermions = {"_p_Pythia8__HMEZ2TwoFermions", "Pythia8::HMEZ2TwoFermions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HVStringFlav = {"_p_Pythia8__HVStringFlav", "Pythia8::HVStringFlav *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HVStringPT = {"_p_Pythia8__HVStringPT", "Pythia8::HVStringPT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HVStringZ = {"_p_Pythia8__HVStringZ", "Pythia8::HVStringZ *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HadronLevel = {"_p_Pythia8__HadronLevel", "Pythia8::HadronLevel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HadronScatter = {"_p_Pythia8__HadronScatter", "Pythia8::HadronScatter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HadronScatterPair = {"_p_Pythia8__HadronScatterPair", "Pythia8::HadronScatterPair *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HardDiffraction = {"_p_Pythia8__HardDiffraction", "Pythia8::HardDiffraction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HardProcess = {"_p_Pythia8__HardProcess", "Pythia8::HardProcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HeavyIons = {"_p_Pythia8__HeavyIons", "Pythia8::HeavyIons *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HelicityMatrixElement = {"_p_Pythia8__HelicityMatrixElement", "Pythia8::HelicityMatrixElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HelicityParticle = {"_p_Pythia8__HelicityParticle", "std::vector< Pythia8::HelicityParticle >::value_type *|Pythia8::HelicityParticle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HiddenValleyFragmentation = {"_p_Pythia8__HiddenValleyFragmentation", "Pythia8::HiddenValleyFragmentation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Hist = {"_p_Pythia8__Hist", "Pythia8::Hist *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__HistPlot = {"_p_Pythia8__HistPlot", "Pythia8::HistPlot *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__History = {"_p_Pythia8__History", "Pythia8::History *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ImpactParameterGenerator = {"_p_Pythia8__ImpactParameterGenerator", "Pythia8::ImpactParameterGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__InBeam = {"_p_Pythia8__InBeam", "Pythia8::InBeam *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__InPair = {"_p_Pythia8__InPair", "Pythia8::InPair *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Info = {"_p_Pythia8__Info", "Pythia8::Info *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Isospin = {"_p_Pythia8__Isospin", "Pythia8::Isospin *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__JetMatching = {"_p_Pythia8__JetMatching", "Pythia8::JetMatching *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__JetMatchingAlpgen = {"_p_Pythia8__JetMatchingAlpgen", "Pythia8::JetMatchingAlpgen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__JetMatchingAlpgenInputAlpgen = {"_p_Pythia8__JetMatchingAlpgenInputAlpgen", "Pythia8::JetMatchingAlpgenInputAlpgen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__JetMatchingMadgraph = {"_p_Pythia8__JetMatchingMadgraph", "Pythia8::JetMatchingMadgraph *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__JetMatchingMadgraphInputAlpgen = {"_p_Pythia8__JetMatchingMadgraphInputAlpgen", "Pythia8::JetMatchingMadgraphInputAlpgen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Junction = {"_p_Pythia8__Junction", "Pythia8::Junction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__JunctionSplitting = {"_p_Pythia8__JunctionSplitting", "Pythia8::JunctionSplitting *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHAGrid1 = {"_p_Pythia8__LHAGrid1", "Pythia8::LHAGrid1 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHAPDF = {"_p_Pythia8__LHAPDF", "Pythia8::LHAPDF *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHAParticle = {"_p_Pythia8__LHAParticle", "Pythia8::LHAParticle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHAProcess = {"_p_Pythia8__LHAProcess", "Pythia8::LHAProcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHAgenerator = {"_p_Pythia8__LHAgenerator", "Pythia8::LHAgenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHAinitrwgt = {"_p_Pythia8__LHAinitrwgt", "Pythia8::LHAinitrwgt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHArwgt = {"_p_Pythia8__LHArwgt", "Pythia8::LHArwgt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHAscales = {"_p_Pythia8__LHAscales", "Pythia8::LHAscales *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHAup = {"_p_Pythia8__LHAup", "Pythia8::LHAup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHAupAlpgen = {"_p_Pythia8__LHAupAlpgen", "Pythia8::LHAupAlpgen *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHAupFromPYTHIA8 = {"_p_Pythia8__LHAupFromPYTHIA8", "Pythia8::LHAupFromPYTHIA8 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHAupHelaconia = {"_p_Pythia8__LHAupHelaconia", "Pythia8::LHAupHelaconia *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHAupLHEF = {"_p_Pythia8__LHAupLHEF", "Pythia8::LHAupLHEF *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHAupMadgraph = {"_p_Pythia8__LHAupMadgraph", "Pythia8::LHAupMadgraph *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHAweight = {"_p_Pythia8__LHAweight", "Pythia8::LHAweight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHAweightgroup = {"_p_Pythia8__LHAweightgroup", "Pythia8::LHAweightgroup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHAweights = {"_p_Pythia8__LHAweights", "Pythia8::LHAweights *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHAwgt = {"_p_Pythia8__LHAwgt", "Pythia8::LHAwgt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHEF3FromPythia8 = {"_p_Pythia8__LHEF3FromPythia8", "Pythia8::LHEF3FromPythia8 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHblockT_double_t = {"_p_Pythia8__LHblockT_double_t", "Pythia8::LHblock< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHblockT_int_t = {"_p_Pythia8__LHblockT_int_t", "Pythia8::LHblock< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHblockT_std__string_t = {"_p_Pythia8__LHblockT_std__string_t", "Pythia8::LHblock< std::string > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHdecayChannel = {"_p_Pythia8__LHdecayChannel", "Pythia8::LHdecayChannel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHdecayTable = {"_p_Pythia8__LHdecayTable", "Pythia8::LHdecayTable *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHgenericBlock = {"_p_Pythia8__LHgenericBlock", "Pythia8::LHgenericBlock *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHmatrixBlockT_2_t = {"_p_Pythia8__LHmatrixBlockT_2_t", "Pythia8::LHmatrixBlock< 2 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHmatrixBlockT_3_t = {"_p_Pythia8__LHmatrixBlockT_3_t", "Pythia8::LHmatrixBlock< 3 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHmatrixBlockT_4_t = {"_p_Pythia8__LHmatrixBlockT_4_t", "Pythia8::LHmatrixBlock< 4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHmatrixBlockT_5_t = {"_p_Pythia8__LHmatrixBlockT_5_t", "Pythia8::LHmatrixBlock< 5 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHmatrixBlockT_6_t = {"_p_Pythia8__LHmatrixBlockT_6_t", "Pythia8::LHmatrixBlock< 6 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHmatrixBlockT_7_t = {"_p_Pythia8__LHmatrixBlockT_7_t", "Pythia8::LHmatrixBlock< 7 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHmatrixBlockT_8_t = {"_p_Pythia8__LHmatrixBlockT_8_t", "Pythia8::LHmatrixBlock< 8 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LHtensor3BlockT_3_t = {"_p_Pythia8__LHtensor3BlockT_3_t", "Pythia8::LHtensor3Block< 3 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Lepton = {"_p_Pythia8__Lepton", "Pythia8::Lepton *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Lepton2gamma = {"_p_Pythia8__Lepton2gamma", "Pythia8::Lepton2gamma *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LeptonPoint = {"_p_Pythia8__LeptonPoint", "Pythia8::LeptonPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LundFFAvg = {"_p_Pythia8__LundFFAvg", "Pythia8::LundFFAvg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__LundFFRaw = {"_p_Pythia8__LundFFRaw", "Pythia8::LundFFRaw *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__MBReconUserHooks = {"_p_Pythia8__MBReconUserHooks", "Pythia8::MBReconUserHooks *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__MSTWpdf = {"_p_Pythia8__MSTWpdf", "Pythia8::MSTWpdf *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__MVec = {"_p_Pythia8__MVec", "std::map< std::string,Pythia8::MVec >::mapped_type *|Pythia8::MVec *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__MadgraphPar = {"_p_Pythia8__MadgraphPar", "Pythia8::MadgraphPar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Merging = {"_p_Pythia8__Merging", "Pythia8::Merging *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__MergingHooks = {"_p_Pythia8__MergingHooks", "Pythia8::MergingHooks *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__MiniStringFragmentation = {"_p_Pythia8__MiniStringFragmentation", "Pythia8::MiniStringFragmentation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Mode = {"_p_Pythia8__Mode", "std::map< std::string,Pythia8::Mode >::mapped_type *|Pythia8::Mode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__MultiRadial = {"_p_Pythia8__MultiRadial", "Pythia8::MultiRadial *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__MultipartonInteractions = {"_p_Pythia8__MultipartonInteractions", "Pythia8::MultipartonInteractions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__NNPDF = {"_p_Pythia8__NNPDF", "Pythia8::NNPDF *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__NaiveSubCollisionModel = {"_p_Pythia8__NaiveSubCollisionModel", "Pythia8::NaiveSubCollisionModel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__NeutrinoPoint = {"_p_Pythia8__NeutrinoPoint", "Pythia8::NeutrinoPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Nucleon = {"_p_Pythia8__Nucleon", "Pythia8::Nucleon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__NucleusModel = {"_p_Pythia8__NucleusModel", "Pythia8::NucleusModel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__OverlappingRopeDipole = {"_p_Pythia8__OverlappingRopeDipole", "Pythia8::OverlappingRopeDipole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__PDF = {"_p_Pythia8__PDF", "Pythia8::PDF *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__PDF__PDFEnvelope = {"_p_Pythia8__PDF__PDFEnvelope", "Pythia8::PDF::PDFEnvelope *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__PVec = {"_p_Pythia8__PVec", "std::map< std::string,Pythia8::PVec >::mapped_type *|Pythia8::PVec *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Parm = {"_p_Pythia8__Parm", "std::map< std::string,Pythia8::Parm >::mapped_type *|Pythia8::Parm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Particle = {"_p_Pythia8__Particle", "Pythia8::Particle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ParticleData = {"_p_Pythia8__ParticleData", "Pythia8::ParticleData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ParticleDataEntry = {"_p_Pythia8__ParticleDataEntry", "Pythia8::ParticleDataEntry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ParticleDecays = {"_p_Pythia8__ParticleDecays", "Pythia8::ParticleDecays *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__PartonLevel = {"_p_Pythia8__PartonLevel", "Pythia8::PartonLevel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__PartonSystem = {"_p_Pythia8__PartonSystem", "Pythia8::PartonSystem *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__PartonSystems = {"_p_Pythia8__PartonSystems", "Pythia8::PartonSystems *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__PartonVertex = {"_p_Pythia8__PartonVertex", "Pythia8::PartonVertex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__PhaseSpace = {"_p_Pythia8__PhaseSpace", "Pythia8::PhaseSpace *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__PhaseSpace2to1tauy = {"_p_Pythia8__PhaseSpace2to1tauy", "Pythia8::PhaseSpace2to1tauy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__PhaseSpace2to2diffractive = {"_p_Pythia8__PhaseSpace2to2diffractive", "Pythia8::PhaseSpace2to2diffractive *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__PhaseSpace2to2elastic = {"_p_Pythia8__PhaseSpace2to2elastic", "Pythia8::PhaseSpace2to2elastic *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__PhaseSpace2to2nondiffractive = {"_p_Pythia8__PhaseSpace2to2nondiffractive", "Pythia8::PhaseSpace2to2nondiffractive *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__PhaseSpace2to2nondiffractiveGamma = {"_p_Pythia8__PhaseSpace2to2nondiffractiveGamma", "Pythia8::PhaseSpace2to2nondiffractiveGamma *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__PhaseSpace2to2tauyz = {"_p_Pythia8__PhaseSpace2to2tauyz", "Pythia8::PhaseSpace2to2tauyz *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__PhaseSpace2to3diffractive = {"_p_Pythia8__PhaseSpace2to3diffractive", "Pythia8::PhaseSpace2to3diffractive *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__PhaseSpace2to3tauycyl = {"_p_Pythia8__PhaseSpace2to3tauycyl", "Pythia8::PhaseSpace2to3tauycyl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__PhaseSpace2to3yyycyl = {"_p_Pythia8__PhaseSpace2to3yyycyl", "Pythia8::PhaseSpace2to3yyycyl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__PhaseSpaceLHA = {"_p_Pythia8__PhaseSpaceLHA", "Pythia8::PhaseSpaceLHA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__PomFix = {"_p_Pythia8__PomFix", "Pythia8::PomFix *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__PomH1FitAB = {"_p_Pythia8__PomH1FitAB", "Pythia8::PomH1FitAB *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__PomH1Jets = {"_p_Pythia8__PomH1Jets", "Pythia8::PomH1Jets *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__PomHISASD = {"_p_Pythia8__PomHISASD", "Pythia8::PomHISASD *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__PowhegHooks = {"_p_Pythia8__PowhegHooks", "Pythia8::PowhegHooks *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__PowhegProcs = {"_p_Pythia8__PowhegProcs", "Pythia8::PowhegProcs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ProcessContainer = {"_p_Pythia8__ProcessContainer", "std::vector< Pythia8::ProcessContainer * >::value_type|Pythia8::ProcessContainer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ProcessLevel = {"_p_Pythia8__ProcessLevel", "Pythia8::ProcessLevel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ProgressLog = {"_p_Pythia8__ProgressLog", "Pythia8::ProgressLog *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ProtonPoint = {"_p_Pythia8__ProtonPoint", "Pythia8::ProtonPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Pythia = {"_p_Pythia8__Pythia", "Pythia8::Pythia *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__RHadrons = {"_p_Pythia8__RHadrons", "Pythia8::RHadrons *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Reader = {"_p_Pythia8__Reader", "Pythia8::Reader *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResolvedParton = {"_p_Pythia8__ResolvedParton", "Pythia8::ResolvedParton *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceChar = {"_p_Pythia8__ResonanceChar", "Pythia8::ResonanceChar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceDecays = {"_p_Pythia8__ResonanceDecays", "Pythia8::ResonanceDecays *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceExcited = {"_p_Pythia8__ResonanceExcited", "Pythia8::ResonanceExcited *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceFour = {"_p_Pythia8__ResonanceFour", "Pythia8::ResonanceFour *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceGeneric = {"_p_Pythia8__ResonanceGeneric", "Pythia8::ResonanceGeneric *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceGluino = {"_p_Pythia8__ResonanceGluino", "Pythia8::ResonanceGluino *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceGmZ = {"_p_Pythia8__ResonanceGmZ", "Pythia8::ResonanceGmZ *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceGraviton = {"_p_Pythia8__ResonanceGraviton", "Pythia8::ResonanceGraviton *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceH = {"_p_Pythia8__ResonanceH", "Pythia8::ResonanceH *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceHchg = {"_p_Pythia8__ResonanceHchg", "Pythia8::ResonanceHchg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceHchgchgLeft = {"_p_Pythia8__ResonanceHchgchgLeft", "Pythia8::ResonanceHchgchgLeft *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceHchgchgRight = {"_p_Pythia8__ResonanceHchgchgRight", "Pythia8::ResonanceHchgchgRight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceKKgluon = {"_p_Pythia8__ResonanceKKgluon", "Pythia8::ResonanceKKgluon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceLeptoquark = {"_p_Pythia8__ResonanceLeptoquark", "Pythia8::ResonanceLeptoquark *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceNeut = {"_p_Pythia8__ResonanceNeut", "Pythia8::ResonanceNeut *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceNuRight = {"_p_Pythia8__ResonanceNuRight", "Pythia8::ResonanceNuRight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceRhorizontal = {"_p_Pythia8__ResonanceRhorizontal", "Pythia8::ResonanceRhorizontal *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceS = {"_p_Pythia8__ResonanceS", "Pythia8::ResonanceS *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceSlepton = {"_p_Pythia8__ResonanceSlepton", "Pythia8::ResonanceSlepton *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceSquark = {"_p_Pythia8__ResonanceSquark", "Pythia8::ResonanceSquark *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceTop = {"_p_Pythia8__ResonanceTop", "Pythia8::ResonanceTop *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceW = {"_p_Pythia8__ResonanceW", "Pythia8::ResonanceW *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceWRight = {"_p_Pythia8__ResonanceWRight", "Pythia8::ResonanceWRight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceWidths = {"_p_Pythia8__ResonanceWidths", "Pythia8::ResonanceWidths *|std::vector< Pythia8::ResonanceWidths * >::value_type", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceWprime = {"_p_Pythia8__ResonanceWprime", "Pythia8::ResonanceWprime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceZRight = {"_p_Pythia8__ResonanceZRight", "Pythia8::ResonanceZRight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceZp = {"_p_Pythia8__ResonanceZp", "Pythia8::ResonanceZp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__ResonanceZprime = {"_p_Pythia8__ResonanceZprime", "Pythia8::ResonanceZprime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Rndm = {"_p_Pythia8__Rndm", "Pythia8::Rndm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__RndmEngine = {"_p_Pythia8__RndmEngine", "Pythia8::RndmEngine *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__RopeDipole = {"_p_Pythia8__RopeDipole", "Pythia8::RopeDipole *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__RopeDipoleEnd = {"_p_Pythia8__RopeDipoleEnd", "Pythia8::RopeDipoleEnd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__RopeFragPars = {"_p_Pythia8__RopeFragPars", "Pythia8::RopeFragPars *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Ropewalk = {"_p_Pythia8__Ropewalk", "Pythia8::Ropewalk *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__RotBstMatrix = {"_p_Pythia8__RotBstMatrix", "Pythia8::RotBstMatrix *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SLHAinterface = {"_p_Pythia8__SLHAinterface", "Pythia8::SLHAinterface *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SUSYResonanceWidths = {"_p_Pythia8__SUSYResonanceWidths", "Pythia8::SUSYResonanceWidths *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Settings = {"_p_Pythia8__Settings", "Pythia8::Settings *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SetupContainers = {"_p_Pythia8__SetupContainers", "Pythia8::SetupContainers *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma0AB2AB = {"_p_Pythia8__Sigma0AB2AB", "Pythia8::Sigma0AB2AB *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma0AB2AX = {"_p_Pythia8__Sigma0AB2AX", "Pythia8::Sigma0AB2AX *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma0AB2AXB = {"_p_Pythia8__Sigma0AB2AXB", "Pythia8::Sigma0AB2AXB *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma0AB2XB = {"_p_Pythia8__Sigma0AB2XB", "Pythia8::Sigma0AB2XB *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma0AB2XX = {"_p_Pythia8__Sigma0AB2XX", "Pythia8::Sigma0AB2XX *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma0Process = {"_p_Pythia8__Sigma0Process", "Pythia8::Sigma0Process *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma0nonDiffractive = {"_p_Pythia8__Sigma0nonDiffractive", "Pythia8::Sigma0nonDiffractive *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma1Process = {"_p_Pythia8__Sigma1Process", "Pythia8::Sigma1Process *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma1ffbar2GravitonStar = {"_p_Pythia8__Sigma1ffbar2GravitonStar", "Pythia8::Sigma1ffbar2GravitonStar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma1ffbar2H = {"_p_Pythia8__Sigma1ffbar2H", "Pythia8::Sigma1ffbar2H *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma1ffbar2Hchg = {"_p_Pythia8__Sigma1ffbar2Hchg", "Pythia8::Sigma1ffbar2Hchg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma1ffbar2Rhorizontal = {"_p_Pythia8__Sigma1ffbar2Rhorizontal", "Pythia8::Sigma1ffbar2Rhorizontal *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma1ffbar2W = {"_p_Pythia8__Sigma1ffbar2W", "Pythia8::Sigma1ffbar2W *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma1ffbar2WRight = {"_p_Pythia8__Sigma1ffbar2WRight", "Pythia8::Sigma1ffbar2WRight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma1ffbar2Wprime = {"_p_Pythia8__Sigma1ffbar2Wprime", "Pythia8::Sigma1ffbar2Wprime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma1ffbar2ZRight = {"_p_Pythia8__Sigma1ffbar2ZRight", "Pythia8::Sigma1ffbar2ZRight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma1ffbar2Zp2XX = {"_p_Pythia8__Sigma1ffbar2Zp2XX", "Pythia8::Sigma1ffbar2Zp2XX *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma1ffbar2Zv = {"_p_Pythia8__Sigma1ffbar2Zv", "Pythia8::Sigma1ffbar2Zv *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma1ffbar2gmZ = {"_p_Pythia8__Sigma1ffbar2gmZ", "Pythia8::Sigma1ffbar2gmZ *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma1ffbar2gmZZprime = {"_p_Pythia8__Sigma1ffbar2gmZZprime", "Pythia8::Sigma1ffbar2gmZZprime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma1ffbarZprimeWprime = {"_p_Pythia8__Sigma1ffbarZprimeWprime", "Pythia8::Sigma1ffbarZprimeWprime *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma1gg2GravitonStar = {"_p_Pythia8__Sigma1gg2GravitonStar", "Pythia8::Sigma1gg2GravitonStar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma1gg2H = {"_p_Pythia8__Sigma1gg2H", "Pythia8::Sigma1gg2H *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma1gg2S2XX = {"_p_Pythia8__Sigma1gg2S2XX", "Pythia8::Sigma1gg2S2XX *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma1gmgm2H = {"_p_Pythia8__Sigma1gmgm2H", "Pythia8::Sigma1gmgm2H *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma1lgm2lStar = {"_p_Pythia8__Sigma1lgm2lStar", "Pythia8::Sigma1lgm2lStar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma1ll2Hchgchg = {"_p_Pythia8__Sigma1ll2Hchgchg", "Pythia8::Sigma1ll2Hchgchg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma1qg2qStar = {"_p_Pythia8__Sigma1qg2qStar", "Pythia8::Sigma1qg2qStar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma1ql2LeptoQuark = {"_p_Pythia8__Sigma1ql2LeptoQuark", "Pythia8::Sigma1ql2LeptoQuark *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma1qq2antisquark = {"_p_Pythia8__Sigma1qq2antisquark", "Pythia8::Sigma1qq2antisquark *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma1qqbar2KKgluonStar = {"_p_Pythia8__Sigma1qqbar2KKgluonStar", "Pythia8::Sigma1qqbar2KKgluonStar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2Process = {"_p_Pythia8__Sigma2Process", "Pythia8::Sigma2Process *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2QCffbar2llbar = {"_p_Pythia8__Sigma2QCffbar2llbar", "Pythia8::Sigma2QCffbar2llbar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2QCqq2qq = {"_p_Pythia8__Sigma2QCqq2qq", "Pythia8::Sigma2QCqq2qq *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2QCqqbar2qqbar = {"_p_Pythia8__Sigma2QCqqbar2qqbar", "Pythia8::Sigma2QCqqbar2qqbar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2SUSY = {"_p_Pythia8__Sigma2SUSY", "Pythia8::Sigma2SUSY *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ff2fftW = {"_p_Pythia8__Sigma2ff2fftW", "Pythia8::Sigma2ff2fftW *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ff2fftgmZ = {"_p_Pythia8__Sigma2ff2fftgmZ", "Pythia8::Sigma2ff2fftgmZ *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbar2A3H12 = {"_p_Pythia8__Sigma2ffbar2A3H12", "Pythia8::Sigma2ffbar2A3H12 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbar2FFbarsgmZ = {"_p_Pythia8__Sigma2ffbar2FFbarsgmZ", "Pythia8::Sigma2ffbar2FFbarsgmZ *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbar2FfbarsW = {"_p_Pythia8__Sigma2ffbar2FfbarsW", "Pythia8::Sigma2ffbar2FfbarsW *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbar2HW = {"_p_Pythia8__Sigma2ffbar2HW", "Pythia8::Sigma2ffbar2HW *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbar2HZ = {"_p_Pythia8__Sigma2ffbar2HZ", "Pythia8::Sigma2ffbar2HZ *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbar2HchgH12 = {"_p_Pythia8__Sigma2ffbar2HchgH12", "Pythia8::Sigma2ffbar2HchgH12 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbar2HchgchgHchgchg = {"_p_Pythia8__Sigma2ffbar2HchgchgHchgchg", "Pythia8::Sigma2ffbar2HchgchgHchgchg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbar2HposHneg = {"_p_Pythia8__Sigma2ffbar2HposHneg", "Pythia8::Sigma2ffbar2HposHneg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbar2LEDUnparticleZ = {"_p_Pythia8__Sigma2ffbar2LEDUnparticleZ", "Pythia8::Sigma2ffbar2LEDUnparticleZ *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbar2LEDUnparticlegamma = {"_p_Pythia8__Sigma2ffbar2LEDUnparticlegamma", "Pythia8::Sigma2ffbar2LEDUnparticlegamma *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbar2LEDgammagamma = {"_p_Pythia8__Sigma2ffbar2LEDgammagamma", "Pythia8::Sigma2ffbar2LEDgammagamma *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbar2LEDllbar = {"_p_Pythia8__Sigma2ffbar2LEDllbar", "Pythia8::Sigma2ffbar2LEDllbar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbar2TEVffbar = {"_p_Pythia8__Sigma2ffbar2TEVffbar", "Pythia8::Sigma2ffbar2TEVffbar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbar2WW = {"_p_Pythia8__Sigma2ffbar2WW", "Pythia8::Sigma2ffbar2WW *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbar2Wgm = {"_p_Pythia8__Sigma2ffbar2Wgm", "Pythia8::Sigma2ffbar2Wgm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbar2ZW = {"_p_Pythia8__Sigma2ffbar2ZW", "Pythia8::Sigma2ffbar2ZW *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbar2ZpH = {"_p_Pythia8__Sigma2ffbar2ZpH", "Pythia8::Sigma2ffbar2ZpH *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbar2fGfGbar = {"_p_Pythia8__Sigma2ffbar2fGfGbar", "Pythia8::Sigma2ffbar2fGfGbar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbar2ffbarsW = {"_p_Pythia8__Sigma2ffbar2ffbarsW", "Pythia8::Sigma2ffbar2ffbarsW *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbar2ffbarsgm = {"_p_Pythia8__Sigma2ffbar2ffbarsgm", "Pythia8::Sigma2ffbar2ffbarsgm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbar2ffbarsgmZ = {"_p_Pythia8__Sigma2ffbar2ffbarsgmZ", "Pythia8::Sigma2ffbar2ffbarsgmZ *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbar2gammagamma = {"_p_Pythia8__Sigma2ffbar2gammagamma", "Pythia8::Sigma2ffbar2gammagamma *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbar2gmZgm = {"_p_Pythia8__Sigma2ffbar2gmZgm", "Pythia8::Sigma2ffbar2gmZgm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbar2gmZgmZ = {"_p_Pythia8__Sigma2ffbar2gmZgmZ", "Pythia8::Sigma2ffbar2gmZgmZ *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbarWggm = {"_p_Pythia8__Sigma2ffbarWggm", "Pythia8::Sigma2ffbarWggm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbargmZWgmZW = {"_p_Pythia8__Sigma2ffbargmZWgmZW", "Pythia8::Sigma2ffbargmZWgmZW *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ffbargmZggm = {"_p_Pythia8__Sigma2ffbargmZggm", "Pythia8::Sigma2ffbargmZggm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2fgm2Wf = {"_p_Pythia8__Sigma2fgm2Wf", "Pythia8::Sigma2fgm2Wf *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2fgm2gmZf = {"_p_Pythia8__Sigma2fgm2gmZf", "Pythia8::Sigma2fgm2gmZf *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2gg2GravitonStarg = {"_p_Pythia8__Sigma2gg2GravitonStarg", "Pythia8::Sigma2gg2GravitonStarg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2gg2Hglt = {"_p_Pythia8__Sigma2gg2Hglt", "Pythia8::Sigma2gg2Hglt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2gg2LEDUnparticleg = {"_p_Pythia8__Sigma2gg2LEDUnparticleg", "Pythia8::Sigma2gg2LEDUnparticleg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2gg2LEDgammagamma = {"_p_Pythia8__Sigma2gg2LEDgammagamma", "Pythia8::Sigma2gg2LEDgammagamma *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2gg2LEDgg = {"_p_Pythia8__Sigma2gg2LEDgg", "Pythia8::Sigma2gg2LEDgg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2gg2LEDllbar = {"_p_Pythia8__Sigma2gg2LEDllbar", "Pythia8::Sigma2gg2LEDllbar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2gg2LEDqqbar = {"_p_Pythia8__Sigma2gg2LEDqqbar", "Pythia8::Sigma2gg2LEDqqbar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2gg2LQLQbar = {"_p_Pythia8__Sigma2gg2LQLQbar", "Pythia8::Sigma2gg2LQLQbar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2gg2QQbar = {"_p_Pythia8__Sigma2gg2QQbar", "Pythia8::Sigma2gg2QQbar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2gg2QQbar3DJ1g = {"_p_Pythia8__Sigma2gg2QQbar3DJ1g", "Pythia8::Sigma2gg2QQbar3DJ1g *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2gg2QQbar3PJ1g = {"_p_Pythia8__Sigma2gg2QQbar3PJ1g", "Pythia8::Sigma2gg2QQbar3PJ1g *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11 = {"_p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11", "Pythia8::Sigma2gg2QQbar3S11QQbar3S11 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2gg2QQbar3S11g = {"_p_Pythia8__Sigma2gg2QQbar3S11g", "Pythia8::Sigma2gg2QQbar3S11g *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2gg2QQbar3S11gm = {"_p_Pythia8__Sigma2gg2QQbar3S11gm", "Pythia8::Sigma2gg2QQbar3S11gm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2gg2QQbarX8g = {"_p_Pythia8__Sigma2gg2QQbarX8g", "Pythia8::Sigma2gg2QQbarX8g *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2gg2Sg2XXj = {"_p_Pythia8__Sigma2gg2Sg2XXj", "Pythia8::Sigma2gg2Sg2XXj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2gg2gammagamma = {"_p_Pythia8__Sigma2gg2gammagamma", "Pythia8::Sigma2gg2gammagamma *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2gg2gg = {"_p_Pythia8__Sigma2gg2gg", "Pythia8::Sigma2gg2gg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2gg2ggamma = {"_p_Pythia8__Sigma2gg2ggamma", "Pythia8::Sigma2gg2ggamma *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2gg2gluinogluino = {"_p_Pythia8__Sigma2gg2gluinogluino", "Pythia8::Sigma2gg2gluinogluino *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2gg2qGqGbar = {"_p_Pythia8__Sigma2gg2qGqGbar", "Pythia8::Sigma2gg2qGqGbar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2gg2qqbar = {"_p_Pythia8__Sigma2gg2qqbar", "Pythia8::Sigma2gg2qqbar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2gg2squarkantisquark = {"_p_Pythia8__Sigma2gg2squarkantisquark", "Pythia8::Sigma2gg2squarkantisquark *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2ggm2qqbar = {"_p_Pythia8__Sigma2ggm2qqbar", "Pythia8::Sigma2ggm2qqbar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2gmgm2ffbar = {"_p_Pythia8__Sigma2gmgm2ffbar", "Pythia8::Sigma2gmgm2ffbar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2lgm2Hchgchgl = {"_p_Pythia8__Sigma2lgm2Hchgchgl", "Pythia8::Sigma2lgm2Hchgchgl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qg2GravitonStarq = {"_p_Pythia8__Sigma2qg2GravitonStarq", "Pythia8::Sigma2qg2GravitonStarq *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qg2Hchgq = {"_p_Pythia8__Sigma2qg2Hchgq", "Pythia8::Sigma2qg2Hchgq *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qg2Hq = {"_p_Pythia8__Sigma2qg2Hq", "Pythia8::Sigma2qg2Hq *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qg2Hqlt = {"_p_Pythia8__Sigma2qg2Hqlt", "Pythia8::Sigma2qg2Hqlt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qg2LEDUnparticleq = {"_p_Pythia8__Sigma2qg2LEDUnparticleq", "Pythia8::Sigma2qg2LEDUnparticleq *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qg2LEDqg = {"_p_Pythia8__Sigma2qg2LEDqg", "Pythia8::Sigma2qg2LEDqg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qg2LeptoQuarkl = {"_p_Pythia8__Sigma2qg2LeptoQuarkl", "Pythia8::Sigma2qg2LeptoQuarkl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qg2QQbar3PJ1q = {"_p_Pythia8__Sigma2qg2QQbar3PJ1q", "Pythia8::Sigma2qg2QQbar3PJ1q *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qg2QQbarX8q = {"_p_Pythia8__Sigma2qg2QQbarX8q", "Pythia8::Sigma2qg2QQbarX8q *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qg2Sq2XXj = {"_p_Pythia8__Sigma2qg2Sq2XXj", "Pythia8::Sigma2qg2Sq2XXj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qg2Wq = {"_p_Pythia8__Sigma2qg2Wq", "Pythia8::Sigma2qg2Wq *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qg2Zpq2XXj = {"_p_Pythia8__Sigma2qg2Zpq2XXj", "Pythia8::Sigma2qg2Zpq2XXj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qg2charsquark = {"_p_Pythia8__Sigma2qg2charsquark", "Pythia8::Sigma2qg2charsquark *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qg2chi0squark = {"_p_Pythia8__Sigma2qg2chi0squark", "Pythia8::Sigma2qg2chi0squark *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qg2gmZq = {"_p_Pythia8__Sigma2qg2gmZq", "Pythia8::Sigma2qg2gmZq *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qg2qg = {"_p_Pythia8__Sigma2qg2qg", "Pythia8::Sigma2qg2qg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qg2qgamma = {"_p_Pythia8__Sigma2qg2qgamma", "Pythia8::Sigma2qg2qgamma *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qg2squarkgluino = {"_p_Pythia8__Sigma2qg2squarkgluino", "Pythia8::Sigma2qg2squarkgluino *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qgm2qg = {"_p_Pythia8__Sigma2qgm2qg", "Pythia8::Sigma2qgm2qg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qgm2qgm = {"_p_Pythia8__Sigma2qgm2qgm", "Pythia8::Sigma2qgm2qgm *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qq2LEDqq = {"_p_Pythia8__Sigma2qq2LEDqq", "Pythia8::Sigma2qq2LEDqq *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qq2QqtW = {"_p_Pythia8__Sigma2qq2QqtW", "Pythia8::Sigma2qq2QqtW *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qq2qStarq = {"_p_Pythia8__Sigma2qq2qStarq", "Pythia8::Sigma2qq2qStarq *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qq2qq = {"_p_Pythia8__Sigma2qq2qq", "Pythia8::Sigma2qq2qq *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qq2squarksquark = {"_p_Pythia8__Sigma2qq2squarksquark", "Pythia8::Sigma2qq2squarksquark *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2GravitonStarg = {"_p_Pythia8__Sigma2qqbar2GravitonStarg", "Pythia8::Sigma2qqbar2GravitonStarg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2Hglt = {"_p_Pythia8__Sigma2qqbar2Hglt", "Pythia8::Sigma2qqbar2Hglt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2LEDUnparticleg = {"_p_Pythia8__Sigma2qqbar2LEDUnparticleg", "Pythia8::Sigma2qqbar2LEDUnparticleg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2LEDgg = {"_p_Pythia8__Sigma2qqbar2LEDgg", "Pythia8::Sigma2qqbar2LEDgg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2LEDqqbarNew = {"_p_Pythia8__Sigma2qqbar2LEDqqbarNew", "Pythia8::Sigma2qqbar2LEDqqbarNew *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2LQLQbar = {"_p_Pythia8__Sigma2qqbar2LQLQbar", "Pythia8::Sigma2qqbar2LQLQbar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2QQbar = {"_p_Pythia8__Sigma2qqbar2QQbar", "Pythia8::Sigma2qqbar2QQbar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2QQbar3PJ1g = {"_p_Pythia8__Sigma2qqbar2QQbar3PJ1g", "Pythia8::Sigma2qqbar2QQbar3PJ1g *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11 = {"_p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11", "Pythia8::Sigma2qqbar2QQbar3S11QQbar3S11 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2QQbarX8g = {"_p_Pythia8__Sigma2qqbar2QQbarX8g", "Pythia8::Sigma2qqbar2QQbarX8g *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2Wg = {"_p_Pythia8__Sigma2qqbar2Wg", "Pythia8::Sigma2qqbar2Wg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2Zpg2XXj = {"_p_Pythia8__Sigma2qqbar2Zpg2XXj", "Pythia8::Sigma2qqbar2Zpg2XXj *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2charchar = {"_p_Pythia8__Sigma2qqbar2charchar", "Pythia8::Sigma2qqbar2charchar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2charchi0 = {"_p_Pythia8__Sigma2qqbar2charchi0", "Pythia8::Sigma2qqbar2charchi0 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2chargluino = {"_p_Pythia8__Sigma2qqbar2chargluino", "Pythia8::Sigma2qqbar2chargluino *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2chi0chi0 = {"_p_Pythia8__Sigma2qqbar2chi0chi0", "Pythia8::Sigma2qqbar2chi0chi0 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2chi0gluino = {"_p_Pythia8__Sigma2qqbar2chi0gluino", "Pythia8::Sigma2qqbar2chi0gluino *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2gg = {"_p_Pythia8__Sigma2qqbar2gg", "Pythia8::Sigma2qqbar2gg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2ggamma = {"_p_Pythia8__Sigma2qqbar2ggamma", "Pythia8::Sigma2qqbar2ggamma *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2gluinogluino = {"_p_Pythia8__Sigma2qqbar2gluinogluino", "Pythia8::Sigma2qqbar2gluinogluino *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2gmZg = {"_p_Pythia8__Sigma2qqbar2gmZg", "Pythia8::Sigma2qqbar2gmZg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2lStarlStarBar = {"_p_Pythia8__Sigma2qqbar2lStarlStarBar", "Pythia8::Sigma2qqbar2lStarlStarBar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2lStarlbar = {"_p_Pythia8__Sigma2qqbar2lStarlbar", "Pythia8::Sigma2qqbar2lStarlbar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2qGqGbar = {"_p_Pythia8__Sigma2qqbar2qGqGbar", "Pythia8::Sigma2qqbar2qGqGbar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2qqbarNew = {"_p_Pythia8__Sigma2qqbar2qqbarNew", "Pythia8::Sigma2qqbar2qqbarNew *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2sleptonantislepton = {"_p_Pythia8__Sigma2qqbar2sleptonantislepton", "Pythia8::Sigma2qqbar2sleptonantislepton *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma2qqbar2squarkantisquark = {"_p_Pythia8__Sigma2qqbar2squarkantisquark", "Pythia8::Sigma2qqbar2squarkantisquark *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma3Process = {"_p_Pythia8__Sigma3Process", "Pythia8::Sigma3Process *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma3ff2HchgchgfftWW = {"_p_Pythia8__Sigma3ff2HchgchgfftWW", "Pythia8::Sigma3ff2HchgchgfftWW *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma3ff2HfftWW = {"_p_Pythia8__Sigma3ff2HfftWW", "Pythia8::Sigma3ff2HfftWW *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma3ff2HfftZZ = {"_p_Pythia8__Sigma3ff2HfftZZ", "Pythia8::Sigma3ff2HfftZZ *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma3gg2HQQbar = {"_p_Pythia8__Sigma3gg2HQQbar", "Pythia8::Sigma3gg2HQQbar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma3gg2ggg = {"_p_Pythia8__Sigma3gg2ggg", "Pythia8::Sigma3gg2ggg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma3gg2qqbarg = {"_p_Pythia8__Sigma3gg2qqbarg", "Pythia8::Sigma3gg2qqbarg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma3qg2qgg = {"_p_Pythia8__Sigma3qg2qgg", "Pythia8::Sigma3qg2qgg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma3qg2qqqbarDiff = {"_p_Pythia8__Sigma3qg2qqqbarDiff", "Pythia8::Sigma3qg2qqqbarDiff *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma3qg2qqqbarSame = {"_p_Pythia8__Sigma3qg2qqqbarSame", "Pythia8::Sigma3qg2qqqbarSame *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma3qq2qqgDiff = {"_p_Pythia8__Sigma3qq2qqgDiff", "Pythia8::Sigma3qq2qqgDiff *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma3qq2qqgSame = {"_p_Pythia8__Sigma3qq2qqgSame", "Pythia8::Sigma3qq2qqgSame *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma3qqbar2HQQbar = {"_p_Pythia8__Sigma3qqbar2HQQbar", "Pythia8::Sigma3qqbar2HQQbar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma3qqbar2ggg = {"_p_Pythia8__Sigma3qqbar2ggg", "Pythia8::Sigma3qqbar2ggg *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma3qqbar2qqbargDiff = {"_p_Pythia8__Sigma3qqbar2qqbargDiff", "Pythia8::Sigma3qqbar2qqbargDiff *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sigma3qqbar2qqbargSame = {"_p_Pythia8__Sigma3qqbar2qqbargSame", "Pythia8::Sigma3qqbar2qqbargSame *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SigmaABMST = {"_p_Pythia8__SigmaABMST", "Pythia8::SigmaABMST *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SigmaLHAProcess = {"_p_Pythia8__SigmaLHAProcess", "Pythia8::SigmaLHAProcess *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SigmaMBR = {"_p_Pythia8__SigmaMBR", "Pythia8::SigmaMBR *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SigmaMultiparton = {"_p_Pythia8__SigmaMultiparton", "Pythia8::SigmaMultiparton *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SigmaOniaSetup = {"_p_Pythia8__SigmaOniaSetup", "Pythia8::SigmaOniaSetup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SigmaPartialWave = {"_p_Pythia8__SigmaPartialWave", "Pythia8::SigmaPartialWave *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SigmaProcess = {"_p_Pythia8__SigmaProcess", "Pythia8::SigmaProcess *|std::vector< Pythia8::SigmaProcess * >::value_type", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SigmaRPP = {"_p_Pythia8__SigmaRPP", "Pythia8::SigmaRPP *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SigmaSaSDL = {"_p_Pythia8__SigmaSaSDL", "Pythia8::SigmaSaSDL *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SigmaTotAux = {"_p_Pythia8__SigmaTotAux", "Pythia8::SigmaTotAux *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SigmaTotOwn = {"_p_Pythia8__SigmaTotOwn", "Pythia8::SigmaTotOwn *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SigmaTotal = {"_p_Pythia8__SigmaTotal", "Pythia8::SigmaTotal *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SingleCell = {"_p_Pythia8__SingleCell", "Pythia8::SingleCell *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SingleCellJet = {"_p_Pythia8__SingleCellJet", "Pythia8::SingleCellJet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SingleClusterJet = {"_p_Pythia8__SingleClusterJet", "Pythia8::SingleClusterJet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SingleSlowJet = {"_p_Pythia8__SingleSlowJet", "Pythia8::SingleSlowJet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SlowJet = {"_p_Pythia8__SlowJet", "Pythia8::SlowJet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SlowJetHook = {"_p_Pythia8__SlowJetHook", "Pythia8::SlowJetHook *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SpaceDipoleEnd = {"_p_Pythia8__SpaceDipoleEnd", "Pythia8::SpaceDipoleEnd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SpaceShower = {"_p_Pythia8__SpaceShower", "Pythia8::SpaceShower *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Sphericity = {"_p_Pythia8__Sphericity", "Pythia8::Sphericity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__StauWidths = {"_p_Pythia8__StauWidths", "Pythia8::StauWidths *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__StringEnd = {"_p_Pythia8__StringEnd", "Pythia8::StringEnd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__StringFlav = {"_p_Pythia8__StringFlav", "Pythia8::StringFlav *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__StringFragmentation = {"_p_Pythia8__StringFragmentation", "Pythia8::StringFragmentation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__StringLength = {"_p_Pythia8__StringLength", "Pythia8::StringLength *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__StringPT = {"_p_Pythia8__StringPT", "Pythia8::StringPT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__StringRegion = {"_p_Pythia8__StringRegion", "Pythia8::StringRegion *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__StringSystem = {"_p_Pythia8__StringSystem", "Pythia8::StringSystem *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__StringVertex = {"_p_Pythia8__StringVertex", "Pythia8::StringVertex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__StringZ = {"_p_Pythia8__StringZ", "Pythia8::StringZ *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SubCollision = {"_p_Pythia8__SubCollision", "Pythia8::SubCollision *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SubCollisionModel = {"_p_Pythia8__SubCollisionModel", "Pythia8::SubCollisionModel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SubCollisionModel__SigEst = {"_p_Pythia8__SubCollisionModel__SigEst", "Pythia8::SubCollisionModel::SigEst *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SuppressSmallPT = {"_p_Pythia8__SuppressSmallPT", "Pythia8::SuppressSmallPT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__SusyLesHouches = {"_p_Pythia8__SusyLesHouches", "Pythia8::SusyLesHouches *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__TauDecays = {"_p_Pythia8__TauDecays", "Pythia8::TauDecays *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Thrust = {"_p_Pythia8__Thrust", "Pythia8::Thrust *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__TimeDipoleEnd = {"_p_Pythia8__TimeDipoleEnd", "Pythia8::TimeDipoleEnd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__TimeShower = {"_p_Pythia8__TimeShower", "Pythia8::TimeShower *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__TopReconUserHooks = {"_p_Pythia8__TopReconUserHooks", "Pythia8::TopReconUserHooks *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__TrialReconnection = {"_p_Pythia8__TrialReconnection", "Pythia8::TrialReconnection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__UserHooks = {"_p_Pythia8__UserHooks", "Pythia8::UserHooks *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__UserHooksVector = {"_p_Pythia8__UserHooksVector", "Pythia8::UserHooksVector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Vec4 = {"_p_Pythia8__Vec4", "std::vector< Pythia8::Vec4 >::value_type *|Pythia8::Vec4 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__WVec = {"_p_Pythia8__WVec", "Pythia8::WVec *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Wave4 = {"_p_Pythia8__Wave4", "Pythia8::Wave4 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__WeakShowerMEs = {"_p_Pythia8__WeakShowerMEs", "Pythia8::WeakShowerMEs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__WidthFunction = {"_p_Pythia8__WidthFunction", "Pythia8::WidthFunction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__WoodsSaxonModel = {"_p_Pythia8__WoodsSaxonModel", "Pythia8::WoodsSaxonModel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Word = {"_p_Pythia8__Word", "std::map< std::string,Pythia8::Word >::mapped_type *|Pythia8::Word *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__Writer = {"_p_Pythia8__Writer", "Pythia8::Writer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__XMLTag = {"_p_Pythia8__XMLTag", "Pythia8::XMLTag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__amcnlo_unitarised_interface = {"_p_Pythia8__amcnlo_unitarised_interface", "Pythia8::amcnlo_unitarised_interface *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Pythia8__nPDF = {"_p_Pythia8__nPDF", "Pythia8::nPDF *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_State = {"_p_State", "State *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_3__std__complexT_double_t = {"_p_a_3__std__complexT_double_t", "std::complex< double > (*)[3]|Pythia8::complex (*)[3]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_4__std__complexT_double_t = {"_p_a_4__std__complexT_double_t", "std::complex< double > (*)[4]|Pythia8::complex (*)[4]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_6__std__complexT_double_t = {"_p_a_6__std__complexT_double_t", "std::complex< double > (*)[6]|Pythia8::complex (*)[6]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_7__std__complexT_double_t = {"_p_a_7__std__complexT_double_t", "std::complex< double > (*)[7]|Pythia8::complex (*)[7]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_8__double = {"_p_a_8__double", "double (*)[8]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t = {"_p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t", "basic_string< char,std::char_traits< char >,std::allocator< char > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bool = {"_p_bool", "bool *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "std::basic_istream< char >::char_type *|char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char_type = {"_p_char_type", "char_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_const_reference = {"_p_const_reference", "const_reference *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_enum_std__ios_base__event_r_std__ios_base_int__void = {"_p_f_enum_std__ios_base__event_r_std__ios_base_int__void", "void (*)(enum std::ios_base::event,std::ios_base &,int)|std::ios_base::event_callback", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t = {"_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t", "std::basic_ios< char,std::char_traits< char > > &(*)(std::basic_ios< char,std::char_traits< char > > &)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t = {"_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t = {"_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t = {"_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t = {"_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t = {"_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t = {"_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t = {"_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t", "std::basic_istream< char,std::char_traits< char > > &(*)(std::basic_istream< char,std::char_traits< char > > &)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t = {"_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t = {"_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t = {"_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t = {"_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t", "std::basic_ostream< char,std::char_traits< char > > &(*)(std::basic_ostream< char,std::char_traits< char > > &)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t = {"_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t = {"_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t = {"_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_r_std__ios_base__r_std__ios_base = {"_p_f_r_std__ios_base__r_std__ios_base", "std::ios_base &(*)(std::ios_base &)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_r_std__ios_base__r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t = {"_p_f_r_std__ios_base__r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_r_std__ios_base__r_std__basic_ostreamT_char_std__char_traitsT_char_t_t = {"_p_f_r_std__ios_base__r_std__basic_ostreamT_char_std__char_traitsT_char_t_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_r_std__ios_base__r_std__basic_istreamT_char_std__char_traitsT_char_t_t = {"_p_f_r_std__ios_base__r_std__basic_istreamT_char_std__char_traitsT_char_t_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_r_std__ios_base__r_std__basic_iosT_char_std__char_traitsT_char_t_t = {"_p_f_r_std__ios_base__r_std__basic_iosT_char_std__char_traitsT_char_t_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_r_std__ios_base__r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t = {"_p_f_r_std__ios_base__r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_r_std__ios_base__r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t = {"_p_f_r_std__ios_base__r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_f_r_std__ios_base__r_std__basic_iostreamT_char_std__char_traitsT_char_t_t = {"_p_f_r_std__ios_base__r_std__basic_iostreamT_char_std__char_traitsT_char_t_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_first_type = {"_p_first_type", "first_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_float = {"_p_float", "float *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_fmtflags = {"_p_fmtflags", "fmtflags *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ifstream = {"_p_ifstream", "ifstream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int_type = {"_p_int_type", "int_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iostate = {"_p_iostate", "iostate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_key_type = {"_p_key_type", "key_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long_double = {"_p_long_double", "long double *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long_long = {"_p_long_long", "long long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mapped_type = {"_p_mapped_type", "mapped_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_off_type = {"_p_off_type", "off_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_openmode = {"_p_openmode", "openmode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_Pythia8__ColourDipole = {"_p_p_Pythia8__ColourDipole", "Pythia8::ColourDipole **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_std__basic_istreamT_char_std__char_traitsT_char_t_t = {"_p_p_std__basic_istreamT_char_std__char_traitsT_char_t_t", "std::basic_istream< char,std::char_traits< char > > **|std::istream **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t = {"_p_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_std__basic_iostreamT_char_std__char_traitsT_char_t_t = {"_p_p_std__basic_iostreamT_char_std__char_traitsT_char_t_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t = {"_p_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_pos_t = {"_p_pos_t", "pos_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_pos_type = {"_p_pos_type", "pos_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_reference = {"_p_reference", "reference *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_second_type = {"_p_second_type", "second_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_seekdir = {"_p_seekdir", "seekdir *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_short = {"_p_short", "short *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_size_t = {"_p_size_t", "std::streamsize *|size_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_state_type = {"_p_state_type", "state_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_Pythia8__Clustering_t = {"_p_std__allocatorT_Pythia8__Clustering_t", "std::vector< Pythia8::Clustering >::allocator_type *|std::allocator< Pythia8::Clustering > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_Pythia8__HelicityParticle_t = {"_p_std__allocatorT_Pythia8__HelicityParticle_t", "std::vector< Pythia8::HelicityParticle >::allocator_type *|std::allocator< Pythia8::HelicityParticle > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_Pythia8__ProcessContainer_p_t = {"_p_std__allocatorT_Pythia8__ProcessContainer_p_t", "std::allocator< Pythia8::ProcessContainer * > *|std::vector< Pythia8::ProcessContainer * >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_Pythia8__ResonanceWidths_p_t = {"_p_std__allocatorT_Pythia8__ResonanceWidths_p_t", "std::vector< Pythia8::ResonanceWidths * >::allocator_type *|std::allocator< Pythia8::ResonanceWidths * > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_Pythia8__SigmaProcess_p_t = {"_p_std__allocatorT_Pythia8__SigmaProcess_p_t", "std::vector< Pythia8::SigmaProcess * >::allocator_type *|std::allocator< Pythia8::SigmaProcess * > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_Pythia8__Vec4_t = {"_p_std__allocatorT_Pythia8__Vec4_t", "std::vector< Pythia8::Vec4 >::allocator_type *|std::allocator< Pythia8::Vec4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_bool_t = {"_p_std__allocatorT_bool_t", "std::vector< bool >::allocator_type *|std::allocator< bool > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_double_t = {"_p_std__allocatorT_double_t", "std::vector< double >::allocator_type *|std::allocator< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_int_t = {"_p_std__allocatorT_int_t", "std::vector< int >::allocator_type *|std::allocator< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__complexT_double_t_t = {"_p_std__allocatorT_std__complexT_double_t_t", "std::allocator< std::complex< double > > *|std::vector< std::complex< double > >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t = {"_p_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t", "std::allocator< std::pair< double const,std::pair< int,int > > > *|std::map< double,std::pair< int,int > >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__pairT_int_const_int_t_t = {"_p_std__allocatorT_std__pairT_int_const_int_t_t", "std::map< int,int >::allocator_type *|std::allocator< std::pair< int const,int > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__pairT_int_int_t_t = {"_p_std__allocatorT_std__pairT_int_int_t_t", "std::allocator< std::pair< int,int > > *|std::vector< std::pair< int,int > >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t = {"_p_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t", "std::allocator< std::pair< std::string const,Pythia8::FVec > > *|std::map< std::string,Pythia8::FVec >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t = {"_p_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t", "std::allocator< std::pair< std::string const,Pythia8::Flag > > *|std::map< std::string,Pythia8::Flag >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t = {"_p_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t", "std::allocator< std::pair< std::string const,Pythia8::MVec > > *|std::map< std::string,Pythia8::MVec >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t = {"_p_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t", "std::allocator< std::pair< std::string const,Pythia8::Mode > > *|std::map< std::string,Pythia8::Mode >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t = {"_p_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t", "std::allocator< std::pair< std::string const,Pythia8::PVec > > *|std::map< std::string,Pythia8::PVec >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t = {"_p_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t", "std::allocator< std::pair< std::string const,Pythia8::Parm > > *|std::map< std::string,Pythia8::Parm >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t = {"_p_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t", "std::allocator< std::pair< std::string const,Pythia8::Word > > *|std::map< std::string,Pythia8::Word >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__pairT_std__string_const_std__string_t_t = {"_p_std__allocatorT_std__pairT_std__string_const_std__string_t_t", "std::map< std::string,std::string >::allocator_type *|std::allocator< std::pair< std::string const,std::string > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__string_t = {"_p_std__allocatorT_std__string_t", "std::vector< std::string >::allocator_type *|std::allocator< std::string > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t = {"_p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t", "std::vector< std::vector< int > >::allocator_type *|std::allocator< std::vector< int,std::allocator< int > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t = {"_p_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t", "std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > *|std::vector< std::vector< std::complex< double > > >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__basic_iosT_char_std__char_traitsT_char_t_t = {"_p_std__basic_iosT_char_std__char_traitsT_char_t_t", "std::basic_ios< char > *|std::basic_ios< char,std::char_traits< char > > *|std::ios *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__basic_iostreamT_char_std__char_traitsT_char_t_t = {"_p_std__basic_iostreamT_char_std__char_traitsT_char_t_t", "std::basic_iostream< char,std::char_traits< char > > *|std::basic_iostream< char > *|std::iostream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__basic_istreamT_char_std__char_traitsT_char_t_t = {"_p_std__basic_istreamT_char_std__char_traitsT_char_t_t", "std::basic_istream< char > *|std::basic_istream< char,std::char_traits< char > > *|std::istream *|istream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t = {"_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t", "std::basic_istringstream< char > *|std::basic_istringstream< char,std::char_traits< char >,std::allocator< char > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__basic_ostreamT_char_std__char_traitsT_char_t_t = {"_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t", "std::basic_ostream< char > *|std::basic_ostream< char,std::char_traits< char > > *|std::ostream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t = {"_p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t", "std::basic_ostringstream< char > *|std::basic_ostringstream< char,std::char_traits< char >,std::allocator< char > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__basic_streambufT_char_std__char_traitsT_char_t_t = {"_p_std__basic_streambufT_char_std__char_traitsT_char_t_t", "std::basic_streambuf< char,std::char_traits< char > > *|std::basic_streambuf< char > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t = {"_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t", "std::basic_string< char,std::char_traits< char >,std::allocator< char > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__basic_stringbufT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t = {"_p_std__basic_stringbufT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t", "std::basic_stringbuf< char,std::char_traits< char >,std::allocator< char > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t = {"_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t", "std::basic_stringstream< char > *|std::basic_stringstream< char,std::char_traits< char >,std::allocator< char > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__complexT_double_t = {"_p_std__complexT_double_t", "Pythia8::complex *|std::complex< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__ifstream = {"_p_std__ifstream", "std::ifstream *|Pythia8::igzstream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__ios_base = {"_p_std__ios_base", "std::ios_base *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__lessT_double_t = {"_p_std__lessT_double_t", "std::less< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__lessT_int_t = {"_p_std__lessT_int_t", "std::less< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__lessT_std__string_t = {"_p_std__lessT_std__string_t", "std::less< std::string > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__locale = {"_p_std__locale", "std::locale *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_Pythia8__Nucleon_p_std__pairT_int_int_t_std__lessT_Pythia8__Nucleon_p_t_std__allocatorT_std__pairT_Pythia8__Nucleon_pconst_std__pairT_int_int_t_t_t_t = {"_p_std__mapT_Pythia8__Nucleon_p_std__pairT_int_int_t_std__lessT_Pythia8__Nucleon_p_t_std__allocatorT_std__pairT_Pythia8__Nucleon_pconst_std__pairT_int_int_t_t_t_t", "std::map< Pythia8::Nucleon *,std::pair< int,int >,std::less< Pythia8::Nucleon * >,std::allocator< std::pair< Pythia8::Nucleon *const,std::pair< int,int > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t = {"_p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t", "std::map< double,std::pair< int,int > > *|std::map< double,std::pair< int,int >,std::less< double >,std::allocator< std::pair< double const,std::pair< int,int > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_int_double_std__lessT_int_t_std__allocatorT_std__pairT_int_const_double_t_t_t = {"_p_std__mapT_int_double_std__lessT_int_t_std__allocatorT_std__pairT_int_const_double_t_t_t", "std::map< int,double,std::less< int >,std::allocator< std::pair< int const,double > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t = {"_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t", "std::map< int,int,std::less< int >,std::allocator< std::pair< int const,int > > > *|std::map< int,int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t = {"_p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t", "std::map< std::string,Pythia8::FVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::FVec > > > *|std::map< std::string,Pythia8::FVec > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t = {"_p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t", "std::map< std::string,Pythia8::Flag,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Flag > > > *|std::map< std::string,Pythia8::Flag > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_std__string_Pythia8__LHAweight_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweight_t_t_t = {"_p_std__mapT_std__string_Pythia8__LHAweight_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweight_t_t_t", "std::map< std::string,Pythia8::LHAweight,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweight > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_std__string_Pythia8__LHAweightgroup_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweightgroup_t_t_t = {"_p_std__mapT_std__string_Pythia8__LHAweightgroup_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweightgroup_t_t_t", "std::map< std::string,Pythia8::LHAweightgroup,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAweightgroup > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_std__string_Pythia8__LHAwgt_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAwgt_t_t_t = {"_p_std__mapT_std__string_Pythia8__LHAwgt_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAwgt_t_t_t", "std::map< std::string,Pythia8::LHAwgt,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHAwgt > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_std__string_Pythia8__LHgenericBlock_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHgenericBlock_t_t_t = {"_p_std__mapT_std__string_Pythia8__LHgenericBlock_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHgenericBlock_t_t_t", "std::map< std::string,Pythia8::LHgenericBlock,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::LHgenericBlock > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t = {"_p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t", "std::map< std::string,Pythia8::MVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::MVec > > > *|std::map< std::string,Pythia8::MVec > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t = {"_p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t", "std::map< std::string,Pythia8::Mode > *|std::map< std::string,Pythia8::Mode,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Mode > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t = {"_p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t", "std::map< std::string,Pythia8::PVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::PVec > > > *|std::map< std::string,Pythia8::PVec > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t = {"_p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t", "std::map< std::string,Pythia8::Parm > *|std::map< std::string,Pythia8::Parm,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Parm > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_std__string_Pythia8__WVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__WVec_t_t_t = {"_p_std__mapT_std__string_Pythia8__WVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__WVec_t_t_t", "std::map< std::string,Pythia8::WVec,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::WVec > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t = {"_p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t", "std::map< std::string,Pythia8::Word,std::less< std::string >,std::allocator< std::pair< std::string const,Pythia8::Word > > > *|std::map< std::string,Pythia8::Word > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t = {"_p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t", "std::map< std::string,double,std::less< std::string >,std::allocator< std::pair< std::string const,double > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t = {"_p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t", "std::map< std::string,std::string > *|std::map< std::string,std::string,std::less< std::string >,std::allocator< std::pair< std::string const,std::string > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__multisetT_Pythia8__SubCollision_std__lessT_Pythia8__SubCollision_t_std__allocatorT_Pythia8__SubCollision_t_t = {"_p_std__multisetT_Pythia8__SubCollision_std__lessT_Pythia8__SubCollision_t_std__allocatorT_Pythia8__SubCollision_t_t", "std::multiset< Pythia8::SubCollision > *|std::multiset< Pythia8::SubCollision,std::less< Pythia8::SubCollision >,std::allocator< Pythia8::SubCollision > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__ofstream = {"_p_std__ofstream", "std::ofstream *|Pythia8::ogzstream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_Pythia8__RotBstMatrix_Pythia8__RotBstMatrix_t = {"_p_std__pairT_Pythia8__RotBstMatrix_Pythia8__RotBstMatrix_t", "std::pair< Pythia8::RotBstMatrix,Pythia8::RotBstMatrix > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_Pythia8__Vec4_Pythia8__Vec4_t = {"_p_std__pairT_Pythia8__Vec4_Pythia8__Vec4_t", "pair< Pythia8::Vec4,Pythia8::Vec4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_double_double_t = {"_p_std__pairT_double_double_t", "pair< double,double > *|std::pair< double,double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_int_int_t = {"_p_std__pairT_int_int_t", "Pythia8::HSIndex *|std::pair< int,int > *|pair< int,int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_long_long_t = {"_p_std__pairT_long_long_t", "pair< long,long > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__setT_int_std__lessT_int_t_std__allocatorT_int_t_t = {"_p_std__setT_int_std__lessT_int_t_std__allocatorT_int_t_t", "std::set< int,std::less< int >,std::allocator< int > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__string__size_type = {"_p_std__string__size_type", "std::string::size_type *|Pythia8::XMLTag::pos_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t = {"_p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t", "std::vector< Pythia8::Clustering,std::allocator< Pythia8::Clustering > > *|std::vector< Pythia8::Clustering > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t = {"_p_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t", "std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t = {"_p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t", "std::vector< Pythia8::HelicityParticle,std::allocator< Pythia8::HelicityParticle > > *|std::vector< Pythia8::HelicityParticle > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Pythia8__InBeam_std__allocatorT_Pythia8__InBeam_t_t = {"_p_std__vectorT_Pythia8__InBeam_std__allocatorT_Pythia8__InBeam_t_t", "std::vector< Pythia8::InBeam,std::allocator< Pythia8::InBeam > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Pythia8__InPair_std__allocatorT_Pythia8__InPair_t_t = {"_p_std__vectorT_Pythia8__InPair_std__allocatorT_Pythia8__InPair_t_t", "std::vector< Pythia8::InPair,std::allocator< Pythia8::InPair > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Pythia8__LHAParticle_std__allocatorT_Pythia8__LHAParticle_t_t = {"_p_std__vectorT_Pythia8__LHAParticle_std__allocatorT_Pythia8__LHAParticle_t_t", "std::vector< Pythia8::LHAParticle,std::allocator< Pythia8::LHAParticle > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Pythia8__LHAgenerator_std__allocatorT_Pythia8__LHAgenerator_t_t = {"_p_std__vectorT_Pythia8__LHAgenerator_std__allocatorT_Pythia8__LHAgenerator_t_t", "std::vector< Pythia8::LHAgenerator,std::allocator< Pythia8::LHAgenerator > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Pythia8__LHblockT_int_t_std__allocatorT_Pythia8__LHblockT_int_t_t_t = {"_p_std__vectorT_Pythia8__LHblockT_int_t_std__allocatorT_Pythia8__LHblockT_int_t_t_t", "std::vector< Pythia8::LHblock< int >,std::allocator< Pythia8::LHblock< int > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Pythia8__LHdecayTable_std__allocatorT_Pythia8__LHdecayTable_t_t = {"_p_std__vectorT_Pythia8__LHdecayTable_std__allocatorT_Pythia8__LHdecayTable_t_t", "std::vector< Pythia8::LHdecayTable,std::allocator< Pythia8::LHdecayTable > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Pythia8__Nucleon_std__allocatorT_Pythia8__Nucleon_t_t = {"_p_std__vectorT_Pythia8__Nucleon_std__allocatorT_Pythia8__Nucleon_t_t", "std::vector< Pythia8::Nucleon,std::allocator< Pythia8::Nucleon > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Pythia8__PhaseSpace_p_std__allocatorT_Pythia8__PhaseSpace_p_t_t = {"_p_std__vectorT_Pythia8__PhaseSpace_p_std__allocatorT_Pythia8__PhaseSpace_p_t_t", "std::vector< Pythia8::PhaseSpace *,std::allocator< Pythia8::PhaseSpace * > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t = {"_p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t", "std::vector< Pythia8::ProcessContainer *,std::allocator< Pythia8::ProcessContainer * > > *|std::vector< Pythia8::ProcessContainer * > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t = {"_p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t", "std::vector< Pythia8::ResonanceWidths * > *|std::vector< Pythia8::ResonanceWidths *,std::allocator< Pythia8::ResonanceWidths * > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t = {"_p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t", "std::vector< Pythia8::SigmaProcess *,std::allocator< Pythia8::SigmaProcess * > > *|std::vector< Pythia8::SigmaProcess * > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Pythia8__StringRegion_std__allocatorT_Pythia8__StringRegion_t_t = {"_p_std__vectorT_Pythia8__StringRegion_std__allocatorT_Pythia8__StringRegion_t_t", "std::vector< Pythia8::StringRegion,std::allocator< Pythia8::StringRegion > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Pythia8__StringVertex_std__allocatorT_Pythia8__StringVertex_t_t = {"_p_std__vectorT_Pythia8__StringVertex_std__allocatorT_Pythia8__StringVertex_t_t", "std::vector< Pythia8::StringVertex,std::allocator< Pythia8::StringVertex > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Pythia8__UserHooks_p_std__allocatorT_Pythia8__UserHooks_p_t_t = {"_p_std__vectorT_Pythia8__UserHooks_p_std__allocatorT_Pythia8__UserHooks_p_t_t", "std::vector< Pythia8::UserHooks *,std::allocator< Pythia8::UserHooks * > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t = {"_p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t", "std::vector< Pythia8::Vec4 > *|std::vector< Pythia8::Vec4,std::allocator< Pythia8::Vec4 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Pythia8__XMLTag_p_std__allocatorT_Pythia8__XMLTag_p_t_t = {"_p_std__vectorT_Pythia8__XMLTag_p_std__allocatorT_Pythia8__XMLTag_p_t_t", "std::vector< Pythia8::XMLTag *,std::allocator< Pythia8::XMLTag * > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_bool_std__allocatorT_bool_t_t = {"_p_std__vectorT_bool_std__allocatorT_bool_t_t", "std::vector< bool,std::allocator< bool > > *|std::vector< bool > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_double_std__allocatorT_double_t_t = {"_p_std__vectorT_double_std__allocatorT_double_t_t", "std::vector< double,std::allocator< double > > *|std::vector< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_int_std__allocatorT_int_t_t = {"_p_std__vectorT_int_std__allocatorT_int_t_t", "std::vector< int,std::allocator< int > > *|std::vector< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_long_std__allocatorT_long_t_t = {"_p_std__vectorT_long_std__allocatorT_long_t_t", "std::vector< long,std::allocator< long > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t = {"_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t", "std::vector< std::complex< double > > *|std::vector< std::complex< double >,std::allocator< std::complex< double > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t = {"_p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t", "std::vector< std::pair< int,int > > *|std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t = {"_p_std__vectorT_std__string_std__allocatorT_std__string_t_t", "std::vector< std::string,std::allocator< std::string > > *|std::vector< std::string > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t_std__allocatorT_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t_t_t = {"_p_std__vectorT_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t_std__allocatorT_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t_t_t", "std::vector< std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > >,std::allocator< std::vector< Pythia8::ColourDipole *,std::allocator< Pythia8::ColourDipole * > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t = {"_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t", "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t = {"_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t", "std::vector< std::vector< int > > *|std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *|std::vector< std::vector< int,std::allocator< int > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t = {"_p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t", "std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > >,std::allocator< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > *|std::vector< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > *|std::vector< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > >,std::allocator< std::vector< Pythia8::complex,std::allocator< Pythia8::complex > > > > *|std::vector< std::vector< std::complex< double > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t_std__allocatorT_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t_t_t = {"_p_std__vectorT_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t_std__allocatorT_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t_t_t", "std::vector< std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >,std::allocator< std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_streamoff = {"_p_streamoff", "std::basic_ostream< char >::off_type *|std::basic_istream< char >::off_type *|std::basic_streambuf< char >::off_type *|streamoff *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_streampos = {"_p_streampos", "std::basic_ostream< char >::pos_type *|std::basic_istream< char >::pos_type *|std::basic_streambuf< char >::pos_type *|streampos *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_stringstream = {"_p_stringstream", "stringstream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_swig__SwigPyIterator = {"_p_swig__SwigPyIterator", "swig::SwigPyIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_traits_type = {"_p_traits_type", "traits_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "unsigned long long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_Pythia8__AlpgenHooks,
  &_swigt__p_Pythia8__AlpgenPar,
  &_swigt__p_Pythia8__AlphaEM,
  &_swigt__p_Pythia8__AlphaStrong,
  &_swigt__p_Pythia8__Angantyr,
  &_swigt__p_Pythia8__BeamParticle,
  &_swigt__p_Pythia8__BeamRemnants,
  &_swigt__p_Pythia8__BeamShape,
  &_swigt__p_Pythia8__BoseEinstein,
  &_swigt__p_Pythia8__BoseEinsteinHadron,
  &_swigt__p_Pythia8__CJKL,
  &_swigt__p_Pythia8__CTEQ5L,
  &_swigt__p_Pythia8__CTEQ6pdf,
  &_swigt__p_Pythia8__CellJet,
  &_swigt__p_Pythia8__ClusterJet,
  &_swigt__p_Pythia8__Clustering,
  &_swigt__p_Pythia8__ColConfig,
  &_swigt__p_Pythia8__ColSinglet,
  &_swigt__p_Pythia8__ColourDipole,
  &_swigt__p_Pythia8__ColourJunction,
  &_swigt__p_Pythia8__ColourParticle,
  &_swigt__p_Pythia8__ColourReconnection,
  &_swigt__p_Pythia8__ColourTracing,
  &_swigt__p_Pythia8__CombineMatchingInput,
  &_swigt__p_Pythia8__CoupSM,
  &_swigt__p_Pythia8__CoupSUSY,
  &_swigt__p_Pythia8__Couplings,
  &_swigt__p_Pythia8__DecayChannel,
  &_swigt__p_Pythia8__DecayHandler,
  &_swigt__p_Pythia8__DoubleStrikman,
  &_swigt__p_Pythia8__DummyForStreams,
  &_swigt__p_Pythia8__EPAexternal,
  &_swigt__p_Pythia8__EPPS16,
  &_swigt__p_Pythia8__EPS09,
  &_swigt__p_Pythia8__Event,
  &_swigt__p_Pythia8__EventInfo,
  &_swigt__p_Pythia8__FVec,
  &_swigt__p_Pythia8__Flag,
  &_swigt__p_Pythia8__FlavContainer,
  &_swigt__p_Pythia8__FlavourRope,
  &_swigt__p_Pythia8__GLISSANDOModel,
  &_swigt__p_Pythia8__GRV94L,
  &_swigt__p_Pythia8__GRVpiL,
  &_swigt__p_Pythia8__GammaKinematics,
  &_swigt__p_Pythia8__GammaMatrix,
  &_swigt__p_Pythia8__GammaPoint,
  &_swigt__p_Pythia8__HEPEUP,
  &_swigt__p_Pythia8__HEPRUP,
  &_swigt__p_Pythia8__HIInfo,
  &_swigt__p_Pythia8__HIUserHooks,
  &_swigt__p_Pythia8__HJSlowJet,
  &_swigt__p_Pythia8__HMEGamma2TwoFermions,
  &_swigt__p_Pythia8__HMEHiggs2TwoFermions,
  &_swigt__p_Pythia8__HMETau2FivePions,
  &_swigt__p_Pythia8__HMETau2FourPions,
  &_swigt__p_Pythia8__HMETau2Meson,
  &_swigt__p_Pythia8__HMETau2PhaseSpace,
  &_swigt__p_Pythia8__HMETau2ThreeMesons,
  &_swigt__p_Pythia8__HMETau2ThreeMesonsGeneric,
  &_swigt__p_Pythia8__HMETau2ThreeMesonsWithKaons,
  &_swigt__p_Pythia8__HMETau2ThreePions,
  &_swigt__p_Pythia8__HMETau2TwoLeptons,
  &_swigt__p_Pythia8__HMETau2TwoMesonsViaVector,
  &_swigt__p_Pythia8__HMETau2TwoMesonsViaVectorScalar,
  &_swigt__p_Pythia8__HMETau2TwoPionsGamma,
  &_swigt__p_Pythia8__HMETauDecay,
  &_swigt__p_Pythia8__HMETwoFermions2GammaZ2TwoFermions,
  &_swigt__p_Pythia8__HMETwoFermions2W2TwoFermions,
  &_swigt__p_Pythia8__HMEW2TwoFermions,
  &_swigt__p_Pythia8__HMEX2TwoFermions,
  &_swigt__p_Pythia8__HMEZ2TwoFermions,
  &_swigt__p_Pythia8__HVStringFlav,
  &_swigt__p_Pythia8__HVStringPT,
  &_swigt__p_Pythia8__HVStringZ,
  &_swigt__p_Pythia8__HadronLevel,
  &_swigt__p_Pythia8__HadronScatter,
  &_swigt__p_Pythia8__HadronScatterPair,
  &_swigt__p_Pythia8__HardDiffraction,
  &_swigt__p_Pythia8__HardProcess,
  &_swigt__p_Pythia8__HeavyIons,
  &_swigt__p_Pythia8__HelicityMatrixElement,
  &_swigt__p_Pythia8__HelicityParticle,
  &_swigt__p_Pythia8__HiddenValleyFragmentation,
  &_swigt__p_Pythia8__Hist,
  &_swigt__p_Pythia8__HistPlot,
  &_swigt__p_Pythia8__History,
  &_swigt__p_Pythia8__ImpactParameterGenerator,
  &_swigt__p_Pythia8__InBeam,
  &_swigt__p_Pythia8__InPair,
  &_swigt__p_Pythia8__Info,
  &_swigt__p_Pythia8__Isospin,
  &_swigt__p_Pythia8__JetMatching,
  &_swigt__p_Pythia8__JetMatchingAlpgen,
  &_swigt__p_Pythia8__JetMatchingAlpgenInputAlpgen,
  &_swigt__p_Pythia8__JetMatchingMadgraph,
  &_swigt__p_Pythia8__JetMatchingMadgraphInputAlpgen,
  &_swigt__p_Pythia8__Junction,
  &_swigt__p_Pythia8__JunctionSplitting,
  &_swigt__p_Pythia8__LHAGrid1,
  &_swigt__p_Pythia8__LHAPDF,
  &_swigt__p_Pythia8__LHAParticle,
  &_swigt__p_Pythia8__LHAProcess,
  &_swigt__p_Pythia8__LHAgenerator,
  &_swigt__p_Pythia8__LHAinitrwgt,
  &_swigt__p_Pythia8__LHArwgt,
  &_swigt__p_Pythia8__LHAscales,
  &_swigt__p_Pythia8__LHAup,
  &_swigt__p_Pythia8__LHAupAlpgen,
  &_swigt__p_Pythia8__LHAupFromPYTHIA8,
  &_swigt__p_Pythia8__LHAupHelaconia,
  &_swigt__p_Pythia8__LHAupLHEF,
  &_swigt__p_Pythia8__LHAupMadgraph,
  &_swigt__p_Pythia8__LHAweight,
  &_swigt__p_Pythia8__LHAweightgroup,
  &_swigt__p_Pythia8__LHAweights,
  &_swigt__p_Pythia8__LHAwgt,
  &_swigt__p_Pythia8__LHEF3FromPythia8,
  &_swigt__p_Pythia8__LHblockT_double_t,
  &_swigt__p_Pythia8__LHblockT_int_t,
  &_swigt__p_Pythia8__LHblockT_std__string_t,
  &_swigt__p_Pythia8__LHdecayChannel,
  &_swigt__p_Pythia8__LHdecayTable,
  &_swigt__p_Pythia8__LHgenericBlock,
  &_swigt__p_Pythia8__LHmatrixBlockT_2_t,
  &_swigt__p_Pythia8__LHmatrixBlockT_3_t,
  &_swigt__p_Pythia8__LHmatrixBlockT_4_t,
  &_swigt__p_Pythia8__LHmatrixBlockT_5_t,
  &_swigt__p_Pythia8__LHmatrixBlockT_6_t,
  &_swigt__p_Pythia8__LHmatrixBlockT_7_t,
  &_swigt__p_Pythia8__LHmatrixBlockT_8_t,
  &_swigt__p_Pythia8__LHtensor3BlockT_3_t,
  &_swigt__p_Pythia8__Lepton,
  &_swigt__p_Pythia8__Lepton2gamma,
  &_swigt__p_Pythia8__LeptonPoint,
  &_swigt__p_Pythia8__LundFFAvg,
  &_swigt__p_Pythia8__LundFFRaw,
  &_swigt__p_Pythia8__MBReconUserHooks,
  &_swigt__p_Pythia8__MSTWpdf,
  &_swigt__p_Pythia8__MVec,
  &_swigt__p_Pythia8__MadgraphPar,
  &_swigt__p_Pythia8__Merging,
  &_swigt__p_Pythia8__MergingHooks,
  &_swigt__p_Pythia8__MiniStringFragmentation,
  &_swigt__p_Pythia8__Mode,
  &_swigt__p_Pythia8__MultiRadial,
  &_swigt__p_Pythia8__MultipartonInteractions,
  &_swigt__p_Pythia8__NNPDF,
  &_swigt__p_Pythia8__NaiveSubCollisionModel,
  &_swigt__p_Pythia8__NeutrinoPoint,
  &_swigt__p_Pythia8__Nucleon,
  &_swigt__p_Pythia8__NucleusModel,
  &_swigt__p_Pythia8__OverlappingRopeDipole,
  &_swigt__p_Pythia8__PDF,
  &_swigt__p_Pythia8__PDF__PDFEnvelope,
  &_swigt__p_Pythia8__PVec,
  &_swigt__p_Pythia8__Parm,
  &_swigt__p_Pythia8__Particle,
  &_swigt__p_Pythia8__ParticleData,
  &_swigt__p_Pythia8__ParticleDataEntry,
  &_swigt__p_Pythia8__ParticleDecays,
  &_swigt__p_Pythia8__PartonLevel,
  &_swigt__p_Pythia8__PartonSystem,
  &_swigt__p_Pythia8__PartonSystems,
  &_swigt__p_Pythia8__PartonVertex,
  &_swigt__p_Pythia8__PhaseSpace,
  &_swigt__p_Pythia8__PhaseSpace2to1tauy,
  &_swigt__p_Pythia8__PhaseSpace2to2diffractive,
  &_swigt__p_Pythia8__PhaseSpace2to2elastic,
  &_swigt__p_Pythia8__PhaseSpace2to2nondiffractive,
  &_swigt__p_Pythia8__PhaseSpace2to2nondiffractiveGamma,
  &_swigt__p_Pythia8__PhaseSpace2to2tauyz,
  &_swigt__p_Pythia8__PhaseSpace2to3diffractive,
  &_swigt__p_Pythia8__PhaseSpace2to3tauycyl,
  &_swigt__p_Pythia8__PhaseSpace2to3yyycyl,
  &_swigt__p_Pythia8__PhaseSpaceLHA,
  &_swigt__p_Pythia8__PomFix,
  &_swigt__p_Pythia8__PomH1FitAB,
  &_swigt__p_Pythia8__PomH1Jets,
  &_swigt__p_Pythia8__PomHISASD,
  &_swigt__p_Pythia8__PowhegHooks,
  &_swigt__p_Pythia8__PowhegProcs,
  &_swigt__p_Pythia8__ProcessContainer,
  &_swigt__p_Pythia8__ProcessLevel,
  &_swigt__p_Pythia8__ProgressLog,
  &_swigt__p_Pythia8__ProtonPoint,
  &_swigt__p_Pythia8__Pythia,
  &_swigt__p_Pythia8__RHadrons,
  &_swigt__p_Pythia8__Reader,
  &_swigt__p_Pythia8__ResolvedParton,
  &_swigt__p_Pythia8__ResonanceChar,
  &_swigt__p_Pythia8__ResonanceDecays,
  &_swigt__p_Pythia8__ResonanceExcited,
  &_swigt__p_Pythia8__ResonanceFour,
  &_swigt__p_Pythia8__ResonanceGeneric,
  &_swigt__p_Pythia8__ResonanceGluino,
  &_swigt__p_Pythia8__ResonanceGmZ,
  &_swigt__p_Pythia8__ResonanceGraviton,
  &_swigt__p_Pythia8__ResonanceH,
  &_swigt__p_Pythia8__ResonanceHchg,
  &_swigt__p_Pythia8__ResonanceHchgchgLeft,
  &_swigt__p_Pythia8__ResonanceHchgchgRight,
  &_swigt__p_Pythia8__ResonanceKKgluon,
  &_swigt__p_Pythia8__ResonanceLeptoquark,
  &_swigt__p_Pythia8__ResonanceNeut,
  &_swigt__p_Pythia8__ResonanceNuRight,
  &_swigt__p_Pythia8__ResonanceRhorizontal,
  &_swigt__p_Pythia8__ResonanceS,
  &_swigt__p_Pythia8__ResonanceSlepton,
  &_swigt__p_Pythia8__ResonanceSquark,
  &_swigt__p_Pythia8__ResonanceTop,
  &_swigt__p_Pythia8__ResonanceW,
  &_swigt__p_Pythia8__ResonanceWRight,
  &_swigt__p_Pythia8__ResonanceWidths,
  &_swigt__p_Pythia8__ResonanceWprime,
  &_swigt__p_Pythia8__ResonanceZRight,
  &_swigt__p_Pythia8__ResonanceZp,
  &_swigt__p_Pythia8__ResonanceZprime,
  &_swigt__p_Pythia8__Rndm,
  &_swigt__p_Pythia8__RndmEngine,
  &_swigt__p_Pythia8__RopeDipole,
  &_swigt__p_Pythia8__RopeDipoleEnd,
  &_swigt__p_Pythia8__RopeFragPars,
  &_swigt__p_Pythia8__Ropewalk,
  &_swigt__p_Pythia8__RotBstMatrix,
  &_swigt__p_Pythia8__SLHAinterface,
  &_swigt__p_Pythia8__SUSYResonanceWidths,
  &_swigt__p_Pythia8__Settings,
  &_swigt__p_Pythia8__SetupContainers,
  &_swigt__p_Pythia8__Sigma0AB2AB,
  &_swigt__p_Pythia8__Sigma0AB2AX,
  &_swigt__p_Pythia8__Sigma0AB2AXB,
  &_swigt__p_Pythia8__Sigma0AB2XB,
  &_swigt__p_Pythia8__Sigma0AB2XX,
  &_swigt__p_Pythia8__Sigma0Process,
  &_swigt__p_Pythia8__Sigma0nonDiffractive,
  &_swigt__p_Pythia8__Sigma1Process,
  &_swigt__p_Pythia8__Sigma1ffbar2GravitonStar,
  &_swigt__p_Pythia8__Sigma1ffbar2H,
  &_swigt__p_Pythia8__Sigma1ffbar2Hchg,
  &_swigt__p_Pythia8__Sigma1ffbar2Rhorizontal,
  &_swigt__p_Pythia8__Sigma1ffbar2W,
  &_swigt__p_Pythia8__Sigma1ffbar2WRight,
  &_swigt__p_Pythia8__Sigma1ffbar2Wprime,
  &_swigt__p_Pythia8__Sigma1ffbar2ZRight,
  &_swigt__p_Pythia8__Sigma1ffbar2Zp2XX,
  &_swigt__p_Pythia8__Sigma1ffbar2Zv,
  &_swigt__p_Pythia8__Sigma1ffbar2gmZ,
  &_swigt__p_Pythia8__Sigma1ffbar2gmZZprime,
  &_swigt__p_Pythia8__Sigma1ffbarZprimeWprime,
  &_swigt__p_Pythia8__Sigma1gg2GravitonStar,
  &_swigt__p_Pythia8__Sigma1gg2H,
  &_swigt__p_Pythia8__Sigma1gg2S2XX,
  &_swigt__p_Pythia8__Sigma1gmgm2H,
  &_swigt__p_Pythia8__Sigma1lgm2lStar,
  &_swigt__p_Pythia8__Sigma1ll2Hchgchg,
  &_swigt__p_Pythia8__Sigma1qg2qStar,
  &_swigt__p_Pythia8__Sigma1ql2LeptoQuark,
  &_swigt__p_Pythia8__Sigma1qq2antisquark,
  &_swigt__p_Pythia8__Sigma1qqbar2KKgluonStar,
  &_swigt__p_Pythia8__Sigma2Process,
  &_swigt__p_Pythia8__Sigma2QCffbar2llbar,
  &_swigt__p_Pythia8__Sigma2QCqq2qq,
  &_swigt__p_Pythia8__Sigma2QCqqbar2qqbar,
  &_swigt__p_Pythia8__Sigma2SUSY,
  &_swigt__p_Pythia8__Sigma2ff2fftW,
  &_swigt__p_Pythia8__Sigma2ff2fftgmZ,
  &_swigt__p_Pythia8__Sigma2ffbar2A3H12,
  &_swigt__p_Pythia8__Sigma2ffbar2FFbarsgmZ,
  &_swigt__p_Pythia8__Sigma2ffbar2FfbarsW,
  &_swigt__p_Pythia8__Sigma2ffbar2HW,
  &_swigt__p_Pythia8__Sigma2ffbar2HZ,
  &_swigt__p_Pythia8__Sigma2ffbar2HchgH12,
  &_swigt__p_Pythia8__Sigma2ffbar2HchgchgHchgchg,
  &_swigt__p_Pythia8__Sigma2ffbar2HposHneg,
  &_swigt__p_Pythia8__Sigma2ffbar2LEDUnparticleZ,
  &_swigt__p_Pythia8__Sigma2ffbar2LEDUnparticlegamma,
  &_swigt__p_Pythia8__Sigma2ffbar2LEDgammagamma,
  &_swigt__p_Pythia8__Sigma2ffbar2LEDllbar,
  &_swigt__p_Pythia8__Sigma2ffbar2TEVffbar,
  &_swigt__p_Pythia8__Sigma2ffbar2WW,
  &_swigt__p_Pythia8__Sigma2ffbar2Wgm,
  &_swigt__p_Pythia8__Sigma2ffbar2ZW,
  &_swigt__p_Pythia8__Sigma2ffbar2ZpH,
  &_swigt__p_Pythia8__Sigma2ffbar2fGfGbar,
  &_swigt__p_Pythia8__Sigma2ffbar2ffbarsW,
  &_swigt__p_Pythia8__Sigma2ffbar2ffbarsgm,
  &_swigt__p_Pythia8__Sigma2ffbar2ffbarsgmZ,
  &_swigt__p_Pythia8__Sigma2ffbar2gammagamma,
  &_swigt__p_Pythia8__Sigma2ffbar2gmZgm,
  &_swigt__p_Pythia8__Sigma2ffbar2gmZgmZ,
  &_swigt__p_Pythia8__Sigma2ffbarWggm,
  &_swigt__p_Pythia8__Sigma2ffbargmZWgmZW,
  &_swigt__p_Pythia8__Sigma2ffbargmZggm,
  &_swigt__p_Pythia8__Sigma2fgm2Wf,
  &_swigt__p_Pythia8__Sigma2fgm2gmZf,
  &_swigt__p_Pythia8__Sigma2gg2GravitonStarg,
  &_swigt__p_Pythia8__Sigma2gg2Hglt,
  &_swigt__p_Pythia8__Sigma2gg2LEDUnparticleg,
  &_swigt__p_Pythia8__Sigma2gg2LEDgammagamma,
  &_swigt__p_Pythia8__Sigma2gg2LEDgg,
  &_swigt__p_Pythia8__Sigma2gg2LEDllbar,
  &_swigt__p_Pythia8__Sigma2gg2LEDqqbar,
  &_swigt__p_Pythia8__Sigma2gg2LQLQbar,
  &_swigt__p_Pythia8__Sigma2gg2QQbar,
  &_swigt__p_Pythia8__Sigma2gg2QQbar3DJ1g,
  &_swigt__p_Pythia8__Sigma2gg2QQbar3PJ1g,
  &_swigt__p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11,
  &_swigt__p_Pythia8__Sigma2gg2QQbar3S11g,
  &_swigt__p_Pythia8__Sigma2gg2QQbar3S11gm,
  &_swigt__p_Pythia8__Sigma2gg2QQbarX8g,
  &_swigt__p_Pythia8__Sigma2gg2Sg2XXj,
  &_swigt__p_Pythia8__Sigma2gg2gammagamma,
  &_swigt__p_Pythia8__Sigma2gg2gg,
  &_swigt__p_Pythia8__Sigma2gg2ggamma,
  &_swigt__p_Pythia8__Sigma2gg2gluinogluino,
  &_swigt__p_Pythia8__Sigma2gg2qGqGbar,
  &_swigt__p_Pythia8__Sigma2gg2qqbar,
  &_swigt__p_Pythia8__Sigma2gg2squarkantisquark,
  &_swigt__p_Pythia8__Sigma2ggm2qqbar,
  &_swigt__p_Pythia8__Sigma2gmgm2ffbar,
  &_swigt__p_Pythia8__Sigma2lgm2Hchgchgl,
  &_swigt__p_Pythia8__Sigma2qg2GravitonStarq,
  &_swigt__p_Pythia8__Sigma2qg2Hchgq,
  &_swigt__p_Pythia8__Sigma2qg2Hq,
  &_swigt__p_Pythia8__Sigma2qg2Hqlt,
  &_swigt__p_Pythia8__Sigma2qg2LEDUnparticleq,
  &_swigt__p_Pythia8__Sigma2qg2LEDqg,
  &_swigt__p_Pythia8__Sigma2qg2LeptoQuarkl,
  &_swigt__p_Pythia8__Sigma2qg2QQbar3PJ1q,
  &_swigt__p_Pythia8__Sigma2qg2QQbarX8q,
  &_swigt__p_Pythia8__Sigma2qg2Sq2XXj,
  &_swigt__p_Pythia8__Sigma2qg2Wq,
  &_swigt__p_Pythia8__Sigma2qg2Zpq2XXj,
  &_swigt__p_Pythia8__Sigma2qg2charsquark,
  &_swigt__p_Pythia8__Sigma2qg2chi0squark,
  &_swigt__p_Pythia8__Sigma2qg2gmZq,
  &_swigt__p_Pythia8__Sigma2qg2qg,
  &_swigt__p_Pythia8__Sigma2qg2qgamma,
  &_swigt__p_Pythia8__Sigma2qg2squarkgluino,
  &_swigt__p_Pythia8__Sigma2qgm2qg,
  &_swigt__p_Pythia8__Sigma2qgm2qgm,
  &_swigt__p_Pythia8__Sigma2qq2LEDqq,
  &_swigt__p_Pythia8__Sigma2qq2QqtW,
  &_swigt__p_Pythia8__Sigma2qq2qStarq,
  &_swigt__p_Pythia8__Sigma2qq2qq,
  &_swigt__p_Pythia8__Sigma2qq2squarksquark,
  &_swigt__p_Pythia8__Sigma2qqbar2GravitonStarg,
  &_swigt__p_Pythia8__Sigma2qqbar2Hglt,
  &_swigt__p_Pythia8__Sigma2qqbar2LEDUnparticleg,
  &_swigt__p_Pythia8__Sigma2qqbar2LEDgg,
  &_swigt__p_Pythia8__Sigma2qqbar2LEDqqbarNew,
  &_swigt__p_Pythia8__Sigma2qqbar2LQLQbar,
  &_swigt__p_Pythia8__Sigma2qqbar2QQbar,
  &_swigt__p_Pythia8__Sigma2qqbar2QQbar3PJ1g,
  &_swigt__p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11,
  &_swigt__p_Pythia8__Sigma2qqbar2QQbarX8g,
  &_swigt__p_Pythia8__Sigma2qqbar2Wg,
  &_swigt__p_Pythia8__Sigma2qqbar2Zpg2XXj,
  &_swigt__p_Pythia8__Sigma2qqbar2charchar,
  &_swigt__p_Pythia8__Sigma2qqbar2charchi0,
  &_swigt__p_Pythia8__Sigma2qqbar2chargluino,
  &_swigt__p_Pythia8__Sigma2qqbar2chi0chi0,
  &_swigt__p_Pythia8__Sigma2qqbar2chi0gluino,
  &_swigt__p_Pythia8__Sigma2qqbar2gg,
  &_swigt__p_Pythia8__Sigma2qqbar2ggamma,
  &_swigt__p_Pythia8__Sigma2qqbar2gluinogluino,
  &_swigt__p_Pythia8__Sigma2qqbar2gmZg,
  &_swigt__p_Pythia8__Sigma2qqbar2lStarlStarBar,
  &_swigt__p_Pythia8__Sigma2qqbar2lStarlbar,
  &_swigt__p_Pythia8__Sigma2qqbar2qGqGbar,
  &_swigt__p_Pythia8__Sigma2qqbar2qqbarNew,
  &_swigt__p_Pythia8__Sigma2qqbar2sleptonantislepton,
  &_swigt__p_Pythia8__Sigma2qqbar2squarkantisquark,
  &_swigt__p_Pythia8__Sigma3Process,
  &_swigt__p_Pythia8__Sigma3ff2HchgchgfftWW,
  &_swigt__p_Pythia8__Sigma3ff2HfftWW,
  &_swigt__p_Pythia8__Sigma3ff2HfftZZ,
  &_swigt__p_Pythia8__Sigma3gg2HQQbar,
  &_swigt__p_Pythia8__Sigma3gg2ggg,
  &_swigt__p_Pythia8__Sigma3gg2qqbarg,
  &_swigt__p_Pythia8__Sigma3qg2qgg,
  &_swigt__p_Pythia8__Sigma3qg2qqqbarDiff,
  &_swigt__p_Pythia8__Sigma3qg2qqqbarSame,
  &_swigt__p_Pythia8__Sigma3qq2qqgDiff,
  &_swigt__p_Pythia8__Sigma3qq2qqgSame,
  &_swigt__p_Pythia8__Sigma3qqbar2HQQbar,
  &_swigt__p_Pythia8__Sigma3qqbar2ggg,
  &_swigt__p_Pythia8__Sigma3qqbar2qqbargDiff,
  &_swigt__p_Pythia8__Sigma3qqbar2qqbargSame,
  &_swigt__p_Pythia8__SigmaABMST,
  &_swigt__p_Pythia8__SigmaLHAProcess,
  &_swigt__p_Pythia8__SigmaMBR,
  &_swigt__p_Pythia8__SigmaMultiparton,
  &_swigt__p_Pythia8__SigmaOniaSetup,
  &_swigt__p_Pythia8__SigmaPartialWave,
  &_swigt__p_Pythia8__SigmaProcess,
  &_swigt__p_Pythia8__SigmaRPP,
  &_swigt__p_Pythia8__SigmaSaSDL,
  &_swigt__p_Pythia8__SigmaTotAux,
  &_swigt__p_Pythia8__SigmaTotOwn,
  &_swigt__p_Pythia8__SigmaTotal,
  &_swigt__p_Pythia8__SingleCell,
  &_swigt__p_Pythia8__SingleCellJet,
  &_swigt__p_Pythia8__SingleClusterJet,
  &_swigt__p_Pythia8__SingleSlowJet,
  &_swigt__p_Pythia8__SlowJet,
  &_swigt__p_Pythia8__SlowJetHook,
  &_swigt__p_Pythia8__SpaceDipoleEnd,
  &_swigt__p_Pythia8__SpaceShower,
  &_swigt__p_Pythia8__Sphericity,
  &_swigt__p_Pythia8__StauWidths,
  &_swigt__p_Pythia8__StringEnd,
  &_swigt__p_Pythia8__StringFlav,
  &_swigt__p_Pythia8__StringFragmentation,
  &_swigt__p_Pythia8__StringLength,
  &_swigt__p_Pythia8__StringPT,
  &_swigt__p_Pythia8__StringRegion,
  &_swigt__p_Pythia8__StringSystem,
  &_swigt__p_Pythia8__StringVertex,
  &_swigt__p_Pythia8__StringZ,
  &_swigt__p_Pythia8__SubCollision,
  &_swigt__p_Pythia8__SubCollisionModel,
  &_swigt__p_Pythia8__SubCollisionModel__SigEst,
  &_swigt__p_Pythia8__SuppressSmallPT,
  &_swigt__p_Pythia8__SusyLesHouches,
  &_swigt__p_Pythia8__TauDecays,
  &_swigt__p_Pythia8__Thrust,
  &_swigt__p_Pythia8__TimeDipoleEnd,
  &_swigt__p_Pythia8__TimeShower,
  &_swigt__p_Pythia8__TopReconUserHooks,
  &_swigt__p_Pythia8__TrialReconnection,
  &_swigt__p_Pythia8__UserHooks,
  &_swigt__p_Pythia8__UserHooksVector,
  &_swigt__p_Pythia8__Vec4,
  &_swigt__p_Pythia8__WVec,
  &_swigt__p_Pythia8__Wave4,
  &_swigt__p_Pythia8__WeakShowerMEs,
  &_swigt__p_Pythia8__WidthFunction,
  &_swigt__p_Pythia8__WoodsSaxonModel,
  &_swigt__p_Pythia8__Word,
  &_swigt__p_Pythia8__Writer,
  &_swigt__p_Pythia8__XMLTag,
  &_swigt__p_Pythia8__amcnlo_unitarised_interface,
  &_swigt__p_Pythia8__nPDF,
  &_swigt__p_State,
  &_swigt__p_a_3__std__complexT_double_t,
  &_swigt__p_a_4__std__complexT_double_t,
  &_swigt__p_a_6__std__complexT_double_t,
  &_swigt__p_a_7__std__complexT_double_t,
  &_swigt__p_a_8__double,
  &_swigt__p_allocator_type,
  &_swigt__p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  &_swigt__p_bool,
  &_swigt__p_char,
  &_swigt__p_char_type,
  &_swigt__p_const_reference,
  &_swigt__p_difference_type,
  &_swigt__p_double,
  &_swigt__p_f_enum_std__ios_base__event_r_std__ios_base_int__void,
  &_swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t,
  &_swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t,
  &_swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t,
  &_swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  &_swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t,
  &_swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  &_swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  &_swigt__p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t,
  &_swigt__p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t,
  &_swigt__p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  &_swigt__p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  &_swigt__p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t,
  &_swigt__p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t,
  &_swigt__p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  &_swigt__p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  &_swigt__p_f_r_std__ios_base__r_std__basic_iosT_char_std__char_traitsT_char_t_t,
  &_swigt__p_f_r_std__ios_base__r_std__basic_iostreamT_char_std__char_traitsT_char_t_t,
  &_swigt__p_f_r_std__ios_base__r_std__basic_istreamT_char_std__char_traitsT_char_t_t,
  &_swigt__p_f_r_std__ios_base__r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  &_swigt__p_f_r_std__ios_base__r_std__basic_ostreamT_char_std__char_traitsT_char_t_t,
  &_swigt__p_f_r_std__ios_base__r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  &_swigt__p_f_r_std__ios_base__r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  &_swigt__p_f_r_std__ios_base__r_std__ios_base,
  &_swigt__p_first_type,
  &_swigt__p_float,
  &_swigt__p_fmtflags,
  &_swigt__p_ifstream,
  &_swigt__p_int,
  &_swigt__p_int_type,
  &_swigt__p_iostate,
  &_swigt__p_key_type,
  &_swigt__p_long,
  &_swigt__p_long_double,
  &_swigt__p_long_long,
  &_swigt__p_mapped_type,
  &_swigt__p_off_type,
  &_swigt__p_openmode,
  &_swigt__p_p_PyObject,
  &_swigt__p_p_Pythia8__ColourDipole,
  &_swigt__p_p_std__basic_iostreamT_char_std__char_traitsT_char_t_t,
  &_swigt__p_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,
  &_swigt__p_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  &_swigt__p_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  &_swigt__p_p_void,
  &_swigt__p_pos_t,
  &_swigt__p_pos_type,
  &_swigt__p_reference,
  &_swigt__p_second_type,
  &_swigt__p_seekdir,
  &_swigt__p_short,
  &_swigt__p_size_t,
  &_swigt__p_size_type,
  &_swigt__p_state_type,
  &_swigt__p_std__allocatorT_Pythia8__Clustering_t,
  &_swigt__p_std__allocatorT_Pythia8__HelicityParticle_t,
  &_swigt__p_std__allocatorT_Pythia8__ProcessContainer_p_t,
  &_swigt__p_std__allocatorT_Pythia8__ResonanceWidths_p_t,
  &_swigt__p_std__allocatorT_Pythia8__SigmaProcess_p_t,
  &_swigt__p_std__allocatorT_Pythia8__Vec4_t,
  &_swigt__p_std__allocatorT_bool_t,
  &_swigt__p_std__allocatorT_double_t,
  &_swigt__p_std__allocatorT_int_t,
  &_swigt__p_std__allocatorT_std__complexT_double_t_t,
  &_swigt__p_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t,
  &_swigt__p_std__allocatorT_std__pairT_int_const_int_t_t,
  &_swigt__p_std__allocatorT_std__pairT_int_int_t_t,
  &_swigt__p_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t,
  &_swigt__p_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t,
  &_swigt__p_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t,
  &_swigt__p_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t,
  &_swigt__p_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t,
  &_swigt__p_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t,
  &_swigt__p_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t,
  &_swigt__p_std__allocatorT_std__pairT_std__string_const_std__string_t_t,
  &_swigt__p_std__allocatorT_std__string_t,
  &_swigt__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t,
  &_swigt__p_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t,
  &_swigt__p_std__basic_iosT_char_std__char_traitsT_char_t_t,
  &_swigt__p_std__basic_iostreamT_char_std__char_traitsT_char_t_t,
  &_swigt__p_std__basic_istreamT_char_std__char_traitsT_char_t_t,
  &_swigt__p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  &_swigt__p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,
  &_swigt__p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  &_swigt__p_std__basic_streambufT_char_std__char_traitsT_char_t_t,
  &_swigt__p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  &_swigt__p_std__basic_stringbufT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  &_swigt__p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  &_swigt__p_std__complexT_double_t,
  &_swigt__p_std__ifstream,
  &_swigt__p_std__invalid_argument,
  &_swigt__p_std__ios_base,
  &_swigt__p_std__lessT_double_t,
  &_swigt__p_std__lessT_int_t,
  &_swigt__p_std__lessT_std__string_t,
  &_swigt__p_std__locale,
  &_swigt__p_std__mapT_Pythia8__Nucleon_p_std__pairT_int_int_t_std__lessT_Pythia8__Nucleon_p_t_std__allocatorT_std__pairT_Pythia8__Nucleon_pconst_std__pairT_int_int_t_t_t_t,
  &_swigt__p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t,
  &_swigt__p_std__mapT_int_double_std__lessT_int_t_std__allocatorT_std__pairT_int_const_double_t_t_t,
  &_swigt__p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t,
  &_swigt__p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t,
  &_swigt__p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t,
  &_swigt__p_std__mapT_std__string_Pythia8__LHAweight_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweight_t_t_t,
  &_swigt__p_std__mapT_std__string_Pythia8__LHAweightgroup_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweightgroup_t_t_t,
  &_swigt__p_std__mapT_std__string_Pythia8__LHAwgt_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAwgt_t_t_t,
  &_swigt__p_std__mapT_std__string_Pythia8__LHgenericBlock_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHgenericBlock_t_t_t,
  &_swigt__p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t,
  &_swigt__p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t,
  &_swigt__p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t,
  &_swigt__p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t,
  &_swigt__p_std__mapT_std__string_Pythia8__WVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__WVec_t_t_t,
  &_swigt__p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t,
  &_swigt__p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t,
  &_swigt__p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t,
  &_swigt__p_std__multisetT_Pythia8__SubCollision_std__lessT_Pythia8__SubCollision_t_std__allocatorT_Pythia8__SubCollision_t_t,
  &_swigt__p_std__ofstream,
  &_swigt__p_std__pairT_Pythia8__RotBstMatrix_Pythia8__RotBstMatrix_t,
  &_swigt__p_std__pairT_Pythia8__Vec4_Pythia8__Vec4_t,
  &_swigt__p_std__pairT_double_double_t,
  &_swigt__p_std__pairT_int_int_t,
  &_swigt__p_std__pairT_long_long_t,
  &_swigt__p_std__setT_int_std__lessT_int_t_std__allocatorT_int_t_t,
  &_swigt__p_std__string,
  &_swigt__p_std__string__size_type,
  &_swigt__p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t,
  &_swigt__p_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t,
  &_swigt__p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,
  &_swigt__p_std__vectorT_Pythia8__InBeam_std__allocatorT_Pythia8__InBeam_t_t,
  &_swigt__p_std__vectorT_Pythia8__InPair_std__allocatorT_Pythia8__InPair_t_t,
  &_swigt__p_std__vectorT_Pythia8__LHAParticle_std__allocatorT_Pythia8__LHAParticle_t_t,
  &_swigt__p_std__vectorT_Pythia8__LHAgenerator_std__allocatorT_Pythia8__LHAgenerator_t_t,
  &_swigt__p_std__vectorT_Pythia8__LHblockT_int_t_std__allocatorT_Pythia8__LHblockT_int_t_t_t,
  &_swigt__p_std__vectorT_Pythia8__LHdecayTable_std__allocatorT_Pythia8__LHdecayTable_t_t,
  &_swigt__p_std__vectorT_Pythia8__Nucleon_std__allocatorT_Pythia8__Nucleon_t_t,
  &_swigt__p_std__vectorT_Pythia8__PhaseSpace_p_std__allocatorT_Pythia8__PhaseSpace_p_t_t,
  &_swigt__p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t,
  &_swigt__p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t,
  &_swigt__p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t,
  &_swigt__p_std__vectorT_Pythia8__StringRegion_std__allocatorT_Pythia8__StringRegion_t_t,
  &_swigt__p_std__vectorT_Pythia8__StringVertex_std__allocatorT_Pythia8__StringVertex_t_t,
  &_swigt__p_std__vectorT_Pythia8__UserHooks_p_std__allocatorT_Pythia8__UserHooks_p_t_t,
  &_swigt__p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t,
  &_swigt__p_std__vectorT_Pythia8__XMLTag_p_std__allocatorT_Pythia8__XMLTag_p_t_t,
  &_swigt__p_std__vectorT_bool_std__allocatorT_bool_t_t,
  &_swigt__p_std__vectorT_double_std__allocatorT_double_t_t,
  &_swigt__p_std__vectorT_int_std__allocatorT_int_t_t,
  &_swigt__p_std__vectorT_long_std__allocatorT_long_t_t,
  &_swigt__p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t,
  &_swigt__p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t,
  &_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
  &_swigt__p_std__vectorT_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t_std__allocatorT_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t_t_t,
  &_swigt__p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,
  &_swigt__p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t,
  &_swigt__p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t,
  &_swigt__p_std__vectorT_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t_std__allocatorT_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t_t_t,
  &_swigt__p_streamoff,
  &_swigt__p_streampos,
  &_swigt__p_stringstream,
  &_swigt__p_swig__SwigPyIterator,
  &_swigt__p_traits_type,
  &_swigt__p_unsigned_int,
  &_swigt__p_unsigned_long,
  &_swigt__p_unsigned_long_long,
  &_swigt__p_unsigned_short,
  &_swigt__p_value_type,
};

static swig_cast_info _swigc__p_Pythia8__AlpgenHooks[] = {  {&_swigt__p_Pythia8__AlpgenHooks, 0, 0, 0},  {&_swigt__p_Pythia8__JetMatchingAlpgenInputAlpgen, _p_Pythia8__JetMatchingAlpgenInputAlpgenTo_p_Pythia8__AlpgenHooks, 0, 0},  {&_swigt__p_Pythia8__JetMatchingMadgraphInputAlpgen, _p_Pythia8__JetMatchingMadgraphInputAlpgenTo_p_Pythia8__AlpgenHooks, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__AlpgenPar[] = {  {&_swigt__p_Pythia8__AlpgenPar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__AlphaEM[] = {  {&_swigt__p_Pythia8__AlphaEM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__AlphaStrong[] = {  {&_swigt__p_Pythia8__AlphaStrong, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Angantyr[] = {  {&_swigt__p_Pythia8__Angantyr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__BeamParticle[] = {  {&_swigt__p_Pythia8__BeamParticle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__BeamRemnants[] = {  {&_swigt__p_Pythia8__BeamRemnants, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__BeamShape[] = {  {&_swigt__p_Pythia8__BeamShape, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__BoseEinstein[] = {  {&_swigt__p_Pythia8__BoseEinstein, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__BoseEinsteinHadron[] = {  {&_swigt__p_Pythia8__BoseEinsteinHadron, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__CJKL[] = {  {&_swigt__p_Pythia8__CJKL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__CTEQ5L[] = {  {&_swigt__p_Pythia8__CTEQ5L, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__CTEQ6pdf[] = {  {&_swigt__p_Pythia8__CTEQ6pdf, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__CellJet[] = {  {&_swigt__p_Pythia8__CellJet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ClusterJet[] = {  {&_swigt__p_Pythia8__ClusterJet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Clustering[] = {  {&_swigt__p_Pythia8__Clustering, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ColConfig[] = {  {&_swigt__p_Pythia8__ColConfig, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ColSinglet[] = {  {&_swigt__p_Pythia8__ColSinglet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ColourDipole[] = {  {&_swigt__p_Pythia8__ColourDipole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ColourJunction[] = {  {&_swigt__p_Pythia8__ColourJunction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ColourParticle[] = {  {&_swigt__p_Pythia8__ColourParticle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ColourReconnection[] = {  {&_swigt__p_Pythia8__ColourReconnection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ColourTracing[] = {  {&_swigt__p_Pythia8__ColourTracing, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__CombineMatchingInput[] = {  {&_swigt__p_Pythia8__CombineMatchingInput, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__CoupSM[] = {  {&_swigt__p_Pythia8__Couplings, _p_Pythia8__CouplingsTo_p_Pythia8__CoupSM, 0, 0},  {&_swigt__p_Pythia8__CoupSUSY, _p_Pythia8__CoupSUSYTo_p_Pythia8__CoupSM, 0, 0},  {&_swigt__p_Pythia8__CoupSM, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__CoupSUSY[] = {  {&_swigt__p_Pythia8__CoupSUSY, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Couplings[] = {  {&_swigt__p_Pythia8__Couplings, 0, 0, 0},  {&_swigt__p_Pythia8__CoupSUSY, _p_Pythia8__CoupSUSYTo_p_Pythia8__Couplings, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__DecayChannel[] = {  {&_swigt__p_Pythia8__DecayChannel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__DecayHandler[] = {  {&_swigt__p_Pythia8__DecayHandler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__DoubleStrikman[] = {  {&_swigt__p_Pythia8__DoubleStrikman, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__DummyForStreams[] = {  {&_swigt__p_Pythia8__DummyForStreams, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__EPAexternal[] = {  {&_swigt__p_Pythia8__EPAexternal, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__EPPS16[] = {  {&_swigt__p_Pythia8__EPPS16, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__EPS09[] = {  {&_swigt__p_Pythia8__EPS09, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Event[] = {  {&_swigt__p_Pythia8__Event, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__EventInfo[] = {  {&_swigt__p_Pythia8__EventInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__FVec[] = {  {&_swigt__p_Pythia8__FVec, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Flag[] = {  {&_swigt__p_Pythia8__Flag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__FlavContainer[] = {  {&_swigt__p_Pythia8__FlavContainer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__FlavourRope[] = {  {&_swigt__p_Pythia8__FlavourRope, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__GLISSANDOModel[] = {  {&_swigt__p_Pythia8__GLISSANDOModel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__GRV94L[] = {  {&_swigt__p_Pythia8__GRV94L, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__GRVpiL[] = {  {&_swigt__p_Pythia8__GRVpiL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__GammaKinematics[] = {  {&_swigt__p_Pythia8__GammaKinematics, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__GammaMatrix[] = {  {&_swigt__p_Pythia8__GammaMatrix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__GammaPoint[] = {  {&_swigt__p_Pythia8__GammaPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HEPEUP[] = {  {&_swigt__p_Pythia8__HEPEUP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HEPRUP[] = {  {&_swigt__p_Pythia8__HEPRUP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HIInfo[] = {  {&_swigt__p_Pythia8__HIInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HIUserHooks[] = {  {&_swigt__p_Pythia8__HIUserHooks, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HJSlowJet[] = {  {&_swigt__p_Pythia8__HJSlowJet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HMEGamma2TwoFermions[] = {  {&_swigt__p_Pythia8__HMEGamma2TwoFermions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HMEHiggs2TwoFermions[] = {  {&_swigt__p_Pythia8__HMEHiggs2TwoFermions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HMETau2FivePions[] = {  {&_swigt__p_Pythia8__HMETau2FivePions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HMETau2FourPions[] = {  {&_swigt__p_Pythia8__HMETau2FourPions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HMETau2Meson[] = {  {&_swigt__p_Pythia8__HMETau2Meson, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HMETau2PhaseSpace[] = {  {&_swigt__p_Pythia8__HMETau2PhaseSpace, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HMETau2ThreeMesons[] = {  {&_swigt__p_Pythia8__HMETau2ThreeMesons, 0, 0, 0},  {&_swigt__p_Pythia8__HMETau2ThreePions, _p_Pythia8__HMETau2ThreePionsTo_p_Pythia8__HMETau2ThreeMesons, 0, 0},  {&_swigt__p_Pythia8__HMETau2ThreeMesonsWithKaons, _p_Pythia8__HMETau2ThreeMesonsWithKaonsTo_p_Pythia8__HMETau2ThreeMesons, 0, 0},  {&_swigt__p_Pythia8__HMETau2ThreeMesonsGeneric, _p_Pythia8__HMETau2ThreeMesonsGenericTo_p_Pythia8__HMETau2ThreeMesons, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HMETau2ThreeMesonsGeneric[] = {  {&_swigt__p_Pythia8__HMETau2ThreeMesonsGeneric, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HMETau2ThreeMesonsWithKaons[] = {  {&_swigt__p_Pythia8__HMETau2ThreeMesonsWithKaons, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HMETau2ThreePions[] = {  {&_swigt__p_Pythia8__HMETau2ThreePions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HMETau2TwoLeptons[] = {  {&_swigt__p_Pythia8__HMETau2TwoLeptons, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HMETau2TwoMesonsViaVector[] = {  {&_swigt__p_Pythia8__HMETau2TwoMesonsViaVector, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HMETau2TwoMesonsViaVectorScalar[] = {  {&_swigt__p_Pythia8__HMETau2TwoMesonsViaVectorScalar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HMETau2TwoPionsGamma[] = {  {&_swigt__p_Pythia8__HMETau2TwoPionsGamma, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HMETauDecay[] = {  {&_swigt__p_Pythia8__HMETau2ThreeMesons, _p_Pythia8__HMETau2ThreeMesonsTo_p_Pythia8__HMETauDecay, 0, 0},  {&_swigt__p_Pythia8__HMETau2ThreePions, _p_Pythia8__HMETau2ThreePionsTo_p_Pythia8__HMETauDecay, 0, 0},  {&_swigt__p_Pythia8__HMETau2ThreeMesonsWithKaons, _p_Pythia8__HMETau2ThreeMesonsWithKaonsTo_p_Pythia8__HMETauDecay, 0, 0},  {&_swigt__p_Pythia8__HMETau2TwoLeptons, _p_Pythia8__HMETau2TwoLeptonsTo_p_Pythia8__HMETauDecay, 0, 0},  {&_swigt__p_Pythia8__HMETau2TwoMesonsViaVector, _p_Pythia8__HMETau2TwoMesonsViaVectorTo_p_Pythia8__HMETauDecay, 0, 0},  {&_swigt__p_Pythia8__HMETauDecay, 0, 0, 0},  {&_swigt__p_Pythia8__HMETau2TwoPionsGamma, _p_Pythia8__HMETau2TwoPionsGammaTo_p_Pythia8__HMETauDecay, 0, 0},  {&_swigt__p_Pythia8__HMETau2FivePions, _p_Pythia8__HMETau2FivePionsTo_p_Pythia8__HMETauDecay, 0, 0},  {&_swigt__p_Pythia8__HMETau2ThreeMesonsGeneric, _p_Pythia8__HMETau2ThreeMesonsGenericTo_p_Pythia8__HMETauDecay, 0, 0},  {&_swigt__p_Pythia8__HMETau2TwoMesonsViaVectorScalar, _p_Pythia8__HMETau2TwoMesonsViaVectorScalarTo_p_Pythia8__HMETauDecay, 0, 0},  {&_swigt__p_Pythia8__HMETau2Meson, _p_Pythia8__HMETau2MesonTo_p_Pythia8__HMETauDecay, 0, 0},  {&_swigt__p_Pythia8__HMETau2PhaseSpace, _p_Pythia8__HMETau2PhaseSpaceTo_p_Pythia8__HMETauDecay, 0, 0},  {&_swigt__p_Pythia8__HMETau2FourPions, _p_Pythia8__HMETau2FourPionsTo_p_Pythia8__HMETauDecay, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HMETwoFermions2GammaZ2TwoFermions[] = {  {&_swigt__p_Pythia8__HMETwoFermions2GammaZ2TwoFermions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HMETwoFermions2W2TwoFermions[] = {  {&_swigt__p_Pythia8__HMETwoFermions2W2TwoFermions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HMEW2TwoFermions[] = {  {&_swigt__p_Pythia8__HMEW2TwoFermions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HMEX2TwoFermions[] = {  {&_swigt__p_Pythia8__HMEX2TwoFermions, 0, 0, 0},  {&_swigt__p_Pythia8__HMEW2TwoFermions, _p_Pythia8__HMEW2TwoFermionsTo_p_Pythia8__HMEX2TwoFermions, 0, 0},  {&_swigt__p_Pythia8__HMEGamma2TwoFermions, _p_Pythia8__HMEGamma2TwoFermionsTo_p_Pythia8__HMEX2TwoFermions, 0, 0},  {&_swigt__p_Pythia8__HMEZ2TwoFermions, _p_Pythia8__HMEZ2TwoFermionsTo_p_Pythia8__HMEX2TwoFermions, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HMEZ2TwoFermions[] = {  {&_swigt__p_Pythia8__HMEZ2TwoFermions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HVStringFlav[] = {  {&_swigt__p_Pythia8__HVStringFlav, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HVStringPT[] = {  {&_swigt__p_Pythia8__HVStringPT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HVStringZ[] = {  {&_swigt__p_Pythia8__HVStringZ, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HadronLevel[] = {  {&_swigt__p_Pythia8__HadronLevel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HadronScatter[] = {  {&_swigt__p_Pythia8__HadronScatter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HadronScatterPair[] = {  {&_swigt__p_Pythia8__HadronScatterPair, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HardDiffraction[] = {  {&_swigt__p_Pythia8__HardDiffraction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HardProcess[] = {  {&_swigt__p_Pythia8__HardProcess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HeavyIons[] = {  {&_swigt__p_Pythia8__HeavyIons, 0, 0, 0},  {&_swigt__p_Pythia8__Angantyr, _p_Pythia8__AngantyrTo_p_Pythia8__HeavyIons, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HelicityMatrixElement[] = {  {&_swigt__p_Pythia8__HMETau2PhaseSpace, _p_Pythia8__HMETau2PhaseSpaceTo_p_Pythia8__HelicityMatrixElement, 0, 0},  {&_swigt__p_Pythia8__HMETau2TwoLeptons, _p_Pythia8__HMETau2TwoLeptonsTo_p_Pythia8__HelicityMatrixElement, 0, 0},  {&_swigt__p_Pythia8__HMETau2FivePions, _p_Pythia8__HMETau2FivePionsTo_p_Pythia8__HelicityMatrixElement, 0, 0},  {&_swigt__p_Pythia8__HMETau2ThreeMesons, _p_Pythia8__HMETau2ThreeMesonsTo_p_Pythia8__HelicityMatrixElement, 0, 0},  {&_swigt__p_Pythia8__HMEZ2TwoFermions, _p_Pythia8__HMEZ2TwoFermionsTo_p_Pythia8__HelicityMatrixElement, 0, 0},  {&_swigt__p_Pythia8__HMEGamma2TwoFermions, _p_Pythia8__HMEGamma2TwoFermionsTo_p_Pythia8__HelicityMatrixElement, 0, 0},  {&_swigt__p_Pythia8__HMEW2TwoFermions, _p_Pythia8__HMEW2TwoFermionsTo_p_Pythia8__HelicityMatrixElement, 0, 0},  {&_swigt__p_Pythia8__HMEX2TwoFermions, _p_Pythia8__HMEX2TwoFermionsTo_p_Pythia8__HelicityMatrixElement, 0, 0},  {&_swigt__p_Pythia8__HMETwoFermions2GammaZ2TwoFermions, _p_Pythia8__HMETwoFermions2GammaZ2TwoFermionsTo_p_Pythia8__HelicityMatrixElement, 0, 0},  {&_swigt__p_Pythia8__HMETwoFermions2W2TwoFermions, _p_Pythia8__HMETwoFermions2W2TwoFermionsTo_p_Pythia8__HelicityMatrixElement, 0, 0},  {&_swigt__p_Pythia8__HMEHiggs2TwoFermions, _p_Pythia8__HMEHiggs2TwoFermionsTo_p_Pythia8__HelicityMatrixElement, 0, 0},  {&_swigt__p_Pythia8__HMETau2ThreePions, _p_Pythia8__HMETau2ThreePionsTo_p_Pythia8__HelicityMatrixElement, 0, 0},  {&_swigt__p_Pythia8__HMETau2TwoMesonsViaVectorScalar, _p_Pythia8__HMETau2TwoMesonsViaVectorScalarTo_p_Pythia8__HelicityMatrixElement, 0, 0},  {&_swigt__p_Pythia8__HMETau2Meson, _p_Pythia8__HMETau2MesonTo_p_Pythia8__HelicityMatrixElement, 0, 0},  {&_swigt__p_Pythia8__HMETau2ThreeMesonsWithKaons, _p_Pythia8__HMETau2ThreeMesonsWithKaonsTo_p_Pythia8__HelicityMatrixElement, 0, 0},  {&_swigt__p_Pythia8__HMETau2TwoPionsGamma, _p_Pythia8__HMETau2TwoPionsGammaTo_p_Pythia8__HelicityMatrixElement, 0, 0},  {&_swigt__p_Pythia8__HMETau2TwoMesonsViaVector, _p_Pythia8__HMETau2TwoMesonsViaVectorTo_p_Pythia8__HelicityMatrixElement, 0, 0},  {&_swigt__p_Pythia8__HelicityMatrixElement, 0, 0, 0},  {&_swigt__p_Pythia8__HMETau2ThreeMesonsGeneric, _p_Pythia8__HMETau2ThreeMesonsGenericTo_p_Pythia8__HelicityMatrixElement, 0, 0},  {&_swigt__p_Pythia8__HMETauDecay, _p_Pythia8__HMETauDecayTo_p_Pythia8__HelicityMatrixElement, 0, 0},  {&_swigt__p_Pythia8__HMETau2FourPions, _p_Pythia8__HMETau2FourPionsTo_p_Pythia8__HelicityMatrixElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HelicityParticle[] = {  {&_swigt__p_Pythia8__HelicityParticle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HiddenValleyFragmentation[] = {  {&_swigt__p_Pythia8__HiddenValleyFragmentation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Hist[] = {  {&_swigt__p_Pythia8__Hist, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__HistPlot[] = {  {&_swigt__p_Pythia8__HistPlot, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__History[] = {  {&_swigt__p_Pythia8__History, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ImpactParameterGenerator[] = {  {&_swigt__p_Pythia8__ImpactParameterGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__InBeam[] = {  {&_swigt__p_Pythia8__InBeam, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__InPair[] = {  {&_swigt__p_Pythia8__InPair, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Info[] = {  {&_swigt__p_Pythia8__Info, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Isospin[] = {  {&_swigt__p_Pythia8__Isospin, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__JetMatching[] = {  {&_swigt__p_Pythia8__JetMatchingAlpgen, _p_Pythia8__JetMatchingAlpgenTo_p_Pythia8__JetMatching, 0, 0},  {&_swigt__p_Pythia8__JetMatching, 0, 0, 0},  {&_swigt__p_Pythia8__JetMatchingAlpgenInputAlpgen, _p_Pythia8__JetMatchingAlpgenInputAlpgenTo_p_Pythia8__JetMatching, 0, 0},  {&_swigt__p_Pythia8__JetMatchingMadgraph, _p_Pythia8__JetMatchingMadgraphTo_p_Pythia8__JetMatching, 0, 0},  {&_swigt__p_Pythia8__JetMatchingMadgraphInputAlpgen, _p_Pythia8__JetMatchingMadgraphInputAlpgenTo_p_Pythia8__JetMatching, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__JetMatchingAlpgen[] = {  {&_swigt__p_Pythia8__JetMatchingAlpgen, 0, 0, 0},  {&_swigt__p_Pythia8__JetMatchingAlpgenInputAlpgen, _p_Pythia8__JetMatchingAlpgenInputAlpgenTo_p_Pythia8__JetMatchingAlpgen, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__JetMatchingAlpgenInputAlpgen[] = {  {&_swigt__p_Pythia8__JetMatchingAlpgenInputAlpgen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__JetMatchingMadgraph[] = {  {&_swigt__p_Pythia8__JetMatchingMadgraph, 0, 0, 0},  {&_swigt__p_Pythia8__JetMatchingMadgraphInputAlpgen, _p_Pythia8__JetMatchingMadgraphInputAlpgenTo_p_Pythia8__JetMatchingMadgraph, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__JetMatchingMadgraphInputAlpgen[] = {  {&_swigt__p_Pythia8__JetMatchingMadgraphInputAlpgen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Junction[] = {  {&_swigt__p_Pythia8__Junction, 0, 0, 0},  {&_swigt__p_Pythia8__ColourJunction, _p_Pythia8__ColourJunctionTo_p_Pythia8__Junction, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__JunctionSplitting[] = {  {&_swigt__p_Pythia8__JunctionSplitting, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHAGrid1[] = {  {&_swigt__p_Pythia8__LHAGrid1, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHAPDF[] = {  {&_swigt__p_Pythia8__LHAPDF, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHAParticle[] = {  {&_swigt__p_Pythia8__LHAParticle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHAProcess[] = {  {&_swigt__p_Pythia8__LHAProcess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHAgenerator[] = {  {&_swigt__p_Pythia8__LHAgenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHAinitrwgt[] = {  {&_swigt__p_Pythia8__LHAinitrwgt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHArwgt[] = {  {&_swigt__p_Pythia8__LHArwgt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHAscales[] = {  {&_swigt__p_Pythia8__LHAscales, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHAup[] = {  {&_swigt__p_Pythia8__LHAupHelaconia, _p_Pythia8__LHAupHelaconiaTo_p_Pythia8__LHAup, 0, 0},  {&_swigt__p_Pythia8__LHAupFromPYTHIA8, _p_Pythia8__LHAupFromPYTHIA8To_p_Pythia8__LHAup, 0, 0},  {&_swigt__p_Pythia8__LHAup, 0, 0, 0},  {&_swigt__p_Pythia8__LHAupLHEF, _p_Pythia8__LHAupLHEFTo_p_Pythia8__LHAup, 0, 0},  {&_swigt__p_Pythia8__LHEF3FromPythia8, _p_Pythia8__LHEF3FromPythia8To_p_Pythia8__LHAup, 0, 0},  {&_swigt__p_Pythia8__LHAupAlpgen, _p_Pythia8__LHAupAlpgenTo_p_Pythia8__LHAup, 0, 0},  {&_swigt__p_Pythia8__LHAupMadgraph, _p_Pythia8__LHAupMadgraphTo_p_Pythia8__LHAup, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHAupAlpgen[] = {  {&_swigt__p_Pythia8__LHAupAlpgen, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHAupFromPYTHIA8[] = {  {&_swigt__p_Pythia8__LHAupFromPYTHIA8, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHAupHelaconia[] = {  {&_swigt__p_Pythia8__LHAupHelaconia, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHAupLHEF[] = {  {&_swigt__p_Pythia8__LHAupLHEF, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHAupMadgraph[] = {  {&_swigt__p_Pythia8__LHAupMadgraph, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHAweight[] = {  {&_swigt__p_Pythia8__LHAweight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHAweightgroup[] = {  {&_swigt__p_Pythia8__LHAweightgroup, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHAweights[] = {  {&_swigt__p_Pythia8__LHAweights, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHAwgt[] = {  {&_swigt__p_Pythia8__LHAwgt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHEF3FromPythia8[] = {  {&_swigt__p_Pythia8__LHEF3FromPythia8, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHblockT_double_t[] = {  {&_swigt__p_Pythia8__LHblockT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHblockT_int_t[] = {  {&_swigt__p_Pythia8__LHblockT_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHblockT_std__string_t[] = {  {&_swigt__p_Pythia8__LHblockT_std__string_t, 0, 0, 0},  {&_swigt__p_Pythia8__LHgenericBlock, _p_Pythia8__LHgenericBlockTo_p_Pythia8__LHblockT_std__string_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHdecayChannel[] = {  {&_swigt__p_Pythia8__LHdecayChannel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHdecayTable[] = {  {&_swigt__p_Pythia8__LHdecayTable, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHgenericBlock[] = {  {&_swigt__p_Pythia8__LHgenericBlock, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHmatrixBlockT_2_t[] = {  {&_swigt__p_Pythia8__LHmatrixBlockT_2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHmatrixBlockT_3_t[] = {  {&_swigt__p_Pythia8__LHmatrixBlockT_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHmatrixBlockT_4_t[] = {  {&_swigt__p_Pythia8__LHmatrixBlockT_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHmatrixBlockT_5_t[] = {  {&_swigt__p_Pythia8__LHmatrixBlockT_5_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHmatrixBlockT_6_t[] = {  {&_swigt__p_Pythia8__LHmatrixBlockT_6_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHmatrixBlockT_7_t[] = {  {&_swigt__p_Pythia8__LHmatrixBlockT_7_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHmatrixBlockT_8_t[] = {  {&_swigt__p_Pythia8__LHmatrixBlockT_8_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LHtensor3BlockT_3_t[] = {  {&_swigt__p_Pythia8__LHtensor3BlockT_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Lepton[] = {  {&_swigt__p_Pythia8__Lepton, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Lepton2gamma[] = {  {&_swigt__p_Pythia8__Lepton2gamma, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LeptonPoint[] = {  {&_swigt__p_Pythia8__LeptonPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LundFFAvg[] = {  {&_swigt__p_Pythia8__LundFFAvg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__LundFFRaw[] = {  {&_swigt__p_Pythia8__LundFFRaw, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__MBReconUserHooks[] = {  {&_swigt__p_Pythia8__MBReconUserHooks, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__MSTWpdf[] = {  {&_swigt__p_Pythia8__MSTWpdf, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__MVec[] = {  {&_swigt__p_Pythia8__MVec, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__MadgraphPar[] = {  {&_swigt__p_Pythia8__MadgraphPar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Merging[] = {  {&_swigt__p_Pythia8__Merging, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__MergingHooks[] = {  {&_swigt__p_Pythia8__MergingHooks, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__MiniStringFragmentation[] = {  {&_swigt__p_Pythia8__MiniStringFragmentation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Mode[] = {  {&_swigt__p_Pythia8__Mode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__MultiRadial[] = {  {&_swigt__p_Pythia8__MultiRadial, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__MultipartonInteractions[] = {  {&_swigt__p_Pythia8__MultipartonInteractions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__NNPDF[] = {  {&_swigt__p_Pythia8__NNPDF, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__NaiveSubCollisionModel[] = {  {&_swigt__p_Pythia8__NaiveSubCollisionModel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__NeutrinoPoint[] = {  {&_swigt__p_Pythia8__NeutrinoPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Nucleon[] = {  {&_swigt__p_Pythia8__Nucleon, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__NucleusModel[] = {  {&_swigt__p_Pythia8__NucleusModel, 0, 0, 0},  {&_swigt__p_Pythia8__WoodsSaxonModel, _p_Pythia8__WoodsSaxonModelTo_p_Pythia8__NucleusModel, 0, 0},  {&_swigt__p_Pythia8__GLISSANDOModel, _p_Pythia8__GLISSANDOModelTo_p_Pythia8__NucleusModel, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__OverlappingRopeDipole[] = {  {&_swigt__p_Pythia8__OverlappingRopeDipole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__PDF[] = {  {&_swigt__p_Pythia8__PomFix, _p_Pythia8__PomFixTo_p_Pythia8__PDF, 0, 0},  {&_swigt__p_Pythia8__CTEQ6pdf, _p_Pythia8__CTEQ6pdfTo_p_Pythia8__PDF, 0, 0},  {&_swigt__p_Pythia8__CTEQ5L, _p_Pythia8__CTEQ5LTo_p_Pythia8__PDF, 0, 0},  {&_swigt__p_Pythia8__GRV94L, _p_Pythia8__GRV94LTo_p_Pythia8__PDF, 0, 0},  {&_swigt__p_Pythia8__Isospin, _p_Pythia8__IsospinTo_p_Pythia8__PDF, 0, 0},  {&_swigt__p_Pythia8__LHAGrid1, _p_Pythia8__LHAGrid1To_p_Pythia8__PDF, 0, 0},  {&_swigt__p_Pythia8__NeutrinoPoint, _p_Pythia8__NeutrinoPointTo_p_Pythia8__PDF, 0, 0},  {&_swigt__p_Pythia8__nPDF, _p_Pythia8__nPDFTo_p_Pythia8__PDF, 0, 0},  {&_swigt__p_Pythia8__Lepton, _p_Pythia8__LeptonTo_p_Pythia8__PDF, 0, 0},  {&_swigt__p_Pythia8__LeptonPoint, _p_Pythia8__LeptonPointTo_p_Pythia8__PDF, 0, 0},  {&_swigt__p_Pythia8__ProtonPoint, _p_Pythia8__ProtonPointTo_p_Pythia8__PDF, 0, 0},  {&_swigt__p_Pythia8__LHAPDF, _p_Pythia8__LHAPDFTo_p_Pythia8__PDF, 0, 0},  {&_swigt__p_Pythia8__EPAexternal, _p_Pythia8__EPAexternalTo_p_Pythia8__PDF, 0, 0},  {&_swigt__p_Pythia8__EPS09, _p_Pythia8__EPS09To_p_Pythia8__PDF, 0, 0},  {&_swigt__p_Pythia8__PDF, 0, 0, 0},  {&_swigt__p_Pythia8__NNPDF, _p_Pythia8__NNPDFTo_p_Pythia8__PDF, 0, 0},  {&_swigt__p_Pythia8__CJKL, _p_Pythia8__CJKLTo_p_Pythia8__PDF, 0, 0},  {&_swigt__p_Pythia8__MSTWpdf, _p_Pythia8__MSTWpdfTo_p_Pythia8__PDF, 0, 0},  {&_swigt__p_Pythia8__Lepton2gamma, _p_Pythia8__Lepton2gammaTo_p_Pythia8__PDF, 0, 0},  {&_swigt__p_Pythia8__GRVpiL, _p_Pythia8__GRVpiLTo_p_Pythia8__PDF, 0, 0},  {&_swigt__p_Pythia8__PomH1FitAB, _p_Pythia8__PomH1FitABTo_p_Pythia8__PDF, 0, 0},  {&_swigt__p_Pythia8__GammaPoint, _p_Pythia8__GammaPointTo_p_Pythia8__PDF, 0, 0},  {&_swigt__p_Pythia8__PomHISASD, _p_Pythia8__PomHISASDTo_p_Pythia8__PDF, 0, 0},  {&_swigt__p_Pythia8__PomH1Jets, _p_Pythia8__PomH1JetsTo_p_Pythia8__PDF, 0, 0},  {&_swigt__p_Pythia8__EPPS16, _p_Pythia8__EPPS16To_p_Pythia8__PDF, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__PDF__PDFEnvelope[] = {  {&_swigt__p_Pythia8__PDF__PDFEnvelope, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__PVec[] = {  {&_swigt__p_Pythia8__PVec, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Parm[] = {  {&_swigt__p_Pythia8__Parm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Particle[] = {  {&_swigt__p_Pythia8__Particle, 0, 0, 0},  {&_swigt__p_Pythia8__HelicityParticle, _p_Pythia8__HelicityParticleTo_p_Pythia8__Particle, 0, 0},  {&_swigt__p_Pythia8__ColourParticle, _p_Pythia8__ColourParticleTo_p_Pythia8__Particle, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ParticleData[] = {  {&_swigt__p_Pythia8__ParticleData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ParticleDataEntry[] = {  {&_swigt__p_Pythia8__ParticleDataEntry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ParticleDecays[] = {  {&_swigt__p_Pythia8__ParticleDecays, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__PartonLevel[] = {  {&_swigt__p_Pythia8__PartonLevel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__PartonSystem[] = {  {&_swigt__p_Pythia8__PartonSystem, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__PartonSystems[] = {  {&_swigt__p_Pythia8__PartonSystems, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__PartonVertex[] = {  {&_swigt__p_Pythia8__PartonVertex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__PhaseSpace[] = {  {&_swigt__p_Pythia8__PhaseSpace2to2tauyz, _p_Pythia8__PhaseSpace2to2tauyzTo_p_Pythia8__PhaseSpace, 0, 0},  {&_swigt__p_Pythia8__PhaseSpace2to2nondiffractiveGamma, _p_Pythia8__PhaseSpace2to2nondiffractiveGammaTo_p_Pythia8__PhaseSpace, 0, 0},  {&_swigt__p_Pythia8__PhaseSpace2to2diffractive, _p_Pythia8__PhaseSpace2to2diffractiveTo_p_Pythia8__PhaseSpace, 0, 0},  {&_swigt__p_Pythia8__PhaseSpace2to3diffractive, _p_Pythia8__PhaseSpace2to3diffractiveTo_p_Pythia8__PhaseSpace, 0, 0},  {&_swigt__p_Pythia8__PhaseSpace2to2nondiffractive, _p_Pythia8__PhaseSpace2to2nondiffractiveTo_p_Pythia8__PhaseSpace, 0, 0},  {&_swigt__p_Pythia8__PhaseSpace2to3tauycyl, _p_Pythia8__PhaseSpace2to3tauycylTo_p_Pythia8__PhaseSpace, 0, 0},  {&_swigt__p_Pythia8__PhaseSpace2to3yyycyl, _p_Pythia8__PhaseSpace2to3yyycylTo_p_Pythia8__PhaseSpace, 0, 0},  {&_swigt__p_Pythia8__PhaseSpace, 0, 0, 0},  {&_swigt__p_Pythia8__PhaseSpace2to2elastic, _p_Pythia8__PhaseSpace2to2elasticTo_p_Pythia8__PhaseSpace, 0, 0},  {&_swigt__p_Pythia8__PhaseSpaceLHA, _p_Pythia8__PhaseSpaceLHATo_p_Pythia8__PhaseSpace, 0, 0},  {&_swigt__p_Pythia8__PhaseSpace2to1tauy, _p_Pythia8__PhaseSpace2to1tauyTo_p_Pythia8__PhaseSpace, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__PhaseSpace2to1tauy[] = {  {&_swigt__p_Pythia8__PhaseSpace2to1tauy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__PhaseSpace2to2diffractive[] = {  {&_swigt__p_Pythia8__PhaseSpace2to2diffractive, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__PhaseSpace2to2elastic[] = {  {&_swigt__p_Pythia8__PhaseSpace2to2elastic, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__PhaseSpace2to2nondiffractive[] = {  {&_swigt__p_Pythia8__PhaseSpace2to2nondiffractive, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__PhaseSpace2to2nondiffractiveGamma[] = {  {&_swigt__p_Pythia8__PhaseSpace2to2nondiffractiveGamma, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__PhaseSpace2to2tauyz[] = {  {&_swigt__p_Pythia8__PhaseSpace2to2tauyz, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__PhaseSpace2to3diffractive[] = {  {&_swigt__p_Pythia8__PhaseSpace2to3diffractive, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__PhaseSpace2to3tauycyl[] = {  {&_swigt__p_Pythia8__PhaseSpace2to3tauycyl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__PhaseSpace2to3yyycyl[] = {  {&_swigt__p_Pythia8__PhaseSpace2to3yyycyl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__PhaseSpaceLHA[] = {  {&_swigt__p_Pythia8__PhaseSpaceLHA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__PomFix[] = {  {&_swigt__p_Pythia8__PomFix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__PomH1FitAB[] = {  {&_swigt__p_Pythia8__PomH1FitAB, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__PomH1Jets[] = {  {&_swigt__p_Pythia8__PomH1Jets, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__PomHISASD[] = {  {&_swigt__p_Pythia8__PomHISASD, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__PowhegHooks[] = {  {&_swigt__p_Pythia8__PowhegHooks, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__PowhegProcs[] = {  {&_swigt__p_Pythia8__PowhegProcs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ProcessContainer[] = {  {&_swigt__p_Pythia8__ProcessContainer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ProcessLevel[] = {  {&_swigt__p_Pythia8__ProcessLevel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ProgressLog[] = {  {&_swigt__p_Pythia8__ProgressLog, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ProtonPoint[] = {  {&_swigt__p_Pythia8__ProtonPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Pythia[] = {  {&_swigt__p_Pythia8__Pythia, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__RHadrons[] = {  {&_swigt__p_Pythia8__RHadrons, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Reader[] = {  {&_swigt__p_Pythia8__Reader, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResolvedParton[] = {  {&_swigt__p_Pythia8__ResolvedParton, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceChar[] = {  {&_swigt__p_Pythia8__ResonanceChar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceDecays[] = {  {&_swigt__p_Pythia8__ResonanceDecays, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceExcited[] = {  {&_swigt__p_Pythia8__ResonanceExcited, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceFour[] = {  {&_swigt__p_Pythia8__ResonanceFour, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceGeneric[] = {  {&_swigt__p_Pythia8__ResonanceGeneric, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceGluino[] = {  {&_swigt__p_Pythia8__ResonanceGluino, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceGmZ[] = {  {&_swigt__p_Pythia8__ResonanceGmZ, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceGraviton[] = {  {&_swigt__p_Pythia8__ResonanceGraviton, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceH[] = {  {&_swigt__p_Pythia8__ResonanceH, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceHchg[] = {  {&_swigt__p_Pythia8__ResonanceHchg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceHchgchgLeft[] = {  {&_swigt__p_Pythia8__ResonanceHchgchgLeft, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceHchgchgRight[] = {  {&_swigt__p_Pythia8__ResonanceHchgchgRight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceKKgluon[] = {  {&_swigt__p_Pythia8__ResonanceKKgluon, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceLeptoquark[] = {  {&_swigt__p_Pythia8__ResonanceLeptoquark, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceNeut[] = {  {&_swigt__p_Pythia8__ResonanceNeut, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceNuRight[] = {  {&_swigt__p_Pythia8__ResonanceNuRight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceRhorizontal[] = {  {&_swigt__p_Pythia8__ResonanceRhorizontal, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceS[] = {  {&_swigt__p_Pythia8__ResonanceS, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceSlepton[] = {  {&_swigt__p_Pythia8__ResonanceSlepton, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceSquark[] = {  {&_swigt__p_Pythia8__ResonanceSquark, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceTop[] = {  {&_swigt__p_Pythia8__ResonanceTop, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceW[] = {  {&_swigt__p_Pythia8__ResonanceW, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceWRight[] = {  {&_swigt__p_Pythia8__ResonanceWRight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceWidths[] = {  {&_swigt__p_Pythia8__ResonanceRhorizontal, _p_Pythia8__ResonanceRhorizontalTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceSquark, _p_Pythia8__ResonanceSquarkTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceWprime, _p_Pythia8__ResonanceWprimeTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceWRight, _p_Pythia8__ResonanceWRightTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__SUSYResonanceWidths, _p_Pythia8__SUSYResonanceWidthsTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceWidths, 0, 0, 0},  {&_swigt__p_Pythia8__ResonanceKKgluon, _p_Pythia8__ResonanceKKgluonTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceHchgchgRight, _p_Pythia8__ResonanceHchgchgRightTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceGraviton, _p_Pythia8__ResonanceGravitonTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceFour, _p_Pythia8__ResonanceFourTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceNeut, _p_Pythia8__ResonanceNeutTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceChar, _p_Pythia8__ResonanceCharTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceZRight, _p_Pythia8__ResonanceZRightTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceZprime, _p_Pythia8__ResonanceZprimeTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceHchg, _p_Pythia8__ResonanceHchgTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceSlepton, _p_Pythia8__ResonanceSleptonTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceGluino, _p_Pythia8__ResonanceGluinoTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceGmZ, _p_Pythia8__ResonanceGmZTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceS, _p_Pythia8__ResonanceSTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceLeptoquark, _p_Pythia8__ResonanceLeptoquarkTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceTop, _p_Pythia8__ResonanceTopTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceZp, _p_Pythia8__ResonanceZpTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceW, _p_Pythia8__ResonanceWTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceHchgchgLeft, _p_Pythia8__ResonanceHchgchgLeftTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceH, _p_Pythia8__ResonanceHTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceNuRight, _p_Pythia8__ResonanceNuRightTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceExcited, _p_Pythia8__ResonanceExcitedTo_p_Pythia8__ResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceGeneric, _p_Pythia8__ResonanceGenericTo_p_Pythia8__ResonanceWidths, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceWprime[] = {  {&_swigt__p_Pythia8__ResonanceWprime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceZRight[] = {  {&_swigt__p_Pythia8__ResonanceZRight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceZp[] = {  {&_swigt__p_Pythia8__ResonanceZp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__ResonanceZprime[] = {  {&_swigt__p_Pythia8__ResonanceZprime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Rndm[] = {  {&_swigt__p_Pythia8__Rndm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__RndmEngine[] = {  {&_swigt__p_Pythia8__RndmEngine, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__RopeDipole[] = {  {&_swigt__p_Pythia8__RopeDipole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__RopeDipoleEnd[] = {  {&_swigt__p_Pythia8__RopeDipoleEnd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__RopeFragPars[] = {  {&_swigt__p_Pythia8__RopeFragPars, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Ropewalk[] = {  {&_swigt__p_Pythia8__Ropewalk, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__RotBstMatrix[] = {  {&_swigt__p_Pythia8__RotBstMatrix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SLHAinterface[] = {  {&_swigt__p_Pythia8__SLHAinterface, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SUSYResonanceWidths[] = {  {&_swigt__p_Pythia8__SUSYResonanceWidths, 0, 0, 0},  {&_swigt__p_Pythia8__ResonanceSquark, _p_Pythia8__ResonanceSquarkTo_p_Pythia8__SUSYResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceNeut, _p_Pythia8__ResonanceNeutTo_p_Pythia8__SUSYResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceGluino, _p_Pythia8__ResonanceGluinoTo_p_Pythia8__SUSYResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceSlepton, _p_Pythia8__ResonanceSleptonTo_p_Pythia8__SUSYResonanceWidths, 0, 0},  {&_swigt__p_Pythia8__ResonanceChar, _p_Pythia8__ResonanceCharTo_p_Pythia8__SUSYResonanceWidths, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Settings[] = {  {&_swigt__p_Pythia8__Settings, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SetupContainers[] = {  {&_swigt__p_Pythia8__SetupContainers, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma0AB2AB[] = {  {&_swigt__p_Pythia8__Sigma0AB2AB, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma0AB2AX[] = {  {&_swigt__p_Pythia8__Sigma0AB2AX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma0AB2AXB[] = {  {&_swigt__p_Pythia8__Sigma0AB2AXB, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma0AB2XB[] = {  {&_swigt__p_Pythia8__Sigma0AB2XB, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma0AB2XX[] = {  {&_swigt__p_Pythia8__Sigma0AB2XX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma0Process[] = {  {&_swigt__p_Pythia8__Sigma0AB2AB, _p_Pythia8__Sigma0AB2ABTo_p_Pythia8__Sigma0Process, 0, 0},  {&_swigt__p_Pythia8__Sigma0AB2XB, _p_Pythia8__Sigma0AB2XBTo_p_Pythia8__Sigma0Process, 0, 0},  {&_swigt__p_Pythia8__Sigma0AB2AX, _p_Pythia8__Sigma0AB2AXTo_p_Pythia8__Sigma0Process, 0, 0},  {&_swigt__p_Pythia8__Sigma0AB2XX, _p_Pythia8__Sigma0AB2XXTo_p_Pythia8__Sigma0Process, 0, 0},  {&_swigt__p_Pythia8__Sigma0nonDiffractive, _p_Pythia8__Sigma0nonDiffractiveTo_p_Pythia8__Sigma0Process, 0, 0},  {&_swigt__p_Pythia8__Sigma0AB2AXB, _p_Pythia8__Sigma0AB2AXBTo_p_Pythia8__Sigma0Process, 0, 0},  {&_swigt__p_Pythia8__Sigma0Process, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma0nonDiffractive[] = {  {&_swigt__p_Pythia8__Sigma0nonDiffractive, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma1Process[] = {  {&_swigt__p_Pythia8__Sigma1ffbar2Rhorizontal, _p_Pythia8__Sigma1ffbar2RhorizontalTo_p_Pythia8__Sigma1Process, 0, 0},  {&_swigt__p_Pythia8__Sigma1qg2qStar, _p_Pythia8__Sigma1qg2qStarTo_p_Pythia8__Sigma1Process, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbarZprimeWprime, _p_Pythia8__Sigma1ffbarZprimeWprimeTo_p_Pythia8__Sigma1Process, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbar2W, _p_Pythia8__Sigma1ffbar2WTo_p_Pythia8__Sigma1Process, 0, 0},  {&_swigt__p_Pythia8__Sigma1qq2antisquark, _p_Pythia8__Sigma1qq2antisquarkTo_p_Pythia8__Sigma1Process, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbar2H, _p_Pythia8__Sigma1ffbar2HTo_p_Pythia8__Sigma1Process, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbar2WRight, _p_Pythia8__Sigma1ffbar2WRightTo_p_Pythia8__Sigma1Process, 0, 0},  {&_swigt__p_Pythia8__Sigma1lgm2lStar, _p_Pythia8__Sigma1lgm2lStarTo_p_Pythia8__Sigma1Process, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbar2Wprime, _p_Pythia8__Sigma1ffbar2WprimeTo_p_Pythia8__Sigma1Process, 0, 0},  {&_swigt__p_Pythia8__Sigma1gg2H, _p_Pythia8__Sigma1gg2HTo_p_Pythia8__Sigma1Process, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbar2gmZ, _p_Pythia8__Sigma1ffbar2gmZTo_p_Pythia8__Sigma1Process, 0, 0},  {&_swigt__p_Pythia8__Sigma1gg2S2XX, _p_Pythia8__Sigma1gg2S2XXTo_p_Pythia8__Sigma1Process, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbar2Hchg, _p_Pythia8__Sigma1ffbar2HchgTo_p_Pythia8__Sigma1Process, 0, 0},  {&_swigt__p_Pythia8__Sigma1ql2LeptoQuark, _p_Pythia8__Sigma1ql2LeptoQuarkTo_p_Pythia8__Sigma1Process, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbar2Zp2XX, _p_Pythia8__Sigma1ffbar2Zp2XXTo_p_Pythia8__Sigma1Process, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbar2GravitonStar, _p_Pythia8__Sigma1ffbar2GravitonStarTo_p_Pythia8__Sigma1Process, 0, 0},  {&_swigt__p_Pythia8__Sigma1gg2GravitonStar, _p_Pythia8__Sigma1gg2GravitonStarTo_p_Pythia8__Sigma1Process, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbar2gmZZprime, _p_Pythia8__Sigma1ffbar2gmZZprimeTo_p_Pythia8__Sigma1Process, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbar2ZRight, _p_Pythia8__Sigma1ffbar2ZRightTo_p_Pythia8__Sigma1Process, 0, 0},  {&_swigt__p_Pythia8__Sigma1ll2Hchgchg, _p_Pythia8__Sigma1ll2HchgchgTo_p_Pythia8__Sigma1Process, 0, 0},  {&_swigt__p_Pythia8__Sigma1Process, 0, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbar2Zv, _p_Pythia8__Sigma1ffbar2ZvTo_p_Pythia8__Sigma1Process, 0, 0},  {&_swigt__p_Pythia8__Sigma1qqbar2KKgluonStar, _p_Pythia8__Sigma1qqbar2KKgluonStarTo_p_Pythia8__Sigma1Process, 0, 0},  {&_swigt__p_Pythia8__Sigma1gmgm2H, _p_Pythia8__Sigma1gmgm2HTo_p_Pythia8__Sigma1Process, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma1ffbar2GravitonStar[] = {  {&_swigt__p_Pythia8__Sigma1ffbar2GravitonStar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma1ffbar2H[] = {  {&_swigt__p_Pythia8__Sigma1ffbar2H, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma1ffbar2Hchg[] = {  {&_swigt__p_Pythia8__Sigma1ffbar2Hchg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma1ffbar2Rhorizontal[] = {  {&_swigt__p_Pythia8__Sigma1ffbar2Rhorizontal, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma1ffbar2W[] = {  {&_swigt__p_Pythia8__Sigma1ffbar2W, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma1ffbar2WRight[] = {  {&_swigt__p_Pythia8__Sigma1ffbar2WRight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma1ffbar2Wprime[] = {  {&_swigt__p_Pythia8__Sigma1ffbar2Wprime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma1ffbar2ZRight[] = {  {&_swigt__p_Pythia8__Sigma1ffbar2ZRight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma1ffbar2Zp2XX[] = {  {&_swigt__p_Pythia8__Sigma1ffbar2Zp2XX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma1ffbar2Zv[] = {  {&_swigt__p_Pythia8__Sigma1ffbar2Zv, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma1ffbar2gmZ[] = {  {&_swigt__p_Pythia8__Sigma1ffbar2gmZ, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma1ffbar2gmZZprime[] = {  {&_swigt__p_Pythia8__Sigma1ffbar2gmZZprime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma1ffbarZprimeWprime[] = {  {&_swigt__p_Pythia8__Sigma1ffbar2gmZZprime, _p_Pythia8__Sigma1ffbar2gmZZprimeTo_p_Pythia8__Sigma1ffbarZprimeWprime, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbar2Wprime, _p_Pythia8__Sigma1ffbar2WprimeTo_p_Pythia8__Sigma1ffbarZprimeWprime, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbarZprimeWprime, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma1gg2GravitonStar[] = {  {&_swigt__p_Pythia8__Sigma1gg2GravitonStar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma1gg2H[] = {  {&_swigt__p_Pythia8__Sigma1gg2H, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma1gg2S2XX[] = {  {&_swigt__p_Pythia8__Sigma1gg2S2XX, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma1gmgm2H[] = {  {&_swigt__p_Pythia8__Sigma1gmgm2H, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma1lgm2lStar[] = {  {&_swigt__p_Pythia8__Sigma1lgm2lStar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma1ll2Hchgchg[] = {  {&_swigt__p_Pythia8__Sigma1ll2Hchgchg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma1qg2qStar[] = {  {&_swigt__p_Pythia8__Sigma1qg2qStar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma1ql2LeptoQuark[] = {  {&_swigt__p_Pythia8__Sigma1ql2LeptoQuark, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma1qq2antisquark[] = {  {&_swigt__p_Pythia8__Sigma1qq2antisquark, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma1qqbar2KKgluonStar[] = {  {&_swigt__p_Pythia8__Sigma1qqbar2KKgluonStar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2Process[] = {  {&_swigt__p_Pythia8__Sigma2SUSY, _p_Pythia8__Sigma2SUSYTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2Hq, _p_Pythia8__Sigma2qg2HqTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2Sq2XXj, _p_Pythia8__Sigma2qg2Sq2XXjTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2Hglt, _p_Pythia8__Sigma2gg2HgltTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2HchgH12, _p_Pythia8__Sigma2ffbar2HchgH12To_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qq2QqtW, _p_Pythia8__Sigma2qq2QqtWTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qq2qStarq, _p_Pythia8__Sigma2qq2qStarqTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qq2LEDqq, _p_Pythia8__Sigma2qq2LEDqqTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2lStarlbar, _p_Pythia8__Sigma2qqbar2lStarlbarTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2QQbar3S11gm, _p_Pythia8__Sigma2gg2QQbar3S11gmTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2QQbar, _p_Pythia8__Sigma2qqbar2QQbarTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qgm2qg, _p_Pythia8__Sigma2qgm2qgTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2Wq, _p_Pythia8__Sigma2qg2WqTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2sleptonantislepton, _p_Pythia8__Sigma2qqbar2sleptonantisleptonTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2ZW, _p_Pythia8__Sigma2ffbar2ZWTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2Hglt, _p_Pythia8__Sigma2qqbar2HgltTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2QQbar3DJ1g, _p_Pythia8__Sigma2gg2QQbar3DJ1gTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2charchi0, _p_Pythia8__Sigma2qqbar2charchi0To_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2ffbarsW, _p_Pythia8__Sigma2ffbar2ffbarsWTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2FfbarsW, _p_Pythia8__Sigma2ffbar2FfbarsWTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2LEDUnparticleZ, _p_Pythia8__Sigma2ffbar2LEDUnparticleZTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ggm2qqbar, _p_Pythia8__Sigma2ggm2qqbarTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2qqbar, _p_Pythia8__Sigma2gg2qqbarTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2ffbarsgm, _p_Pythia8__Sigma2ffbar2ffbarsgmTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2LQLQbar, _p_Pythia8__Sigma2gg2LQLQbarTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2LQLQbar, _p_Pythia8__Sigma2qqbar2LQLQbarTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2gmZgm, _p_Pythia8__Sigma2ffbar2gmZgmTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2LEDqqbarNew, _p_Pythia8__Sigma2qqbar2LEDqqbarNewTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2qqbarNew, _p_Pythia8__Sigma2qqbar2qqbarNewTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2ggamma, _p_Pythia8__Sigma2gg2ggammaTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2ggamma, _p_Pythia8__Sigma2qqbar2ggammaTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2chargluino, _p_Pythia8__Sigma2qqbar2chargluinoTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2chi0gluino, _p_Pythia8__Sigma2qqbar2chi0gluinoTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2gmgm2ffbar, _p_Pythia8__Sigma2gmgm2ffbarTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2gg, _p_Pythia8__Sigma2gg2ggTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2LEDllbar, _p_Pythia8__Sigma2gg2LEDllbarTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2LEDllbar, _p_Pythia8__Sigma2ffbar2LEDllbarTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2GravitonStarg, _p_Pythia8__Sigma2qqbar2GravitonStargTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2GravitonStarg, _p_Pythia8__Sigma2gg2GravitonStargTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2Wgm, _p_Pythia8__Sigma2ffbar2WgmTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2LEDUnparticleg, _p_Pythia8__Sigma2qqbar2LEDUnparticlegTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2LEDUnparticleg, _p_Pythia8__Sigma2gg2LEDUnparticlegTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2QCffbar2llbar, _p_Pythia8__Sigma2QCffbar2llbarTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2ZpH, _p_Pythia8__Sigma2ffbar2ZpHTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbargmZggm, _p_Pythia8__Sigma2ffbargmZggmTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2QQbar, _p_Pythia8__Sigma2gg2QQbarTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2fgm2Wf, _p_Pythia8__Sigma2fgm2WfTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2GravitonStarq, _p_Pythia8__Sigma2qg2GravitonStarqTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2QCqq2qq, _p_Pythia8__Sigma2QCqq2qqTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2Wg, _p_Pythia8__Sigma2qqbar2WgTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2QQbarX8g, _p_Pythia8__Sigma2gg2QQbarX8gTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2QQbarX8g, _p_Pythia8__Sigma2qqbar2QQbarX8gTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2A3H12, _p_Pythia8__Sigma2ffbar2A3H12To_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2LEDUnparticleq, _p_Pythia8__Sigma2qg2LEDUnparticleqTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2LeptoQuarkl, _p_Pythia8__Sigma2qg2LeptoQuarklTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2chi0squark, _p_Pythia8__Sigma2qg2chi0squarkTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2charsquark, _p_Pythia8__Sigma2qg2charsquarkTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qq2qq, _p_Pythia8__Sigma2qq2qqTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ff2fftW, _p_Pythia8__Sigma2ff2fftWTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2qg, _p_Pythia8__Sigma2qg2qgTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2fgm2gmZf, _p_Pythia8__Sigma2fgm2gmZfTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2LEDgg, _p_Pythia8__Sigma2qqbar2LEDggTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2TEVffbar, _p_Pythia8__Sigma2ffbar2TEVffbarTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2QQbar3PJ1g, _p_Pythia8__Sigma2gg2QQbar3PJ1gTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2QQbar3PJ1g, _p_Pythia8__Sigma2qqbar2QQbar3PJ1gTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ff2fftgmZ, _p_Pythia8__Sigma2ff2fftgmZTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2QQbarX8q, _p_Pythia8__Sigma2qg2QQbarX8qTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbargmZWgmZW, _p_Pythia8__Sigma2ffbargmZWgmZWTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2gmZgmZ, _p_Pythia8__Sigma2ffbar2gmZgmZTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2Zpg2XXj, _p_Pythia8__Sigma2qqbar2Zpg2XXjTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2gluinogluino, _p_Pythia8__Sigma2qqbar2gluinogluinoTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2gluinogluino, _p_Pythia8__Sigma2gg2gluinogluinoTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2squarkgluino, _p_Pythia8__Sigma2qg2squarkgluinoTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11, _p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11To_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11, _p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11To_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2Hqlt, _p_Pythia8__Sigma2qg2HqltTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2lStarlStarBar, _p_Pythia8__Sigma2qqbar2lStarlStarBarTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2QQbar3PJ1q, _p_Pythia8__Sigma2qg2QQbar3PJ1qTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2Hchgq, _p_Pythia8__Sigma2qg2HchgqTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2qgamma, _p_Pythia8__Sigma2qg2qgammaTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2lgm2Hchgchgl, _p_Pythia8__Sigma2lgm2HchgchglTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2Zpq2XXj, _p_Pythia8__Sigma2qg2Zpq2XXjTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2LEDgammagamma, _p_Pythia8__Sigma2gg2LEDgammagammaTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2LEDgammagamma, _p_Pythia8__Sigma2ffbar2LEDgammagammaTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2gammagamma, _p_Pythia8__Sigma2ffbar2gammagammaTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2gammagamma, _p_Pythia8__Sigma2gg2gammagammaTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbarWggm, _p_Pythia8__Sigma2ffbarWggmTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2gmZg, _p_Pythia8__Sigma2qqbar2gmZgTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2charchar, _p_Pythia8__Sigma2qqbar2charcharTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2qGqGbar, _p_Pythia8__Sigma2qqbar2qGqGbarTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2qGqGbar, _p_Pythia8__Sigma2gg2qGqGbarTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2gmZq, _p_Pythia8__Sigma2qg2gmZqTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2LEDqqbar, _p_Pythia8__Sigma2gg2LEDqqbarTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qq2squarksquark, _p_Pythia8__Sigma2qq2squarksquarkTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2squarkantisquark, _p_Pythia8__Sigma2qqbar2squarkantisquarkTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2squarkantisquark, _p_Pythia8__Sigma2gg2squarkantisquarkTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2chi0chi0, _p_Pythia8__Sigma2qqbar2chi0chi0To_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2Process, 0, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2HW, _p_Pythia8__Sigma2ffbar2HWTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2QCqqbar2qqbar, _p_Pythia8__Sigma2QCqqbar2qqbarTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2QQbar3S11g, _p_Pythia8__Sigma2gg2QQbar3S11gTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2HZ, _p_Pythia8__Sigma2ffbar2HZTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2LEDgg, _p_Pythia8__Sigma2gg2LEDggTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2fGfGbar, _p_Pythia8__Sigma2ffbar2fGfGbarTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2Sg2XXj, _p_Pythia8__Sigma2gg2Sg2XXjTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2WW, _p_Pythia8__Sigma2ffbar2WWTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2LEDqg, _p_Pythia8__Sigma2qg2LEDqgTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2ffbarsgmZ, _p_Pythia8__Sigma2ffbar2ffbarsgmZTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2FFbarsgmZ, _p_Pythia8__Sigma2ffbar2FFbarsgmZTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2gg, _p_Pythia8__Sigma2qqbar2ggTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2HchgchgHchgchg, _p_Pythia8__Sigma2ffbar2HchgchgHchgchgTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2LEDUnparticlegamma, _p_Pythia8__Sigma2ffbar2LEDUnparticlegammaTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2qgm2qgm, _p_Pythia8__Sigma2qgm2qgmTo_p_Pythia8__Sigma2Process, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2HposHneg, _p_Pythia8__Sigma2ffbar2HposHnegTo_p_Pythia8__Sigma2Process, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2QCffbar2llbar[] = {  {&_swigt__p_Pythia8__Sigma2QCffbar2llbar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2QCqq2qq[] = {  {&_swigt__p_Pythia8__Sigma2QCqq2qq, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2QCqqbar2qqbar[] = {  {&_swigt__p_Pythia8__Sigma2QCqqbar2qqbar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2SUSY[] = {  {&_swigt__p_Pythia8__Sigma2SUSY, 0, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2charchar, _p_Pythia8__Sigma2qqbar2charcharTo_p_Pythia8__Sigma2SUSY, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2charchi0, _p_Pythia8__Sigma2qqbar2charchi0To_p_Pythia8__Sigma2SUSY, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2chi0gluino, _p_Pythia8__Sigma2qqbar2chi0gluinoTo_p_Pythia8__Sigma2SUSY, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2chargluino, _p_Pythia8__Sigma2qqbar2chargluinoTo_p_Pythia8__Sigma2SUSY, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2chi0chi0, _p_Pythia8__Sigma2qqbar2chi0chi0To_p_Pythia8__Sigma2SUSY, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ff2fftW[] = {  {&_swigt__p_Pythia8__Sigma2ff2fftW, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ff2fftgmZ[] = {  {&_swigt__p_Pythia8__Sigma2ff2fftgmZ, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbar2A3H12[] = {  {&_swigt__p_Pythia8__Sigma2ffbar2A3H12, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbar2FFbarsgmZ[] = {  {&_swigt__p_Pythia8__Sigma2ffbar2FFbarsgmZ, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbar2FfbarsW[] = {  {&_swigt__p_Pythia8__Sigma2ffbar2FfbarsW, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbar2HW[] = {  {&_swigt__p_Pythia8__Sigma2ffbar2HW, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbar2HZ[] = {  {&_swigt__p_Pythia8__Sigma2ffbar2HZ, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbar2HchgH12[] = {  {&_swigt__p_Pythia8__Sigma2ffbar2HchgH12, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbar2HchgchgHchgchg[] = {  {&_swigt__p_Pythia8__Sigma2ffbar2HchgchgHchgchg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbar2HposHneg[] = {  {&_swigt__p_Pythia8__Sigma2ffbar2HposHneg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbar2LEDUnparticleZ[] = {  {&_swigt__p_Pythia8__Sigma2ffbar2LEDUnparticleZ, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbar2LEDUnparticlegamma[] = {  {&_swigt__p_Pythia8__Sigma2ffbar2LEDUnparticlegamma, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbar2LEDgammagamma[] = {  {&_swigt__p_Pythia8__Sigma2ffbar2LEDgammagamma, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbar2LEDllbar[] = {  {&_swigt__p_Pythia8__Sigma2ffbar2LEDllbar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbar2TEVffbar[] = {  {&_swigt__p_Pythia8__Sigma2ffbar2TEVffbar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbar2WW[] = {  {&_swigt__p_Pythia8__Sigma2ffbar2WW, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbar2Wgm[] = {  {&_swigt__p_Pythia8__Sigma2ffbar2Wgm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbar2ZW[] = {  {&_swigt__p_Pythia8__Sigma2ffbar2ZW, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbar2ZpH[] = {  {&_swigt__p_Pythia8__Sigma2ffbar2ZpH, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbar2fGfGbar[] = {  {&_swigt__p_Pythia8__Sigma2ffbar2fGfGbar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbar2ffbarsW[] = {  {&_swigt__p_Pythia8__Sigma2ffbar2ffbarsW, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbar2ffbarsgm[] = {  {&_swigt__p_Pythia8__Sigma2ffbar2ffbarsgm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbar2ffbarsgmZ[] = {  {&_swigt__p_Pythia8__Sigma2ffbar2ffbarsgmZ, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbar2gammagamma[] = {  {&_swigt__p_Pythia8__Sigma2ffbar2gammagamma, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbar2gmZgm[] = {  {&_swigt__p_Pythia8__Sigma2ffbar2gmZgm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbar2gmZgmZ[] = {  {&_swigt__p_Pythia8__Sigma2ffbar2gmZgmZ, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbarWggm[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2Wg, _p_Pythia8__Sigma2qqbar2WgTo_p_Pythia8__Sigma2ffbarWggm, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2Wgm, _p_Pythia8__Sigma2ffbar2WgmTo_p_Pythia8__Sigma2ffbarWggm, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2Wq, _p_Pythia8__Sigma2qg2WqTo_p_Pythia8__Sigma2ffbarWggm, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbarWggm, 0, 0, 0},  {&_swigt__p_Pythia8__Sigma2fgm2Wf, _p_Pythia8__Sigma2fgm2WfTo_p_Pythia8__Sigma2ffbarWggm, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbargmZWgmZW[] = {  {&_swigt__p_Pythia8__Sigma2ffbargmZWgmZW, 0, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2ZW, _p_Pythia8__Sigma2ffbar2ZWTo_p_Pythia8__Sigma2ffbargmZWgmZW, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2gmZgmZ, _p_Pythia8__Sigma2ffbar2gmZgmZTo_p_Pythia8__Sigma2ffbargmZWgmZW, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2WW, _p_Pythia8__Sigma2ffbar2WWTo_p_Pythia8__Sigma2ffbargmZWgmZW, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ffbargmZggm[] = {  {&_swigt__p_Pythia8__Sigma2qg2gmZq, _p_Pythia8__Sigma2qg2gmZqTo_p_Pythia8__Sigma2ffbargmZggm, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbargmZggm, 0, 0, 0},  {&_swigt__p_Pythia8__Sigma2fgm2gmZf, _p_Pythia8__Sigma2fgm2gmZfTo_p_Pythia8__Sigma2ffbargmZggm, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2gmZg, _p_Pythia8__Sigma2qqbar2gmZgTo_p_Pythia8__Sigma2ffbargmZggm, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2gmZgm, _p_Pythia8__Sigma2ffbar2gmZgmTo_p_Pythia8__Sigma2ffbargmZggm, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2fgm2Wf[] = {  {&_swigt__p_Pythia8__Sigma2fgm2Wf, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2fgm2gmZf[] = {  {&_swigt__p_Pythia8__Sigma2fgm2gmZf, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2gg2GravitonStarg[] = {  {&_swigt__p_Pythia8__Sigma2gg2GravitonStarg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2gg2Hglt[] = {  {&_swigt__p_Pythia8__Sigma2gg2Hglt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2gg2LEDUnparticleg[] = {  {&_swigt__p_Pythia8__Sigma2gg2LEDUnparticleg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2gg2LEDgammagamma[] = {  {&_swigt__p_Pythia8__Sigma2gg2LEDgammagamma, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2gg2LEDgg[] = {  {&_swigt__p_Pythia8__Sigma2gg2LEDgg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2gg2LEDllbar[] = {  {&_swigt__p_Pythia8__Sigma2gg2LEDllbar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2gg2LEDqqbar[] = {  {&_swigt__p_Pythia8__Sigma2gg2LEDqqbar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2gg2LQLQbar[] = {  {&_swigt__p_Pythia8__Sigma2gg2LQLQbar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2gg2QQbar[] = {  {&_swigt__p_Pythia8__Sigma2gg2QQbar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2gg2QQbar3DJ1g[] = {  {&_swigt__p_Pythia8__Sigma2gg2QQbar3DJ1g, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2gg2QQbar3PJ1g[] = {  {&_swigt__p_Pythia8__Sigma2qg2QQbar3PJ1q, _p_Pythia8__Sigma2qg2QQbar3PJ1qTo_p_Pythia8__Sigma2gg2QQbar3PJ1g, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2QQbar3PJ1g, 0, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2QQbar3PJ1g, _p_Pythia8__Sigma2qqbar2QQbar3PJ1gTo_p_Pythia8__Sigma2gg2QQbar3PJ1g, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2QQbar3DJ1g, _p_Pythia8__Sigma2gg2QQbar3DJ1gTo_p_Pythia8__Sigma2gg2QQbar3PJ1g, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11[] = {  {&_swigt__p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2gg2QQbar3S11g[] = {  {&_swigt__p_Pythia8__Sigma2gg2QQbar3S11g, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2gg2QQbar3S11gm[] = {  {&_swigt__p_Pythia8__Sigma2gg2QQbar3S11gm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2gg2QQbarX8g[] = {  {&_swigt__p_Pythia8__Sigma2gg2QQbarX8g, 0, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2QQbarX8g, _p_Pythia8__Sigma2qqbar2QQbarX8gTo_p_Pythia8__Sigma2gg2QQbarX8g, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2QQbarX8q, _p_Pythia8__Sigma2qg2QQbarX8qTo_p_Pythia8__Sigma2gg2QQbarX8g, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2gg2Sg2XXj[] = {  {&_swigt__p_Pythia8__Sigma2gg2Sg2XXj, 0, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2Sq2XXj, _p_Pythia8__Sigma2qg2Sq2XXjTo_p_Pythia8__Sigma2gg2Sg2XXj, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2gg2gammagamma[] = {  {&_swigt__p_Pythia8__Sigma2gg2gammagamma, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2gg2gg[] = {  {&_swigt__p_Pythia8__Sigma2gg2gg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2gg2ggamma[] = {  {&_swigt__p_Pythia8__Sigma2gg2ggamma, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2gg2gluinogluino[] = {  {&_swigt__p_Pythia8__Sigma2gg2gluinogluino, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2gg2qGqGbar[] = {  {&_swigt__p_Pythia8__Sigma2gg2qGqGbar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2gg2qqbar[] = {  {&_swigt__p_Pythia8__Sigma2gg2qqbar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2gg2squarkantisquark[] = {  {&_swigt__p_Pythia8__Sigma2gg2squarkantisquark, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2ggm2qqbar[] = {  {&_swigt__p_Pythia8__Sigma2ggm2qqbar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2gmgm2ffbar[] = {  {&_swigt__p_Pythia8__Sigma2gmgm2ffbar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2lgm2Hchgchgl[] = {  {&_swigt__p_Pythia8__Sigma2lgm2Hchgchgl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qg2GravitonStarq[] = {  {&_swigt__p_Pythia8__Sigma2qg2GravitonStarq, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qg2Hchgq[] = {  {&_swigt__p_Pythia8__Sigma2qg2Hchgq, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qg2Hq[] = {  {&_swigt__p_Pythia8__Sigma2qg2Hq, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qg2Hqlt[] = {  {&_swigt__p_Pythia8__Sigma2qg2Hqlt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qg2LEDUnparticleq[] = {  {&_swigt__p_Pythia8__Sigma2qg2LEDUnparticleq, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qg2LEDqg[] = {  {&_swigt__p_Pythia8__Sigma2qg2LEDqg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qg2LeptoQuarkl[] = {  {&_swigt__p_Pythia8__Sigma2qg2LeptoQuarkl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qg2QQbar3PJ1q[] = {  {&_swigt__p_Pythia8__Sigma2qg2QQbar3PJ1q, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qg2QQbarX8q[] = {  {&_swigt__p_Pythia8__Sigma2qg2QQbarX8q, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qg2Sq2XXj[] = {  {&_swigt__p_Pythia8__Sigma2qg2Sq2XXj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qg2Wq[] = {  {&_swigt__p_Pythia8__Sigma2qg2Wq, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qg2Zpq2XXj[] = {  {&_swigt__p_Pythia8__Sigma2qg2Zpq2XXj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qg2charsquark[] = {  {&_swigt__p_Pythia8__Sigma2qg2charsquark, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qg2chi0squark[] = {  {&_swigt__p_Pythia8__Sigma2qg2chi0squark, 0, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2charsquark, _p_Pythia8__Sigma2qg2charsquarkTo_p_Pythia8__Sigma2qg2chi0squark, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qg2gmZq[] = {  {&_swigt__p_Pythia8__Sigma2qg2gmZq, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qg2qg[] = {  {&_swigt__p_Pythia8__Sigma2qg2qg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qg2qgamma[] = {  {&_swigt__p_Pythia8__Sigma2qg2qgamma, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qg2squarkgluino[] = {  {&_swigt__p_Pythia8__Sigma2qg2squarkgluino, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qgm2qg[] = {  {&_swigt__p_Pythia8__Sigma2qgm2qg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qgm2qgm[] = {  {&_swigt__p_Pythia8__Sigma2qgm2qgm, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qq2LEDqq[] = {  {&_swigt__p_Pythia8__Sigma2qq2LEDqq, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qq2QqtW[] = {  {&_swigt__p_Pythia8__Sigma2qq2QqtW, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qq2qStarq[] = {  {&_swigt__p_Pythia8__Sigma2qq2qStarq, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qq2qq[] = {  {&_swigt__p_Pythia8__Sigma2qq2qq, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qq2squarksquark[] = {  {&_swigt__p_Pythia8__Sigma2qq2squarksquark, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2GravitonStarg[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2GravitonStarg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2Hglt[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2Hglt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2LEDUnparticleg[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2LEDUnparticleg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2LEDgg[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2LEDgg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2LEDqqbarNew[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2LEDqqbarNew, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2LQLQbar[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2LQLQbar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2QQbar[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2QQbar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2QQbar3PJ1g[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2QQbar3PJ1g, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2QQbarX8g[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2QQbarX8g, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2Wg[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2Wg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2Zpg2XXj[] = {  {&_swigt__p_Pythia8__Sigma2qg2Zpq2XXj, _p_Pythia8__Sigma2qg2Zpq2XXjTo_p_Pythia8__Sigma2qqbar2Zpg2XXj, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2Zpg2XXj, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2charchar[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2charchar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2charchi0[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2charchi0, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2chargluino[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2chargluino, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2chi0chi0[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2charchar, _p_Pythia8__Sigma2qqbar2charcharTo_p_Pythia8__Sigma2qqbar2chi0chi0, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2charchi0, _p_Pythia8__Sigma2qqbar2charchi0To_p_Pythia8__Sigma2qqbar2chi0chi0, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2chi0chi0, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2chi0gluino[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2chi0gluino, 0, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2chargluino, _p_Pythia8__Sigma2qqbar2chargluinoTo_p_Pythia8__Sigma2qqbar2chi0gluino, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2gg[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2gg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2ggamma[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2ggamma, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2gluinogluino[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2gluinogluino, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2gmZg[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2gmZg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2lStarlStarBar[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2lStarlStarBar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2lStarlbar[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2lStarlbar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2qGqGbar[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2qGqGbar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2qqbarNew[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2qqbarNew, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2sleptonantislepton[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2sleptonantislepton, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma2qqbar2squarkantisquark[] = {  {&_swigt__p_Pythia8__Sigma2qqbar2sleptonantislepton, _p_Pythia8__Sigma2qqbar2sleptonantisleptonTo_p_Pythia8__Sigma2qqbar2squarkantisquark, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2squarkantisquark, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma3Process[] = {  {&_swigt__p_Pythia8__Sigma3qg2qqqbarSame, _p_Pythia8__Sigma3qg2qqqbarSameTo_p_Pythia8__Sigma3Process, 0, 0},  {&_swigt__p_Pythia8__Sigma3ff2HfftWW, _p_Pythia8__Sigma3ff2HfftWWTo_p_Pythia8__Sigma3Process, 0, 0},  {&_swigt__p_Pythia8__Sigma3qqbar2HQQbar, _p_Pythia8__Sigma3qqbar2HQQbarTo_p_Pythia8__Sigma3Process, 0, 0},  {&_swigt__p_Pythia8__Sigma3gg2HQQbar, _p_Pythia8__Sigma3gg2HQQbarTo_p_Pythia8__Sigma3Process, 0, 0},  {&_swigt__p_Pythia8__Sigma3gg2ggg, _p_Pythia8__Sigma3gg2gggTo_p_Pythia8__Sigma3Process, 0, 0},  {&_swigt__p_Pythia8__Sigma3gg2qqbarg, _p_Pythia8__Sigma3gg2qqbargTo_p_Pythia8__Sigma3Process, 0, 0},  {&_swigt__p_Pythia8__Sigma3qq2qqgDiff, _p_Pythia8__Sigma3qq2qqgDiffTo_p_Pythia8__Sigma3Process, 0, 0},  {&_swigt__p_Pythia8__Sigma3Process, 0, 0, 0},  {&_swigt__p_Pythia8__Sigma3qqbar2qqbargDiff, _p_Pythia8__Sigma3qqbar2qqbargDiffTo_p_Pythia8__Sigma3Process, 0, 0},  {&_swigt__p_Pythia8__Sigma3ff2HchgchgfftWW, _p_Pythia8__Sigma3ff2HchgchgfftWWTo_p_Pythia8__Sigma3Process, 0, 0},  {&_swigt__p_Pythia8__Sigma3qqbar2ggg, _p_Pythia8__Sigma3qqbar2gggTo_p_Pythia8__Sigma3Process, 0, 0},  {&_swigt__p_Pythia8__Sigma3qq2qqgSame, _p_Pythia8__Sigma3qq2qqgSameTo_p_Pythia8__Sigma3Process, 0, 0},  {&_swigt__p_Pythia8__Sigma3qg2qqqbarDiff, _p_Pythia8__Sigma3qg2qqqbarDiffTo_p_Pythia8__Sigma3Process, 0, 0},  {&_swigt__p_Pythia8__Sigma3qg2qgg, _p_Pythia8__Sigma3qg2qggTo_p_Pythia8__Sigma3Process, 0, 0},  {&_swigt__p_Pythia8__Sigma3qqbar2qqbargSame, _p_Pythia8__Sigma3qqbar2qqbargSameTo_p_Pythia8__Sigma3Process, 0, 0},  {&_swigt__p_Pythia8__Sigma3ff2HfftZZ, _p_Pythia8__Sigma3ff2HfftZZTo_p_Pythia8__Sigma3Process, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma3ff2HchgchgfftWW[] = {  {&_swigt__p_Pythia8__Sigma3ff2HchgchgfftWW, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma3ff2HfftWW[] = {  {&_swigt__p_Pythia8__Sigma3ff2HfftWW, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma3ff2HfftZZ[] = {  {&_swigt__p_Pythia8__Sigma3ff2HfftZZ, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma3gg2HQQbar[] = {  {&_swigt__p_Pythia8__Sigma3gg2HQQbar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma3gg2ggg[] = {  {&_swigt__p_Pythia8__Sigma3gg2ggg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma3gg2qqbarg[] = {  {&_swigt__p_Pythia8__Sigma3gg2qqbarg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma3qg2qgg[] = {  {&_swigt__p_Pythia8__Sigma3qg2qgg, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma3qg2qqqbarDiff[] = {  {&_swigt__p_Pythia8__Sigma3qg2qqqbarDiff, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma3qg2qqqbarSame[] = {  {&_swigt__p_Pythia8__Sigma3qg2qqqbarSame, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma3qq2qqgDiff[] = {  {&_swigt__p_Pythia8__Sigma3qg2qqqbarDiff, _p_Pythia8__Sigma3qg2qqqbarDiffTo_p_Pythia8__Sigma3qq2qqgDiff, 0, 0},  {&_swigt__p_Pythia8__Sigma3qq2qqgDiff, 0, 0, 0},  {&_swigt__p_Pythia8__Sigma3qqbar2qqbargDiff, _p_Pythia8__Sigma3qqbar2qqbargDiffTo_p_Pythia8__Sigma3qq2qqgDiff, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma3qq2qqgSame[] = {  {&_swigt__p_Pythia8__Sigma3qq2qqgSame, 0, 0, 0},  {&_swigt__p_Pythia8__Sigma3qqbar2qqbargSame, _p_Pythia8__Sigma3qqbar2qqbargSameTo_p_Pythia8__Sigma3qq2qqgSame, 0, 0},  {&_swigt__p_Pythia8__Sigma3qg2qqqbarSame, _p_Pythia8__Sigma3qg2qqqbarSameTo_p_Pythia8__Sigma3qq2qqgSame, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma3qqbar2HQQbar[] = {  {&_swigt__p_Pythia8__Sigma3qqbar2HQQbar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma3qqbar2ggg[] = {  {&_swigt__p_Pythia8__Sigma3gg2qqbarg, _p_Pythia8__Sigma3gg2qqbargTo_p_Pythia8__Sigma3qqbar2ggg, 0, 0},  {&_swigt__p_Pythia8__Sigma3qqbar2ggg, 0, 0, 0},  {&_swigt__p_Pythia8__Sigma3qg2qgg, _p_Pythia8__Sigma3qg2qggTo_p_Pythia8__Sigma3qqbar2ggg, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma3qqbar2qqbargDiff[] = {  {&_swigt__p_Pythia8__Sigma3qqbar2qqbargDiff, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sigma3qqbar2qqbargSame[] = {  {&_swigt__p_Pythia8__Sigma3qqbar2qqbargSame, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SigmaABMST[] = {  {&_swigt__p_Pythia8__SigmaABMST, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SigmaLHAProcess[] = {  {&_swigt__p_Pythia8__SigmaLHAProcess, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SigmaMBR[] = {  {&_swigt__p_Pythia8__SigmaMBR, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SigmaMultiparton[] = {  {&_swigt__p_Pythia8__SigmaMultiparton, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SigmaOniaSetup[] = {  {&_swigt__p_Pythia8__SigmaOniaSetup, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SigmaPartialWave[] = {  {&_swigt__p_Pythia8__SigmaPartialWave, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SigmaProcess[] = {  {&_swigt__p_Pythia8__Sigma2ffbar2ZW, _p_Pythia8__Sigma2ffbar2ZWTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2ffbarsgmZ, _p_Pythia8__Sigma2ffbar2ffbarsgmZTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2FFbarsgmZ, _p_Pythia8__Sigma2ffbar2FFbarsgmZTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbar2gmZ, _p_Pythia8__Sigma1ffbar2gmZTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2Sq2XXj, _p_Pythia8__Sigma2qg2Sq2XXjTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma3qq2qqgSame, _p_Pythia8__Sigma3qq2qqgSameTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2ffbarsgm, _p_Pythia8__Sigma2ffbar2ffbarsgmTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2LEDUnparticlegamma, _p_Pythia8__Sigma2ffbar2LEDUnparticlegammaTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma1gmgm2H, _p_Pythia8__Sigma1gmgm2HTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2QQbar3PJ1g, _p_Pythia8__Sigma2qqbar2QQbar3PJ1gTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2QQbar3PJ1g, _p_Pythia8__Sigma2gg2QQbar3PJ1gTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2gmgm2ffbar, _p_Pythia8__Sigma2gmgm2ffbarTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2QQbarX8q, _p_Pythia8__Sigma2qg2QQbarX8qTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2ffbarsW, _p_Pythia8__Sigma2ffbar2ffbarsWTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2FfbarsW, _p_Pythia8__Sigma2ffbar2FfbarsWTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2QQbar3S11g, _p_Pythia8__Sigma2gg2QQbar3S11gTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbarWggm, _p_Pythia8__Sigma2ffbarWggmTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2LEDqqbarNew, _p_Pythia8__Sigma2qqbar2LEDqqbarNewTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2qqbarNew, _p_Pythia8__Sigma2qqbar2qqbarNewTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2QQbar3PJ1q, _p_Pythia8__Sigma2qg2QQbar3PJ1qTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2LEDqg, _p_Pythia8__Sigma2qg2LEDqgTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2Zpg2XXj, _p_Pythia8__Sigma2qqbar2Zpg2XXjTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2Hglt, _p_Pythia8__Sigma2gg2HgltTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2LEDgg, _p_Pythia8__Sigma2gg2LEDggTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma1qqbar2KKgluonStar, _p_Pythia8__Sigma1qqbar2KKgluonStarTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2A3H12, _p_Pythia8__Sigma2ffbar2A3H12To_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2GravitonStarg, _p_Pythia8__Sigma2gg2GravitonStargTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2GravitonStarg, _p_Pythia8__Sigma2qqbar2GravitonStargTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2lStarlbar, _p_Pythia8__Sigma2qqbar2lStarlbarTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qgm2qgm, _p_Pythia8__Sigma2qgm2qgmTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2qqbar, _p_Pythia8__Sigma2gg2qqbarTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ggm2qqbar, _p_Pythia8__Sigma2ggm2qqbarTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qq2LEDqq, _p_Pythia8__Sigma2qq2LEDqqTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbar2Zv, _p_Pythia8__Sigma1ffbar2ZvTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma0AB2XB, _p_Pythia8__Sigma0AB2XBTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2Sg2XXj, _p_Pythia8__Sigma2gg2Sg2XXjTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbar2H, _p_Pythia8__Sigma1ffbar2HTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2GravitonStarq, _p_Pythia8__Sigma2qg2GravitonStarqTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2gmZq, _p_Pythia8__Sigma2qg2gmZqTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2LEDgammagamma, _p_Pythia8__Sigma2gg2LEDgammagammaTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2LEDgammagamma, _p_Pythia8__Sigma2ffbar2LEDgammagammaTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2gammagamma, _p_Pythia8__Sigma2ffbar2gammagammaTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2gammagamma, _p_Pythia8__Sigma2gg2gammagammaTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbar2Zp2XX, _p_Pythia8__Sigma1ffbar2Zp2XXTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2chi0chi0, _p_Pythia8__Sigma2qqbar2chi0chi0To_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2QCffbar2llbar, _p_Pythia8__Sigma2QCffbar2llbarTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2gmZgm, _p_Pythia8__Sigma2ffbar2gmZgmTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2lStarlStarBar, _p_Pythia8__Sigma2qqbar2lStarlStarBarTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbar2W, _p_Pythia8__Sigma1ffbar2WTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2LEDgg, _p_Pythia8__Sigma2qqbar2LEDggTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ff2fftgmZ, _p_Pythia8__Sigma2ff2fftgmZTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbar2GravitonStar, _p_Pythia8__Sigma1ffbar2GravitonStarTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma1gg2GravitonStar, _p_Pythia8__Sigma1gg2GravitonStarTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma3Process, _p_Pythia8__Sigma3ProcessTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2Process, _p_Pythia8__Sigma2ProcessTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__SigmaProcess, 0, 0, 0},  {&_swigt__p_Pythia8__Sigma0Process, _p_Pythia8__Sigma0ProcessTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma1Process, _p_Pythia8__Sigma1ProcessTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma0AB2XX, _p_Pythia8__Sigma0AB2XXTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__SigmaLHAProcess, _p_Pythia8__SigmaLHAProcessTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2QCqqbar2qqbar, _p_Pythia8__Sigma2QCqqbar2qqbarTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2LEDUnparticleZ, _p_Pythia8__Sigma2ffbar2LEDUnparticleZTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma1qg2qStar, _p_Pythia8__Sigma1qg2qStarTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2Wg, _p_Pythia8__Sigma2qqbar2WgTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbargmZWgmZW, _p_Pythia8__Sigma2ffbargmZWgmZWTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbar2WRight, _p_Pythia8__Sigma1ffbar2WRightTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2Wq, _p_Pythia8__Sigma2qg2WqTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma3qg2qgg, _p_Pythia8__Sigma3qg2qggTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2Hchgq, _p_Pythia8__Sigma2qg2HchgqTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11, _p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11To_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11, _p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11To_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2squarkgluino, _p_Pythia8__Sigma2qg2squarkgluinoTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2gluinogluino, _p_Pythia8__Sigma2gg2gluinogluinoTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2gluinogluino, _p_Pythia8__Sigma2qqbar2gluinogluinoTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2qg, _p_Pythia8__Sigma2qg2qgTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma3qg2qqqbarSame, _p_Pythia8__Sigma3qg2qqqbarSameTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2WW, _p_Pythia8__Sigma2ffbar2WWTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2LEDUnparticleg, _p_Pythia8__Sigma2qqbar2LEDUnparticlegTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2LEDUnparticleg, _p_Pythia8__Sigma2gg2LEDUnparticlegTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2Hq, _p_Pythia8__Sigma2qg2HqTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma1gg2S2XX, _p_Pythia8__Sigma1gg2S2XXTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma3gg2ggg, _p_Pythia8__Sigma3gg2gggTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma1lgm2lStar, _p_Pythia8__Sigma1lgm2lStarTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2Wgm, _p_Pythia8__Sigma2ffbar2WgmTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma3qqbar2qqbargSame, _p_Pythia8__Sigma3qqbar2qqbargSameTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma3gg2qqbarg, _p_Pythia8__Sigma3gg2qqbargTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma3qq2qqgDiff, _p_Pythia8__Sigma3qq2qqgDiffTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbar2Rhorizontal, _p_Pythia8__Sigma1ffbar2RhorizontalTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2HW, _p_Pythia8__Sigma2ffbar2HWTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2LQLQbar, _p_Pythia8__Sigma2qqbar2LQLQbarTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2LQLQbar, _p_Pythia8__Sigma2gg2LQLQbarTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2LEDUnparticleq, _p_Pythia8__Sigma2qg2LEDUnparticleqTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2HZ, _p_Pythia8__Sigma2ffbar2HZTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2gg, _p_Pythia8__Sigma2qqbar2ggTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma3ff2HfftZZ, _p_Pythia8__Sigma3ff2HfftZZTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qgm2qg, _p_Pythia8__Sigma2qgm2qgTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2LEDllbar, _p_Pythia8__Sigma2gg2LEDllbarTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2LEDllbar, _p_Pythia8__Sigma2ffbar2LEDllbarTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2qGqGbar, _p_Pythia8__Sigma2gg2qGqGbarTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2qGqGbar, _p_Pythia8__Sigma2qqbar2qGqGbarTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbar2Wprime, _p_Pythia8__Sigma1ffbar2WprimeTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2chargluino, _p_Pythia8__Sigma2qqbar2chargluinoTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2chi0gluino, _p_Pythia8__Sigma2qqbar2chi0gluinoTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2fGfGbar, _p_Pythia8__Sigma2ffbar2fGfGbarTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2LEDqqbar, _p_Pythia8__Sigma2gg2LEDqqbarTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2charchar, _p_Pythia8__Sigma2qqbar2charcharTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbar2ZRight, _p_Pythia8__Sigma1ffbar2ZRightTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2HchgchgHchgchg, _p_Pythia8__Sigma2ffbar2HchgchgHchgchgTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma1ll2Hchgchg, _p_Pythia8__Sigma1ll2HchgchgTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qq2qStarq, _p_Pythia8__Sigma2qq2qStarqTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2gg, _p_Pythia8__Sigma2gg2ggTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma3ff2HchgchgfftWW, _p_Pythia8__Sigma3ff2HchgchgfftWWTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2fgm2gmZf, _p_Pythia8__Sigma2fgm2gmZfTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2QQbar3S11gm, _p_Pythia8__Sigma2gg2QQbar3S11gmTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2lgm2Hchgchgl, _p_Pythia8__Sigma2lgm2HchgchglTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2Hglt, _p_Pythia8__Sigma2qqbar2HgltTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbar2Hchg, _p_Pythia8__Sigma1ffbar2HchgTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma3qqbar2HQQbar, _p_Pythia8__Sigma3qqbar2HQQbarTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma3gg2HQQbar, _p_Pythia8__Sigma3gg2HQQbarTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma0AB2AB, _p_Pythia8__Sigma0AB2ABTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2QQbar3DJ1g, _p_Pythia8__Sigma2gg2QQbar3DJ1gTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbarZprimeWprime, _p_Pythia8__Sigma1ffbarZprimeWprimeTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2gmZg, _p_Pythia8__Sigma2qqbar2gmZgTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2sleptonantislepton, _p_Pythia8__Sigma2qqbar2sleptonantisleptonTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma0nonDiffractive, _p_Pythia8__Sigma0nonDiffractiveTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2squarkantisquark, _p_Pythia8__Sigma2gg2squarkantisquarkTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2squarkantisquark, _p_Pythia8__Sigma2qqbar2squarkantisquarkTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qq2squarksquark, _p_Pythia8__Sigma2qq2squarksquarkTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma1qq2antisquark, _p_Pythia8__Sigma1qq2antisquarkTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbargmZggm, _p_Pythia8__Sigma2ffbargmZggmTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qq2QqtW, _p_Pythia8__Sigma2qq2QqtWTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma0AB2AXB, _p_Pythia8__Sigma0AB2AXBTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2QCqq2qq, _p_Pythia8__Sigma2QCqq2qqTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2charchi0, _p_Pythia8__Sigma2qqbar2charchi0To_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qq2qq, _p_Pythia8__Sigma2qq2qqTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma1ffbar2gmZZprime, _p_Pythia8__Sigma1ffbar2gmZZprimeTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2QQbar, _p_Pythia8__Sigma2gg2QQbarTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2gmZgmZ, _p_Pythia8__Sigma2ffbar2gmZgmZTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2LeptoQuarkl, _p_Pythia8__Sigma2qg2LeptoQuarklTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma0AB2AX, _p_Pythia8__Sigma0AB2AXTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2ZpH, _p_Pythia8__Sigma2ffbar2ZpHTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma1ql2LeptoQuark, _p_Pythia8__Sigma1ql2LeptoQuarkTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma3qg2qqqbarDiff, _p_Pythia8__Sigma3qg2qqqbarDiffTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2TEVffbar, _p_Pythia8__Sigma2ffbar2TEVffbarTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2ggamma, _p_Pythia8__Sigma2gg2ggammaTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2ggamma, _p_Pythia8__Sigma2qqbar2ggammaTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2SUSY, _p_Pythia8__Sigma2SUSYTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma3qqbar2qqbargDiff, _p_Pythia8__Sigma3qqbar2qqbargDiffTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2HchgH12, _p_Pythia8__Sigma2ffbar2HchgH12To_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2chi0squark, _p_Pythia8__Sigma2qg2chi0squarkTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2charsquark, _p_Pythia8__Sigma2qg2charsquarkTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2fgm2Wf, _p_Pythia8__Sigma2fgm2WfTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma3ff2HfftWW, _p_Pythia8__Sigma3ff2HfftWWTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ffbar2HposHneg, _p_Pythia8__Sigma2ffbar2HposHnegTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2ff2fftW, _p_Pythia8__Sigma2ff2fftWTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma3qqbar2ggg, _p_Pythia8__Sigma3qqbar2gggTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2Zpq2XXj, _p_Pythia8__Sigma2qg2Zpq2XXjTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2QQbar, _p_Pythia8__Sigma2qqbar2QQbarTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2Hqlt, _p_Pythia8__Sigma2qg2HqltTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qg2qgamma, _p_Pythia8__Sigma2qg2qgammaTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2gg2QQbarX8g, _p_Pythia8__Sigma2gg2QQbarX8gTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma2qqbar2QQbarX8g, _p_Pythia8__Sigma2qqbar2QQbarX8gTo_p_Pythia8__SigmaProcess, 0, 0},  {&_swigt__p_Pythia8__Sigma1gg2H, _p_Pythia8__Sigma1gg2HTo_p_Pythia8__SigmaProcess, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SigmaRPP[] = {  {&_swigt__p_Pythia8__SigmaRPP, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SigmaSaSDL[] = {  {&_swigt__p_Pythia8__SigmaSaSDL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SigmaTotAux[] = {  {&_swigt__p_Pythia8__SigmaSaSDL, _p_Pythia8__SigmaSaSDLTo_p_Pythia8__SigmaTotAux, 0, 0},  {&_swigt__p_Pythia8__SigmaTotOwn, _p_Pythia8__SigmaTotOwnTo_p_Pythia8__SigmaTotAux, 0, 0},  {&_swigt__p_Pythia8__SigmaABMST, _p_Pythia8__SigmaABMSTTo_p_Pythia8__SigmaTotAux, 0, 0},  {&_swigt__p_Pythia8__SigmaTotAux, 0, 0, 0},  {&_swigt__p_Pythia8__SigmaMBR, _p_Pythia8__SigmaMBRTo_p_Pythia8__SigmaTotAux, 0, 0},  {&_swigt__p_Pythia8__SigmaRPP, _p_Pythia8__SigmaRPPTo_p_Pythia8__SigmaTotAux, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SigmaTotOwn[] = {  {&_swigt__p_Pythia8__SigmaTotOwn, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SigmaTotal[] = {  {&_swigt__p_Pythia8__SigmaTotal, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SingleCell[] = {  {&_swigt__p_Pythia8__SingleCell, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SingleCellJet[] = {  {&_swigt__p_Pythia8__SingleCellJet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SingleClusterJet[] = {  {&_swigt__p_Pythia8__SingleClusterJet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SingleSlowJet[] = {  {&_swigt__p_Pythia8__SingleSlowJet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SlowJet[] = {  {&_swigt__p_Pythia8__SlowJet, 0, 0, 0},  {&_swigt__p_Pythia8__HJSlowJet, _p_Pythia8__HJSlowJetTo_p_Pythia8__SlowJet, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SlowJetHook[] = {  {&_swigt__p_Pythia8__SlowJetHook, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SpaceDipoleEnd[] = {  {&_swigt__p_Pythia8__SpaceDipoleEnd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SpaceShower[] = {  {&_swigt__p_Pythia8__SpaceShower, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Sphericity[] = {  {&_swigt__p_Pythia8__Sphericity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__StauWidths[] = {  {&_swigt__p_Pythia8__StauWidths, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__StringEnd[] = {  {&_swigt__p_Pythia8__StringEnd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__StringFlav[] = {  {&_swigt__p_Pythia8__StringFlav, 0, 0, 0},  {&_swigt__p_Pythia8__HVStringFlav, _p_Pythia8__HVStringFlavTo_p_Pythia8__StringFlav, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__StringFragmentation[] = {  {&_swigt__p_Pythia8__StringFragmentation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__StringLength[] = {  {&_swigt__p_Pythia8__StringLength, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__StringPT[] = {  {&_swigt__p_Pythia8__StringPT, 0, 0, 0},  {&_swigt__p_Pythia8__HVStringPT, _p_Pythia8__HVStringPTTo_p_Pythia8__StringPT, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__StringRegion[] = {  {&_swigt__p_Pythia8__StringRegion, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__StringSystem[] = {  {&_swigt__p_Pythia8__StringSystem, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__StringVertex[] = {  {&_swigt__p_Pythia8__StringVertex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__StringZ[] = {  {&_swigt__p_Pythia8__StringZ, 0, 0, 0},  {&_swigt__p_Pythia8__HVStringZ, _p_Pythia8__HVStringZTo_p_Pythia8__StringZ, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SubCollision[] = {  {&_swigt__p_Pythia8__SubCollision, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SubCollisionModel[] = {  {&_swigt__p_Pythia8__SubCollisionModel, 0, 0, 0},  {&_swigt__p_Pythia8__NaiveSubCollisionModel, _p_Pythia8__NaiveSubCollisionModelTo_p_Pythia8__SubCollisionModel, 0, 0},  {&_swigt__p_Pythia8__DoubleStrikman, _p_Pythia8__DoubleStrikmanTo_p_Pythia8__SubCollisionModel, 0, 0},  {&_swigt__p_Pythia8__MultiRadial, _p_Pythia8__MultiRadialTo_p_Pythia8__SubCollisionModel, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SubCollisionModel__SigEst[] = {  {&_swigt__p_Pythia8__SubCollisionModel__SigEst, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SuppressSmallPT[] = {  {&_swigt__p_Pythia8__SuppressSmallPT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__SusyLesHouches[] = {  {&_swigt__p_Pythia8__SusyLesHouches, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__TauDecays[] = {  {&_swigt__p_Pythia8__TauDecays, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Thrust[] = {  {&_swigt__p_Pythia8__Thrust, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__TimeDipoleEnd[] = {  {&_swigt__p_Pythia8__TimeDipoleEnd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__TimeShower[] = {  {&_swigt__p_Pythia8__TimeShower, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__TopReconUserHooks[] = {  {&_swigt__p_Pythia8__TopReconUserHooks, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__TrialReconnection[] = {  {&_swigt__p_Pythia8__TrialReconnection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__UserHooks[] = {  {&_swigt__p_Pythia8__amcnlo_unitarised_interface, _p_Pythia8__amcnlo_unitarised_interfaceTo_p_Pythia8__UserHooks, 0, 0},  {&_swigt__p_Pythia8__JetMatchingAlpgen, _p_Pythia8__JetMatchingAlpgenTo_p_Pythia8__UserHooks, 0, 0},  {&_swigt__p_Pythia8__SuppressSmallPT, _p_Pythia8__SuppressSmallPTTo_p_Pythia8__UserHooks, 0, 0},  {&_swigt__p_Pythia8__UserHooksVector, _p_Pythia8__UserHooksVectorTo_p_Pythia8__UserHooks, 0, 0},  {&_swigt__p_Pythia8__AlpgenHooks, _p_Pythia8__AlpgenHooksTo_p_Pythia8__UserHooks, 0, 0},  {&_swigt__p_Pythia8__PowhegHooks, _p_Pythia8__PowhegHooksTo_p_Pythia8__UserHooks, 0, 0},  {&_swigt__p_Pythia8__UserHooks, 0, 0, 0},  {&_swigt__p_Pythia8__MBReconUserHooks, _p_Pythia8__MBReconUserHooksTo_p_Pythia8__UserHooks, 0, 0},  {&_swigt__p_Pythia8__TopReconUserHooks, _p_Pythia8__TopReconUserHooksTo_p_Pythia8__UserHooks, 0, 0},  {&_swigt__p_Pythia8__JetMatching, _p_Pythia8__JetMatchingTo_p_Pythia8__UserHooks, 0, 0},  {&_swigt__p_Pythia8__JetMatchingAlpgenInputAlpgen, _p_Pythia8__JetMatchingAlpgenInputAlpgenTo_p_Pythia8__UserHooks, 0, 0},  {&_swigt__p_Pythia8__JetMatchingMadgraphInputAlpgen, _p_Pythia8__JetMatchingMadgraphInputAlpgenTo_p_Pythia8__UserHooks, 0, 0},  {&_swigt__p_Pythia8__JetMatchingMadgraph, _p_Pythia8__JetMatchingMadgraphTo_p_Pythia8__UserHooks, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__UserHooksVector[] = {  {&_swigt__p_Pythia8__UserHooksVector, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Vec4[] = {  {&_swigt__p_Pythia8__Vec4, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__WVec[] = {  {&_swigt__p_Pythia8__WVec, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Wave4[] = {  {&_swigt__p_Pythia8__Wave4, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__WeakShowerMEs[] = {  {&_swigt__p_Pythia8__WeakShowerMEs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__WidthFunction[] = {  {&_swigt__p_Pythia8__StauWidths, _p_Pythia8__StauWidthsTo_p_Pythia8__WidthFunction, 0, 0},  {&_swigt__p_Pythia8__WidthFunction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__WoodsSaxonModel[] = {  {&_swigt__p_Pythia8__WoodsSaxonModel, 0, 0, 0},  {&_swigt__p_Pythia8__GLISSANDOModel, _p_Pythia8__GLISSANDOModelTo_p_Pythia8__WoodsSaxonModel, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Word[] = {  {&_swigt__p_Pythia8__Word, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__Writer[] = {  {&_swigt__p_Pythia8__Writer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__XMLTag[] = {  {&_swigt__p_Pythia8__XMLTag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__amcnlo_unitarised_interface[] = {  {&_swigt__p_Pythia8__amcnlo_unitarised_interface, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Pythia8__nPDF[] = {  {&_swigt__p_Pythia8__Isospin, _p_Pythia8__IsospinTo_p_Pythia8__nPDF, 0, 0},  {&_swigt__p_Pythia8__EPPS16, _p_Pythia8__EPPS16To_p_Pythia8__nPDF, 0, 0},  {&_swigt__p_Pythia8__nPDF, 0, 0, 0},  {&_swigt__p_Pythia8__EPS09, _p_Pythia8__EPS09To_p_Pythia8__nPDF, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_State[] = {  {&_swigt__p_State, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_3__std__complexT_double_t[] = {  {&_swigt__p_a_3__std__complexT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_4__std__complexT_double_t[] = {  {&_swigt__p_a_4__std__complexT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_6__std__complexT_double_t[] = {  {&_swigt__p_a_6__std__complexT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_7__std__complexT_double_t[] = {  {&_swigt__p_a_7__std__complexT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_8__double[] = {  {&_swigt__p_a_8__double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_allocator_type[] = {  {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t[] = {  {&_swigt__p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bool[] = {  {&_swigt__p_bool, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char_type[] = {  {&_swigt__p_char_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_const_reference[] = {  {&_swigt__p_const_reference, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_difference_type[] = {  {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_enum_std__ios_base__event_r_std__ios_base_int__void[] = {  {&_swigt__p_f_enum_std__ios_base__event_r_std__ios_base_int__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t[] = {{&_swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t[] = {{&_swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t[] = {{&_swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t[] = {{&_swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t[] = {{&_swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t[] = {{&_swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t[] = {  {&_swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t, 0, 0, 0},  {&_swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t, _p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_tTo_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t, 0, 0},  {&_swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t, _p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_tTo_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t, 0, 0},  {&_swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t, _p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_tTo_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t, 0, 0},  {&_swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, _p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t, 0, 0},  {&_swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, _p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t, 0, 0},  {&_swigt__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, _p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t[] = {{&_swigt__p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t[] = {{&_swigt__p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t[] = {{&_swigt__p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t[] = {  {&_swigt__p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0, 0, 0},  {&_swigt__p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t, _p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_tTo_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0, 0},  {&_swigt__p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, _p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0, 0},  {&_swigt__p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, _p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t[] = {{&_swigt__p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t[] = {{&_swigt__p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t[] = {{&_swigt__p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t[] = {  {&_swigt__p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0, 0, 0},  {&_swigt__p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t, _p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_tTo_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0, 0},  {&_swigt__p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, _p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0, 0},  {&_swigt__p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, _p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_std__ios_base__r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t[] = {{&_swigt__p_f_r_std__ios_base__r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_std__ios_base__r_std__basic_ostreamT_char_std__char_traitsT_char_t_t[] = {{&_swigt__p_f_r_std__ios_base__r_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_std__ios_base__r_std__basic_istreamT_char_std__char_traitsT_char_t_t[] = {{&_swigt__p_f_r_std__ios_base__r_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_std__ios_base__r_std__basic_iosT_char_std__char_traitsT_char_t_t[] = {{&_swigt__p_f_r_std__ios_base__r_std__basic_iosT_char_std__char_traitsT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_std__ios_base__r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t[] = {{&_swigt__p_f_r_std__ios_base__r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_std__ios_base__r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t[] = {{&_swigt__p_f_r_std__ios_base__r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_std__ios_base__r_std__basic_iostreamT_char_std__char_traitsT_char_t_t[] = {{&_swigt__p_f_r_std__ios_base__r_std__basic_iostreamT_char_std__char_traitsT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_std__ios_base__r_std__ios_base[] = {  {&_swigt__p_f_r_std__ios_base__r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, _p_f_r_std__ios_base__r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_f_r_std__ios_base__r_std__ios_base, 0, 0},  {&_swigt__p_f_r_std__ios_base__r_std__basic_ostreamT_char_std__char_traitsT_char_t_t, _p_f_r_std__ios_base__r_std__basic_ostreamT_char_std__char_traitsT_char_t_tTo_p_f_r_std__ios_base__r_std__ios_base, 0, 0},  {&_swigt__p_f_r_std__ios_base__r_std__basic_istreamT_char_std__char_traitsT_char_t_t, _p_f_r_std__ios_base__r_std__basic_istreamT_char_std__char_traitsT_char_t_tTo_p_f_r_std__ios_base__r_std__ios_base, 0, 0},  {&_swigt__p_f_r_std__ios_base__r_std__ios_base, 0, 0, 0},  {&_swigt__p_f_r_std__ios_base__r_std__basic_iosT_char_std__char_traitsT_char_t_t, _p_f_r_std__ios_base__r_std__basic_iosT_char_std__char_traitsT_char_t_tTo_p_f_r_std__ios_base__r_std__ios_base, 0, 0},  {&_swigt__p_f_r_std__ios_base__r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, _p_f_r_std__ios_base__r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_f_r_std__ios_base__r_std__ios_base, 0, 0},  {&_swigt__p_f_r_std__ios_base__r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, _p_f_r_std__ios_base__r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_f_r_std__ios_base__r_std__ios_base, 0, 0},  {&_swigt__p_f_r_std__ios_base__r_std__basic_iostreamT_char_std__char_traitsT_char_t_t, _p_f_r_std__ios_base__r_std__basic_iostreamT_char_std__char_traitsT_char_t_tTo_p_f_r_std__ios_base__r_std__ios_base, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_first_type[] = {  {&_swigt__p_first_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_fmtflags[] = {  {&_swigt__p_fmtflags, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ifstream[] = {  {&_swigt__p_ifstream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int_type[] = {  {&_swigt__p_int_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iostate[] = {  {&_swigt__p_iostate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_key_type[] = {  {&_swigt__p_key_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long_double[] = {  {&_swigt__p_long_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long_long[] = {  {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mapped_type[] = {  {&_swigt__p_mapped_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_off_type[] = {  {&_swigt__p_off_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_openmode[] = {  {&_swigt__p_openmode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_PyObject[] = {  {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Pythia8__ColourDipole[] = {  {&_swigt__p_p_Pythia8__ColourDipole, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t[] = {{&_swigt__p_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_std__basic_iostreamT_char_std__char_traitsT_char_t_t[] = {{&_swigt__p_p_std__basic_iostreamT_char_std__char_traitsT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t[] = {{&_swigt__p_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_std__basic_istreamT_char_std__char_traitsT_char_t_t[] = {  {&_swigt__p_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0, 0, 0},  {&_swigt__p_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, _p_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0, 0},  {&_swigt__p_p_std__basic_iostreamT_char_std__char_traitsT_char_t_t, _p_p_std__basic_iostreamT_char_std__char_traitsT_char_t_tTo_p_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0, 0},  {&_swigt__p_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, _p_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_void[] = {  {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_pos_t[] = {  {&_swigt__p_pos_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_pos_type[] = {  {&_swigt__p_pos_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_reference[] = {  {&_swigt__p_reference, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_second_type[] = {  {&_swigt__p_second_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_seekdir[] = {  {&_swigt__p_seekdir, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_size_t[] = {  {&_swigt__p_size_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_size_type[] = {  {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_state_type[] = {  {&_swigt__p_state_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_Pythia8__Clustering_t[] = {  {&_swigt__p_std__allocatorT_Pythia8__Clustering_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_Pythia8__HelicityParticle_t[] = {  {&_swigt__p_std__allocatorT_Pythia8__HelicityParticle_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_Pythia8__ProcessContainer_p_t[] = {  {&_swigt__p_std__allocatorT_Pythia8__ProcessContainer_p_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_Pythia8__ResonanceWidths_p_t[] = {  {&_swigt__p_std__allocatorT_Pythia8__ResonanceWidths_p_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_Pythia8__SigmaProcess_p_t[] = {  {&_swigt__p_std__allocatorT_Pythia8__SigmaProcess_p_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_Pythia8__Vec4_t[] = {  {&_swigt__p_std__allocatorT_Pythia8__Vec4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_bool_t[] = {  {&_swigt__p_std__allocatorT_bool_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_double_t[] = {  {&_swigt__p_std__allocatorT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_int_t[] = {  {&_swigt__p_std__allocatorT_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__complexT_double_t_t[] = {  {&_swigt__p_std__allocatorT_std__complexT_double_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__pairT_int_const_int_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_int_const_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__pairT_int_int_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_int_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__pairT_std__string_const_std__string_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_std__string_const_std__string_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__string_t[] = {  {&_swigt__p_std__allocatorT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t[] = {  {&_swigt__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t[] = {  {&_swigt__p_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__basic_iosT_char_std__char_traitsT_char_t_t[] = {  {&_swigt__p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0, 0, 0},  {&_swigt__p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, _p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0, 0},  {&_swigt__p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, _p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0, 0},  {&_swigt__p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, _p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0, 0},  {&_swigt__p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, _p_std__basic_ostreamT_char_std__char_traitsT_char_t_tTo_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0, 0},  {&_swigt__p_std__basic_iostreamT_char_std__char_traitsT_char_t_t, _p_std__basic_iostreamT_char_std__char_traitsT_char_t_tTo_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0, 0},  {&_swigt__p_std__basic_istreamT_char_std__char_traitsT_char_t_t, _p_std__basic_istreamT_char_std__char_traitsT_char_t_tTo_p_std__basic_iosT_char_std__char_traitsT_char_t_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__basic_iostreamT_char_std__char_traitsT_char_t_t[] = {  {&_swigt__p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, _p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_std__basic_iostreamT_char_std__char_traitsT_char_t_t, 0, 0},  {&_swigt__p_std__basic_iostreamT_char_std__char_traitsT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__basic_istreamT_char_std__char_traitsT_char_t_t[] = {  {&_swigt__p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, _p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0, 0},  {&_swigt__p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, _p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0, 0},  {&_swigt__p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0, 0, 0},  {&_swigt__p_std__basic_iostreamT_char_std__char_traitsT_char_t_t, _p_std__basic_iostreamT_char_std__char_traitsT_char_t_tTo_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t[] = {  {&_swigt__p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__basic_ostreamT_char_std__char_traitsT_char_t_t[] = {  {&_swigt__p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, _p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0, 0},  {&_swigt__p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, _p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0, 0},  {&_swigt__p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0, 0, 0},  {&_swigt__p_std__basic_iostreamT_char_std__char_traitsT_char_t_t, _p_std__basic_iostreamT_char_std__char_traitsT_char_t_tTo_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t[] = {  {&_swigt__p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__basic_streambufT_char_std__char_traitsT_char_t_t[] = {  {&_swigt__p_std__basic_streambufT_char_std__char_traitsT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t[] = {  {&_swigt__p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__basic_stringbufT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t[] = {  {&_swigt__p_std__basic_stringbufT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t[] = {  {&_swigt__p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__complexT_double_t[] = {  {&_swigt__p_std__complexT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__ifstream[] = {  {&_swigt__p_std__ifstream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__invalid_argument[] = {  {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__ios_base[] = {  {&_swigt__p_std__basic_iosT_char_std__char_traitsT_char_t_t, _p_std__basic_iosT_char_std__char_traitsT_char_t_tTo_p_std__ios_base, 0, 0},  {&_swigt__p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, _p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_std__ios_base, 0, 0},  {&_swigt__p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, _p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_std__ios_base, 0, 0},  {&_swigt__p_std__ios_base, 0, 0, 0},  {&_swigt__p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, _p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_tTo_p_std__ios_base, 0, 0},  {&_swigt__p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, _p_std__basic_ostreamT_char_std__char_traitsT_char_t_tTo_p_std__ios_base, 0, 0},  {&_swigt__p_std__basic_iostreamT_char_std__char_traitsT_char_t_t, _p_std__basic_iostreamT_char_std__char_traitsT_char_t_tTo_p_std__ios_base, 0, 0},  {&_swigt__p_std__basic_istreamT_char_std__char_traitsT_char_t_t, _p_std__basic_istreamT_char_std__char_traitsT_char_t_tTo_p_std__ios_base, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__lessT_double_t[] = {  {&_swigt__p_std__lessT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__lessT_int_t[] = {  {&_swigt__p_std__lessT_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__lessT_std__string_t[] = {  {&_swigt__p_std__lessT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__locale[] = {  {&_swigt__p_std__locale, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_Pythia8__Nucleon_p_std__pairT_int_int_t_std__lessT_Pythia8__Nucleon_p_t_std__allocatorT_std__pairT_Pythia8__Nucleon_pconst_std__pairT_int_int_t_t_t_t[] = {  {&_swigt__p_std__mapT_Pythia8__Nucleon_p_std__pairT_int_int_t_std__lessT_Pythia8__Nucleon_p_t_std__allocatorT_std__pairT_Pythia8__Nucleon_pconst_std__pairT_int_int_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t[] = {  {&_swigt__p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_int_double_std__lessT_int_t_std__allocatorT_std__pairT_int_const_double_t_t_t[] = {  {&_swigt__p_std__mapT_int_double_std__lessT_int_t_std__allocatorT_std__pairT_int_const_double_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t[] = {  {&_swigt__p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t[] = {  {&_swigt__p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t[] = {  {&_swigt__p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_std__string_Pythia8__LHAweight_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweight_t_t_t[] = {  {&_swigt__p_std__mapT_std__string_Pythia8__LHAweight_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweight_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_std__string_Pythia8__LHAweightgroup_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweightgroup_t_t_t[] = {  {&_swigt__p_std__mapT_std__string_Pythia8__LHAweightgroup_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweightgroup_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_std__string_Pythia8__LHAwgt_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAwgt_t_t_t[] = {  {&_swigt__p_std__mapT_std__string_Pythia8__LHAwgt_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAwgt_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_std__string_Pythia8__LHgenericBlock_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHgenericBlock_t_t_t[] = {  {&_swigt__p_std__mapT_std__string_Pythia8__LHgenericBlock_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHgenericBlock_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t[] = {  {&_swigt__p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t[] = {  {&_swigt__p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t[] = {  {&_swigt__p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t[] = {  {&_swigt__p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_std__string_Pythia8__WVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__WVec_t_t_t[] = {  {&_swigt__p_std__mapT_std__string_Pythia8__WVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__WVec_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t[] = {  {&_swigt__p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t[] = {  {&_swigt__p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t[] = {  {&_swigt__p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__multisetT_Pythia8__SubCollision_std__lessT_Pythia8__SubCollision_t_std__allocatorT_Pythia8__SubCollision_t_t[] = {  {&_swigt__p_std__multisetT_Pythia8__SubCollision_std__lessT_Pythia8__SubCollision_t_std__allocatorT_Pythia8__SubCollision_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__ofstream[] = {  {&_swigt__p_std__ofstream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_Pythia8__RotBstMatrix_Pythia8__RotBstMatrix_t[] = {  {&_swigt__p_std__pairT_Pythia8__RotBstMatrix_Pythia8__RotBstMatrix_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_Pythia8__Vec4_Pythia8__Vec4_t[] = {  {&_swigt__p_std__pairT_Pythia8__Vec4_Pythia8__Vec4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_double_double_t[] = {  {&_swigt__p_std__pairT_double_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_int_int_t[] = {  {&_swigt__p_std__pairT_int_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_long_long_t[] = {  {&_swigt__p_std__pairT_long_long_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__setT_int_std__lessT_int_t_std__allocatorT_int_t_t[] = {  {&_swigt__p_std__setT_int_std__lessT_int_t_std__allocatorT_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__string[] = {  {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__string__size_type[] = {  {&_swigt__p_std__string__size_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t[] = {  {&_swigt__p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t[] = {  {&_swigt__p_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t[] = {  {&_swigt__p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Pythia8__InBeam_std__allocatorT_Pythia8__InBeam_t_t[] = {  {&_swigt__p_std__vectorT_Pythia8__InBeam_std__allocatorT_Pythia8__InBeam_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Pythia8__InPair_std__allocatorT_Pythia8__InPair_t_t[] = {  {&_swigt__p_std__vectorT_Pythia8__InPair_std__allocatorT_Pythia8__InPair_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Pythia8__LHAParticle_std__allocatorT_Pythia8__LHAParticle_t_t[] = {  {&_swigt__p_std__vectorT_Pythia8__LHAParticle_std__allocatorT_Pythia8__LHAParticle_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Pythia8__LHAgenerator_std__allocatorT_Pythia8__LHAgenerator_t_t[] = {  {&_swigt__p_std__vectorT_Pythia8__LHAgenerator_std__allocatorT_Pythia8__LHAgenerator_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Pythia8__LHblockT_int_t_std__allocatorT_Pythia8__LHblockT_int_t_t_t[] = {  {&_swigt__p_std__vectorT_Pythia8__LHblockT_int_t_std__allocatorT_Pythia8__LHblockT_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Pythia8__LHdecayTable_std__allocatorT_Pythia8__LHdecayTable_t_t[] = {  {&_swigt__p_std__vectorT_Pythia8__LHdecayTable_std__allocatorT_Pythia8__LHdecayTable_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Pythia8__Nucleon_std__allocatorT_Pythia8__Nucleon_t_t[] = {  {&_swigt__p_std__vectorT_Pythia8__Nucleon_std__allocatorT_Pythia8__Nucleon_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Pythia8__PhaseSpace_p_std__allocatorT_Pythia8__PhaseSpace_p_t_t[] = {  {&_swigt__p_std__vectorT_Pythia8__PhaseSpace_p_std__allocatorT_Pythia8__PhaseSpace_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t[] = {  {&_swigt__p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t[] = {  {&_swigt__p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t[] = {  {&_swigt__p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Pythia8__StringRegion_std__allocatorT_Pythia8__StringRegion_t_t[] = {  {&_swigt__p_std__vectorT_Pythia8__StringRegion_std__allocatorT_Pythia8__StringRegion_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Pythia8__StringVertex_std__allocatorT_Pythia8__StringVertex_t_t[] = {  {&_swigt__p_std__vectorT_Pythia8__StringVertex_std__allocatorT_Pythia8__StringVertex_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Pythia8__UserHooks_p_std__allocatorT_Pythia8__UserHooks_p_t_t[] = {  {&_swigt__p_std__vectorT_Pythia8__UserHooks_p_std__allocatorT_Pythia8__UserHooks_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t[] = {  {&_swigt__p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Pythia8__XMLTag_p_std__allocatorT_Pythia8__XMLTag_p_t_t[] = {  {&_swigt__p_std__vectorT_Pythia8__XMLTag_p_std__allocatorT_Pythia8__XMLTag_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_bool_std__allocatorT_bool_t_t[] = {  {&_swigt__p_std__vectorT_bool_std__allocatorT_bool_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_double_std__allocatorT_double_t_t[] = {  {&_swigt__p_std__vectorT_double_std__allocatorT_double_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_int_std__allocatorT_int_t_t[] = {  {&_swigt__p_std__vectorT_int_std__allocatorT_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_long_std__allocatorT_long_t_t[] = {  {&_swigt__p_std__vectorT_long_std__allocatorT_long_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t[] = {  {&_swigt__p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t[] = {  {&_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t_std__allocatorT_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t_t_t[] = {  {&_swigt__p_std__vectorT_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t_std__allocatorT_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t[] = {  {&_swigt__p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t[] = {  {&_swigt__p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t[] = {  {&_swigt__p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t_std__allocatorT_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t_t_t[] = {  {&_swigt__p_std__vectorT_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t_std__allocatorT_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_streamoff[] = {  {&_swigt__p_streamoff, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_streampos[] = {  {&_swigt__p_streampos, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_stringstream[] = {  {&_swigt__p_stringstream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_swig__SwigPyIterator[] = {  {&_swigt__p_swig__SwigPyIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_traits_type[] = {  {&_swigt__p_traits_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_long_long[] = {  {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_value_type[] = {  {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};

static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_Pythia8__AlpgenHooks,
  _swigc__p_Pythia8__AlpgenPar,
  _swigc__p_Pythia8__AlphaEM,
  _swigc__p_Pythia8__AlphaStrong,
  _swigc__p_Pythia8__Angantyr,
  _swigc__p_Pythia8__BeamParticle,
  _swigc__p_Pythia8__BeamRemnants,
  _swigc__p_Pythia8__BeamShape,
  _swigc__p_Pythia8__BoseEinstein,
  _swigc__p_Pythia8__BoseEinsteinHadron,
  _swigc__p_Pythia8__CJKL,
  _swigc__p_Pythia8__CTEQ5L,
  _swigc__p_Pythia8__CTEQ6pdf,
  _swigc__p_Pythia8__CellJet,
  _swigc__p_Pythia8__ClusterJet,
  _swigc__p_Pythia8__Clustering,
  _swigc__p_Pythia8__ColConfig,
  _swigc__p_Pythia8__ColSinglet,
  _swigc__p_Pythia8__ColourDipole,
  _swigc__p_Pythia8__ColourJunction,
  _swigc__p_Pythia8__ColourParticle,
  _swigc__p_Pythia8__ColourReconnection,
  _swigc__p_Pythia8__ColourTracing,
  _swigc__p_Pythia8__CombineMatchingInput,
  _swigc__p_Pythia8__CoupSM,
  _swigc__p_Pythia8__CoupSUSY,
  _swigc__p_Pythia8__Couplings,
  _swigc__p_Pythia8__DecayChannel,
  _swigc__p_Pythia8__DecayHandler,
  _swigc__p_Pythia8__DoubleStrikman,
  _swigc__p_Pythia8__DummyForStreams,
  _swigc__p_Pythia8__EPAexternal,
  _swigc__p_Pythia8__EPPS16,
  _swigc__p_Pythia8__EPS09,
  _swigc__p_Pythia8__Event,
  _swigc__p_Pythia8__EventInfo,
  _swigc__p_Pythia8__FVec,
  _swigc__p_Pythia8__Flag,
  _swigc__p_Pythia8__FlavContainer,
  _swigc__p_Pythia8__FlavourRope,
  _swigc__p_Pythia8__GLISSANDOModel,
  _swigc__p_Pythia8__GRV94L,
  _swigc__p_Pythia8__GRVpiL,
  _swigc__p_Pythia8__GammaKinematics,
  _swigc__p_Pythia8__GammaMatrix,
  _swigc__p_Pythia8__GammaPoint,
  _swigc__p_Pythia8__HEPEUP,
  _swigc__p_Pythia8__HEPRUP,
  _swigc__p_Pythia8__HIInfo,
  _swigc__p_Pythia8__HIUserHooks,
  _swigc__p_Pythia8__HJSlowJet,
  _swigc__p_Pythia8__HMEGamma2TwoFermions,
  _swigc__p_Pythia8__HMEHiggs2TwoFermions,
  _swigc__p_Pythia8__HMETau2FivePions,
  _swigc__p_Pythia8__HMETau2FourPions,
  _swigc__p_Pythia8__HMETau2Meson,
  _swigc__p_Pythia8__HMETau2PhaseSpace,
  _swigc__p_Pythia8__HMETau2ThreeMesons,
  _swigc__p_Pythia8__HMETau2ThreeMesonsGeneric,
  _swigc__p_Pythia8__HMETau2ThreeMesonsWithKaons,
  _swigc__p_Pythia8__HMETau2ThreePions,
  _swigc__p_Pythia8__HMETau2TwoLeptons,
  _swigc__p_Pythia8__HMETau2TwoMesonsViaVector,
  _swigc__p_Pythia8__HMETau2TwoMesonsViaVectorScalar,
  _swigc__p_Pythia8__HMETau2TwoPionsGamma,
  _swigc__p_Pythia8__HMETauDecay,
  _swigc__p_Pythia8__HMETwoFermions2GammaZ2TwoFermions,
  _swigc__p_Pythia8__HMETwoFermions2W2TwoFermions,
  _swigc__p_Pythia8__HMEW2TwoFermions,
  _swigc__p_Pythia8__HMEX2TwoFermions,
  _swigc__p_Pythia8__HMEZ2TwoFermions,
  _swigc__p_Pythia8__HVStringFlav,
  _swigc__p_Pythia8__HVStringPT,
  _swigc__p_Pythia8__HVStringZ,
  _swigc__p_Pythia8__HadronLevel,
  _swigc__p_Pythia8__HadronScatter,
  _swigc__p_Pythia8__HadronScatterPair,
  _swigc__p_Pythia8__HardDiffraction,
  _swigc__p_Pythia8__HardProcess,
  _swigc__p_Pythia8__HeavyIons,
  _swigc__p_Pythia8__HelicityMatrixElement,
  _swigc__p_Pythia8__HelicityParticle,
  _swigc__p_Pythia8__HiddenValleyFragmentation,
  _swigc__p_Pythia8__Hist,
  _swigc__p_Pythia8__HistPlot,
  _swigc__p_Pythia8__History,
  _swigc__p_Pythia8__ImpactParameterGenerator,
  _swigc__p_Pythia8__InBeam,
  _swigc__p_Pythia8__InPair,
  _swigc__p_Pythia8__Info,
  _swigc__p_Pythia8__Isospin,
  _swigc__p_Pythia8__JetMatching,
  _swigc__p_Pythia8__JetMatchingAlpgen,
  _swigc__p_Pythia8__JetMatchingAlpgenInputAlpgen,
  _swigc__p_Pythia8__JetMatchingMadgraph,
  _swigc__p_Pythia8__JetMatchingMadgraphInputAlpgen,
  _swigc__p_Pythia8__Junction,
  _swigc__p_Pythia8__JunctionSplitting,
  _swigc__p_Pythia8__LHAGrid1,
  _swigc__p_Pythia8__LHAPDF,
  _swigc__p_Pythia8__LHAParticle,
  _swigc__p_Pythia8__LHAProcess,
  _swigc__p_Pythia8__LHAgenerator,
  _swigc__p_Pythia8__LHAinitrwgt,
  _swigc__p_Pythia8__LHArwgt,
  _swigc__p_Pythia8__LHAscales,
  _swigc__p_Pythia8__LHAup,
  _swigc__p_Pythia8__LHAupAlpgen,
  _swigc__p_Pythia8__LHAupFromPYTHIA8,
  _swigc__p_Pythia8__LHAupHelaconia,
  _swigc__p_Pythia8__LHAupLHEF,
  _swigc__p_Pythia8__LHAupMadgraph,
  _swigc__p_Pythia8__LHAweight,
  _swigc__p_Pythia8__LHAweightgroup,
  _swigc__p_Pythia8__LHAweights,
  _swigc__p_Pythia8__LHAwgt,
  _swigc__p_Pythia8__LHEF3FromPythia8,
  _swigc__p_Pythia8__LHblockT_double_t,
  _swigc__p_Pythia8__LHblockT_int_t,
  _swigc__p_Pythia8__LHblockT_std__string_t,
  _swigc__p_Pythia8__LHdecayChannel,
  _swigc__p_Pythia8__LHdecayTable,
  _swigc__p_Pythia8__LHgenericBlock,
  _swigc__p_Pythia8__LHmatrixBlockT_2_t,
  _swigc__p_Pythia8__LHmatrixBlockT_3_t,
  _swigc__p_Pythia8__LHmatrixBlockT_4_t,
  _swigc__p_Pythia8__LHmatrixBlockT_5_t,
  _swigc__p_Pythia8__LHmatrixBlockT_6_t,
  _swigc__p_Pythia8__LHmatrixBlockT_7_t,
  _swigc__p_Pythia8__LHmatrixBlockT_8_t,
  _swigc__p_Pythia8__LHtensor3BlockT_3_t,
  _swigc__p_Pythia8__Lepton,
  _swigc__p_Pythia8__Lepton2gamma,
  _swigc__p_Pythia8__LeptonPoint,
  _swigc__p_Pythia8__LundFFAvg,
  _swigc__p_Pythia8__LundFFRaw,
  _swigc__p_Pythia8__MBReconUserHooks,
  _swigc__p_Pythia8__MSTWpdf,
  _swigc__p_Pythia8__MVec,
  _swigc__p_Pythia8__MadgraphPar,
  _swigc__p_Pythia8__Merging,
  _swigc__p_Pythia8__MergingHooks,
  _swigc__p_Pythia8__MiniStringFragmentation,
  _swigc__p_Pythia8__Mode,
  _swigc__p_Pythia8__MultiRadial,
  _swigc__p_Pythia8__MultipartonInteractions,
  _swigc__p_Pythia8__NNPDF,
  _swigc__p_Pythia8__NaiveSubCollisionModel,
  _swigc__p_Pythia8__NeutrinoPoint,
  _swigc__p_Pythia8__Nucleon,
  _swigc__p_Pythia8__NucleusModel,
  _swigc__p_Pythia8__OverlappingRopeDipole,
  _swigc__p_Pythia8__PDF,
  _swigc__p_Pythia8__PDF__PDFEnvelope,
  _swigc__p_Pythia8__PVec,
  _swigc__p_Pythia8__Parm,
  _swigc__p_Pythia8__Particle,
  _swigc__p_Pythia8__ParticleData,
  _swigc__p_Pythia8__ParticleDataEntry,
  _swigc__p_Pythia8__ParticleDecays,
  _swigc__p_Pythia8__PartonLevel,
  _swigc__p_Pythia8__PartonSystem,
  _swigc__p_Pythia8__PartonSystems,
  _swigc__p_Pythia8__PartonVertex,
  _swigc__p_Pythia8__PhaseSpace,
  _swigc__p_Pythia8__PhaseSpace2to1tauy,
  _swigc__p_Pythia8__PhaseSpace2to2diffractive,
  _swigc__p_Pythia8__PhaseSpace2to2elastic,
  _swigc__p_Pythia8__PhaseSpace2to2nondiffractive,
  _swigc__p_Pythia8__PhaseSpace2to2nondiffractiveGamma,
  _swigc__p_Pythia8__PhaseSpace2to2tauyz,
  _swigc__p_Pythia8__PhaseSpace2to3diffractive,
  _swigc__p_Pythia8__PhaseSpace2to3tauycyl,
  _swigc__p_Pythia8__PhaseSpace2to3yyycyl,
  _swigc__p_Pythia8__PhaseSpaceLHA,
  _swigc__p_Pythia8__PomFix,
  _swigc__p_Pythia8__PomH1FitAB,
  _swigc__p_Pythia8__PomH1Jets,
  _swigc__p_Pythia8__PomHISASD,
  _swigc__p_Pythia8__PowhegHooks,
  _swigc__p_Pythia8__PowhegProcs,
  _swigc__p_Pythia8__ProcessContainer,
  _swigc__p_Pythia8__ProcessLevel,
  _swigc__p_Pythia8__ProgressLog,
  _swigc__p_Pythia8__ProtonPoint,
  _swigc__p_Pythia8__Pythia,
  _swigc__p_Pythia8__RHadrons,
  _swigc__p_Pythia8__Reader,
  _swigc__p_Pythia8__ResolvedParton,
  _swigc__p_Pythia8__ResonanceChar,
  _swigc__p_Pythia8__ResonanceDecays,
  _swigc__p_Pythia8__ResonanceExcited,
  _swigc__p_Pythia8__ResonanceFour,
  _swigc__p_Pythia8__ResonanceGeneric,
  _swigc__p_Pythia8__ResonanceGluino,
  _swigc__p_Pythia8__ResonanceGmZ,
  _swigc__p_Pythia8__ResonanceGraviton,
  _swigc__p_Pythia8__ResonanceH,
  _swigc__p_Pythia8__ResonanceHchg,
  _swigc__p_Pythia8__ResonanceHchgchgLeft,
  _swigc__p_Pythia8__ResonanceHchgchgRight,
  _swigc__p_Pythia8__ResonanceKKgluon,
  _swigc__p_Pythia8__ResonanceLeptoquark,
  _swigc__p_Pythia8__ResonanceNeut,
  _swigc__p_Pythia8__ResonanceNuRight,
  _swigc__p_Pythia8__ResonanceRhorizontal,
  _swigc__p_Pythia8__ResonanceS,
  _swigc__p_Pythia8__ResonanceSlepton,
  _swigc__p_Pythia8__ResonanceSquark,
  _swigc__p_Pythia8__ResonanceTop,
  _swigc__p_Pythia8__ResonanceW,
  _swigc__p_Pythia8__ResonanceWRight,
  _swigc__p_Pythia8__ResonanceWidths,
  _swigc__p_Pythia8__ResonanceWprime,
  _swigc__p_Pythia8__ResonanceZRight,
  _swigc__p_Pythia8__ResonanceZp,
  _swigc__p_Pythia8__ResonanceZprime,
  _swigc__p_Pythia8__Rndm,
  _swigc__p_Pythia8__RndmEngine,
  _swigc__p_Pythia8__RopeDipole,
  _swigc__p_Pythia8__RopeDipoleEnd,
  _swigc__p_Pythia8__RopeFragPars,
  _swigc__p_Pythia8__Ropewalk,
  _swigc__p_Pythia8__RotBstMatrix,
  _swigc__p_Pythia8__SLHAinterface,
  _swigc__p_Pythia8__SUSYResonanceWidths,
  _swigc__p_Pythia8__Settings,
  _swigc__p_Pythia8__SetupContainers,
  _swigc__p_Pythia8__Sigma0AB2AB,
  _swigc__p_Pythia8__Sigma0AB2AX,
  _swigc__p_Pythia8__Sigma0AB2AXB,
  _swigc__p_Pythia8__Sigma0AB2XB,
  _swigc__p_Pythia8__Sigma0AB2XX,
  _swigc__p_Pythia8__Sigma0Process,
  _swigc__p_Pythia8__Sigma0nonDiffractive,
  _swigc__p_Pythia8__Sigma1Process,
  _swigc__p_Pythia8__Sigma1ffbar2GravitonStar,
  _swigc__p_Pythia8__Sigma1ffbar2H,
  _swigc__p_Pythia8__Sigma1ffbar2Hchg,
  _swigc__p_Pythia8__Sigma1ffbar2Rhorizontal,
  _swigc__p_Pythia8__Sigma1ffbar2W,
  _swigc__p_Pythia8__Sigma1ffbar2WRight,
  _swigc__p_Pythia8__Sigma1ffbar2Wprime,
  _swigc__p_Pythia8__Sigma1ffbar2ZRight,
  _swigc__p_Pythia8__Sigma1ffbar2Zp2XX,
  _swigc__p_Pythia8__Sigma1ffbar2Zv,
  _swigc__p_Pythia8__Sigma1ffbar2gmZ,
  _swigc__p_Pythia8__Sigma1ffbar2gmZZprime,
  _swigc__p_Pythia8__Sigma1ffbarZprimeWprime,
  _swigc__p_Pythia8__Sigma1gg2GravitonStar,
  _swigc__p_Pythia8__Sigma1gg2H,
  _swigc__p_Pythia8__Sigma1gg2S2XX,
  _swigc__p_Pythia8__Sigma1gmgm2H,
  _swigc__p_Pythia8__Sigma1lgm2lStar,
  _swigc__p_Pythia8__Sigma1ll2Hchgchg,
  _swigc__p_Pythia8__Sigma1qg2qStar,
  _swigc__p_Pythia8__Sigma1ql2LeptoQuark,
  _swigc__p_Pythia8__Sigma1qq2antisquark,
  _swigc__p_Pythia8__Sigma1qqbar2KKgluonStar,
  _swigc__p_Pythia8__Sigma2Process,
  _swigc__p_Pythia8__Sigma2QCffbar2llbar,
  _swigc__p_Pythia8__Sigma2QCqq2qq,
  _swigc__p_Pythia8__Sigma2QCqqbar2qqbar,
  _swigc__p_Pythia8__Sigma2SUSY,
  _swigc__p_Pythia8__Sigma2ff2fftW,
  _swigc__p_Pythia8__Sigma2ff2fftgmZ,
  _swigc__p_Pythia8__Sigma2ffbar2A3H12,
  _swigc__p_Pythia8__Sigma2ffbar2FFbarsgmZ,
  _swigc__p_Pythia8__Sigma2ffbar2FfbarsW,
  _swigc__p_Pythia8__Sigma2ffbar2HW,
  _swigc__p_Pythia8__Sigma2ffbar2HZ,
  _swigc__p_Pythia8__Sigma2ffbar2HchgH12,
  _swigc__p_Pythia8__Sigma2ffbar2HchgchgHchgchg,
  _swigc__p_Pythia8__Sigma2ffbar2HposHneg,
  _swigc__p_Pythia8__Sigma2ffbar2LEDUnparticleZ,
  _swigc__p_Pythia8__Sigma2ffbar2LEDUnparticlegamma,
  _swigc__p_Pythia8__Sigma2ffbar2LEDgammagamma,
  _swigc__p_Pythia8__Sigma2ffbar2LEDllbar,
  _swigc__p_Pythia8__Sigma2ffbar2TEVffbar,
  _swigc__p_Pythia8__Sigma2ffbar2WW,
  _swigc__p_Pythia8__Sigma2ffbar2Wgm,
  _swigc__p_Pythia8__Sigma2ffbar2ZW,
  _swigc__p_Pythia8__Sigma2ffbar2ZpH,
  _swigc__p_Pythia8__Sigma2ffbar2fGfGbar,
  _swigc__p_Pythia8__Sigma2ffbar2ffbarsW,
  _swigc__p_Pythia8__Sigma2ffbar2ffbarsgm,
  _swigc__p_Pythia8__Sigma2ffbar2ffbarsgmZ,
  _swigc__p_Pythia8__Sigma2ffbar2gammagamma,
  _swigc__p_Pythia8__Sigma2ffbar2gmZgm,
  _swigc__p_Pythia8__Sigma2ffbar2gmZgmZ,
  _swigc__p_Pythia8__Sigma2ffbarWggm,
  _swigc__p_Pythia8__Sigma2ffbargmZWgmZW,
  _swigc__p_Pythia8__Sigma2ffbargmZggm,
  _swigc__p_Pythia8__Sigma2fgm2Wf,
  _swigc__p_Pythia8__Sigma2fgm2gmZf,
  _swigc__p_Pythia8__Sigma2gg2GravitonStarg,
  _swigc__p_Pythia8__Sigma2gg2Hglt,
  _swigc__p_Pythia8__Sigma2gg2LEDUnparticleg,
  _swigc__p_Pythia8__Sigma2gg2LEDgammagamma,
  _swigc__p_Pythia8__Sigma2gg2LEDgg,
  _swigc__p_Pythia8__Sigma2gg2LEDllbar,
  _swigc__p_Pythia8__Sigma2gg2LEDqqbar,
  _swigc__p_Pythia8__Sigma2gg2LQLQbar,
  _swigc__p_Pythia8__Sigma2gg2QQbar,
  _swigc__p_Pythia8__Sigma2gg2QQbar3DJ1g,
  _swigc__p_Pythia8__Sigma2gg2QQbar3PJ1g,
  _swigc__p_Pythia8__Sigma2gg2QQbar3S11QQbar3S11,
  _swigc__p_Pythia8__Sigma2gg2QQbar3S11g,
  _swigc__p_Pythia8__Sigma2gg2QQbar3S11gm,
  _swigc__p_Pythia8__Sigma2gg2QQbarX8g,
  _swigc__p_Pythia8__Sigma2gg2Sg2XXj,
  _swigc__p_Pythia8__Sigma2gg2gammagamma,
  _swigc__p_Pythia8__Sigma2gg2gg,
  _swigc__p_Pythia8__Sigma2gg2ggamma,
  _swigc__p_Pythia8__Sigma2gg2gluinogluino,
  _swigc__p_Pythia8__Sigma2gg2qGqGbar,
  _swigc__p_Pythia8__Sigma2gg2qqbar,
  _swigc__p_Pythia8__Sigma2gg2squarkantisquark,
  _swigc__p_Pythia8__Sigma2ggm2qqbar,
  _swigc__p_Pythia8__Sigma2gmgm2ffbar,
  _swigc__p_Pythia8__Sigma2lgm2Hchgchgl,
  _swigc__p_Pythia8__Sigma2qg2GravitonStarq,
  _swigc__p_Pythia8__Sigma2qg2Hchgq,
  _swigc__p_Pythia8__Sigma2qg2Hq,
  _swigc__p_Pythia8__Sigma2qg2Hqlt,
  _swigc__p_Pythia8__Sigma2qg2LEDUnparticleq,
  _swigc__p_Pythia8__Sigma2qg2LEDqg,
  _swigc__p_Pythia8__Sigma2qg2LeptoQuarkl,
  _swigc__p_Pythia8__Sigma2qg2QQbar3PJ1q,
  _swigc__p_Pythia8__Sigma2qg2QQbarX8q,
  _swigc__p_Pythia8__Sigma2qg2Sq2XXj,
  _swigc__p_Pythia8__Sigma2qg2Wq,
  _swigc__p_Pythia8__Sigma2qg2Zpq2XXj,
  _swigc__p_Pythia8__Sigma2qg2charsquark,
  _swigc__p_Pythia8__Sigma2qg2chi0squark,
  _swigc__p_Pythia8__Sigma2qg2gmZq,
  _swigc__p_Pythia8__Sigma2qg2qg,
  _swigc__p_Pythia8__Sigma2qg2qgamma,
  _swigc__p_Pythia8__Sigma2qg2squarkgluino,
  _swigc__p_Pythia8__Sigma2qgm2qg,
  _swigc__p_Pythia8__Sigma2qgm2qgm,
  _swigc__p_Pythia8__Sigma2qq2LEDqq,
  _swigc__p_Pythia8__Sigma2qq2QqtW,
  _swigc__p_Pythia8__Sigma2qq2qStarq,
  _swigc__p_Pythia8__Sigma2qq2qq,
  _swigc__p_Pythia8__Sigma2qq2squarksquark,
  _swigc__p_Pythia8__Sigma2qqbar2GravitonStarg,
  _swigc__p_Pythia8__Sigma2qqbar2Hglt,
  _swigc__p_Pythia8__Sigma2qqbar2LEDUnparticleg,
  _swigc__p_Pythia8__Sigma2qqbar2LEDgg,
  _swigc__p_Pythia8__Sigma2qqbar2LEDqqbarNew,
  _swigc__p_Pythia8__Sigma2qqbar2LQLQbar,
  _swigc__p_Pythia8__Sigma2qqbar2QQbar,
  _swigc__p_Pythia8__Sigma2qqbar2QQbar3PJ1g,
  _swigc__p_Pythia8__Sigma2qqbar2QQbar3S11QQbar3S11,
  _swigc__p_Pythia8__Sigma2qqbar2QQbarX8g,
  _swigc__p_Pythia8__Sigma2qqbar2Wg,
  _swigc__p_Pythia8__Sigma2qqbar2Zpg2XXj,
  _swigc__p_Pythia8__Sigma2qqbar2charchar,
  _swigc__p_Pythia8__Sigma2qqbar2charchi0,
  _swigc__p_Pythia8__Sigma2qqbar2chargluino,
  _swigc__p_Pythia8__Sigma2qqbar2chi0chi0,
  _swigc__p_Pythia8__Sigma2qqbar2chi0gluino,
  _swigc__p_Pythia8__Sigma2qqbar2gg,
  _swigc__p_Pythia8__Sigma2qqbar2ggamma,
  _swigc__p_Pythia8__Sigma2qqbar2gluinogluino,
  _swigc__p_Pythia8__Sigma2qqbar2gmZg,
  _swigc__p_Pythia8__Sigma2qqbar2lStarlStarBar,
  _swigc__p_Pythia8__Sigma2qqbar2lStarlbar,
  _swigc__p_Pythia8__Sigma2qqbar2qGqGbar,
  _swigc__p_Pythia8__Sigma2qqbar2qqbarNew,
  _swigc__p_Pythia8__Sigma2qqbar2sleptonantislepton,
  _swigc__p_Pythia8__Sigma2qqbar2squarkantisquark,
  _swigc__p_Pythia8__Sigma3Process,
  _swigc__p_Pythia8__Sigma3ff2HchgchgfftWW,
  _swigc__p_Pythia8__Sigma3ff2HfftWW,
  _swigc__p_Pythia8__Sigma3ff2HfftZZ,
  _swigc__p_Pythia8__Sigma3gg2HQQbar,
  _swigc__p_Pythia8__Sigma3gg2ggg,
  _swigc__p_Pythia8__Sigma3gg2qqbarg,
  _swigc__p_Pythia8__Sigma3qg2qgg,
  _swigc__p_Pythia8__Sigma3qg2qqqbarDiff,
  _swigc__p_Pythia8__Sigma3qg2qqqbarSame,
  _swigc__p_Pythia8__Sigma3qq2qqgDiff,
  _swigc__p_Pythia8__Sigma3qq2qqgSame,
  _swigc__p_Pythia8__Sigma3qqbar2HQQbar,
  _swigc__p_Pythia8__Sigma3qqbar2ggg,
  _swigc__p_Pythia8__Sigma3qqbar2qqbargDiff,
  _swigc__p_Pythia8__Sigma3qqbar2qqbargSame,
  _swigc__p_Pythia8__SigmaABMST,
  _swigc__p_Pythia8__SigmaLHAProcess,
  _swigc__p_Pythia8__SigmaMBR,
  _swigc__p_Pythia8__SigmaMultiparton,
  _swigc__p_Pythia8__SigmaOniaSetup,
  _swigc__p_Pythia8__SigmaPartialWave,
  _swigc__p_Pythia8__SigmaProcess,
  _swigc__p_Pythia8__SigmaRPP,
  _swigc__p_Pythia8__SigmaSaSDL,
  _swigc__p_Pythia8__SigmaTotAux,
  _swigc__p_Pythia8__SigmaTotOwn,
  _swigc__p_Pythia8__SigmaTotal,
  _swigc__p_Pythia8__SingleCell,
  _swigc__p_Pythia8__SingleCellJet,
  _swigc__p_Pythia8__SingleClusterJet,
  _swigc__p_Pythia8__SingleSlowJet,
  _swigc__p_Pythia8__SlowJet,
  _swigc__p_Pythia8__SlowJetHook,
  _swigc__p_Pythia8__SpaceDipoleEnd,
  _swigc__p_Pythia8__SpaceShower,
  _swigc__p_Pythia8__Sphericity,
  _swigc__p_Pythia8__StauWidths,
  _swigc__p_Pythia8__StringEnd,
  _swigc__p_Pythia8__StringFlav,
  _swigc__p_Pythia8__StringFragmentation,
  _swigc__p_Pythia8__StringLength,
  _swigc__p_Pythia8__StringPT,
  _swigc__p_Pythia8__StringRegion,
  _swigc__p_Pythia8__StringSystem,
  _swigc__p_Pythia8__StringVertex,
  _swigc__p_Pythia8__StringZ,
  _swigc__p_Pythia8__SubCollision,
  _swigc__p_Pythia8__SubCollisionModel,
  _swigc__p_Pythia8__SubCollisionModel__SigEst,
  _swigc__p_Pythia8__SuppressSmallPT,
  _swigc__p_Pythia8__SusyLesHouches,
  _swigc__p_Pythia8__TauDecays,
  _swigc__p_Pythia8__Thrust,
  _swigc__p_Pythia8__TimeDipoleEnd,
  _swigc__p_Pythia8__TimeShower,
  _swigc__p_Pythia8__TopReconUserHooks,
  _swigc__p_Pythia8__TrialReconnection,
  _swigc__p_Pythia8__UserHooks,
  _swigc__p_Pythia8__UserHooksVector,
  _swigc__p_Pythia8__Vec4,
  _swigc__p_Pythia8__WVec,
  _swigc__p_Pythia8__Wave4,
  _swigc__p_Pythia8__WeakShowerMEs,
  _swigc__p_Pythia8__WidthFunction,
  _swigc__p_Pythia8__WoodsSaxonModel,
  _swigc__p_Pythia8__Word,
  _swigc__p_Pythia8__Writer,
  _swigc__p_Pythia8__XMLTag,
  _swigc__p_Pythia8__amcnlo_unitarised_interface,
  _swigc__p_Pythia8__nPDF,
  _swigc__p_State,
  _swigc__p_a_3__std__complexT_double_t,
  _swigc__p_a_4__std__complexT_double_t,
  _swigc__p_a_6__std__complexT_double_t,
  _swigc__p_a_7__std__complexT_double_t,
  _swigc__p_a_8__double,
  _swigc__p_allocator_type,
  _swigc__p_basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  _swigc__p_bool,
  _swigc__p_char,
  _swigc__p_char_type,
  _swigc__p_const_reference,
  _swigc__p_difference_type,
  _swigc__p_double,
  _swigc__p_f_enum_std__ios_base__event_r_std__ios_base_int__void,
  _swigc__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iosT_char_std__char_traitsT_char_t_t,
  _swigc__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t,
  _swigc__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t,
  _swigc__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  _swigc__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t,
  _swigc__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  _swigc__p_f_r_std__basic_ios__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  _swigc__p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t,
  _swigc__p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istreamT_char_std__char_traitsT_char_t_t,
  _swigc__p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  _swigc__p_f_r_std__basic_istream__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  _swigc__p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_iostreamT_char_std__char_traitsT_char_t_t,
  _swigc__p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t,
  _swigc__p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  _swigc__p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  _swigc__p_f_r_std__ios_base__r_std__basic_iosT_char_std__char_traitsT_char_t_t,
  _swigc__p_f_r_std__ios_base__r_std__basic_iostreamT_char_std__char_traitsT_char_t_t,
  _swigc__p_f_r_std__ios_base__r_std__basic_istreamT_char_std__char_traitsT_char_t_t,
  _swigc__p_f_r_std__ios_base__r_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  _swigc__p_f_r_std__ios_base__r_std__basic_ostreamT_char_std__char_traitsT_char_t_t,
  _swigc__p_f_r_std__ios_base__r_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  _swigc__p_f_r_std__ios_base__r_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  _swigc__p_f_r_std__ios_base__r_std__ios_base,
  _swigc__p_first_type,
  _swigc__p_float,
  _swigc__p_fmtflags,
  _swigc__p_ifstream,
  _swigc__p_int,
  _swigc__p_int_type,
  _swigc__p_iostate,
  _swigc__p_key_type,
  _swigc__p_long,
  _swigc__p_long_double,
  _swigc__p_long_long,
  _swigc__p_mapped_type,
  _swigc__p_off_type,
  _swigc__p_openmode,
  _swigc__p_p_PyObject,
  _swigc__p_p_Pythia8__ColourDipole,
  _swigc__p_p_std__basic_iostreamT_char_std__char_traitsT_char_t_t,
  _swigc__p_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,
  _swigc__p_p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  _swigc__p_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  _swigc__p_p_void,
  _swigc__p_pos_t,
  _swigc__p_pos_type,
  _swigc__p_reference,
  _swigc__p_second_type,
  _swigc__p_seekdir,
  _swigc__p_short,
  _swigc__p_size_t,
  _swigc__p_size_type,
  _swigc__p_state_type,
  _swigc__p_std__allocatorT_Pythia8__Clustering_t,
  _swigc__p_std__allocatorT_Pythia8__HelicityParticle_t,
  _swigc__p_std__allocatorT_Pythia8__ProcessContainer_p_t,
  _swigc__p_std__allocatorT_Pythia8__ResonanceWidths_p_t,
  _swigc__p_std__allocatorT_Pythia8__SigmaProcess_p_t,
  _swigc__p_std__allocatorT_Pythia8__Vec4_t,
  _swigc__p_std__allocatorT_bool_t,
  _swigc__p_std__allocatorT_double_t,
  _swigc__p_std__allocatorT_int_t,
  _swigc__p_std__allocatorT_std__complexT_double_t_t,
  _swigc__p_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t,
  _swigc__p_std__allocatorT_std__pairT_int_const_int_t_t,
  _swigc__p_std__allocatorT_std__pairT_int_int_t_t,
  _swigc__p_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t,
  _swigc__p_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t,
  _swigc__p_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t,
  _swigc__p_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t,
  _swigc__p_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t,
  _swigc__p_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t,
  _swigc__p_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t,
  _swigc__p_std__allocatorT_std__pairT_std__string_const_std__string_t_t,
  _swigc__p_std__allocatorT_std__string_t,
  _swigc__p_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t,
  _swigc__p_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t,
  _swigc__p_std__basic_iosT_char_std__char_traitsT_char_t_t,
  _swigc__p_std__basic_iostreamT_char_std__char_traitsT_char_t_t,
  _swigc__p_std__basic_istreamT_char_std__char_traitsT_char_t_t,
  _swigc__p_std__basic_istringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  _swigc__p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,
  _swigc__p_std__basic_ostringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  _swigc__p_std__basic_streambufT_char_std__char_traitsT_char_t_t,
  _swigc__p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  _swigc__p_std__basic_stringbufT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  _swigc__p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  _swigc__p_std__complexT_double_t,
  _swigc__p_std__ifstream,
  _swigc__p_std__invalid_argument,
  _swigc__p_std__ios_base,
  _swigc__p_std__lessT_double_t,
  _swigc__p_std__lessT_int_t,
  _swigc__p_std__lessT_std__string_t,
  _swigc__p_std__locale,
  _swigc__p_std__mapT_Pythia8__Nucleon_p_std__pairT_int_int_t_std__lessT_Pythia8__Nucleon_p_t_std__allocatorT_std__pairT_Pythia8__Nucleon_pconst_std__pairT_int_int_t_t_t_t,
  _swigc__p_std__mapT_double_std__pairT_int_int_t_std__lessT_double_t_std__allocatorT_std__pairT_double_const_std__pairT_int_int_t_t_t_t,
  _swigc__p_std__mapT_int_double_std__lessT_int_t_std__allocatorT_std__pairT_int_const_double_t_t_t,
  _swigc__p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t,
  _swigc__p_std__mapT_std__string_Pythia8__FVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__FVec_t_t_t,
  _swigc__p_std__mapT_std__string_Pythia8__Flag_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Flag_t_t_t,
  _swigc__p_std__mapT_std__string_Pythia8__LHAweight_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweight_t_t_t,
  _swigc__p_std__mapT_std__string_Pythia8__LHAweightgroup_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAweightgroup_t_t_t,
  _swigc__p_std__mapT_std__string_Pythia8__LHAwgt_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHAwgt_t_t_t,
  _swigc__p_std__mapT_std__string_Pythia8__LHgenericBlock_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__LHgenericBlock_t_t_t,
  _swigc__p_std__mapT_std__string_Pythia8__MVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__MVec_t_t_t,
  _swigc__p_std__mapT_std__string_Pythia8__Mode_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Mode_t_t_t,
  _swigc__p_std__mapT_std__string_Pythia8__PVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__PVec_t_t_t,
  _swigc__p_std__mapT_std__string_Pythia8__Parm_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Parm_t_t_t,
  _swigc__p_std__mapT_std__string_Pythia8__WVec_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__WVec_t_t_t,
  _swigc__p_std__mapT_std__string_Pythia8__Word_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_Pythia8__Word_t_t_t,
  _swigc__p_std__mapT_std__string_double_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_double_t_t_t,
  _swigc__p_std__mapT_std__string_std__string_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_std__string_t_t_t,
  _swigc__p_std__multisetT_Pythia8__SubCollision_std__lessT_Pythia8__SubCollision_t_std__allocatorT_Pythia8__SubCollision_t_t,
  _swigc__p_std__ofstream,
  _swigc__p_std__pairT_Pythia8__RotBstMatrix_Pythia8__RotBstMatrix_t,
  _swigc__p_std__pairT_Pythia8__Vec4_Pythia8__Vec4_t,
  _swigc__p_std__pairT_double_double_t,
  _swigc__p_std__pairT_int_int_t,
  _swigc__p_std__pairT_long_long_t,
  _swigc__p_std__setT_int_std__lessT_int_t_std__allocatorT_int_t_t,
  _swigc__p_std__string,
  _swigc__p_std__string__size_type,
  _swigc__p_std__vectorT_Pythia8__Clustering_std__allocatorT_Pythia8__Clustering_t_t,
  _swigc__p_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t,
  _swigc__p_std__vectorT_Pythia8__HelicityParticle_std__allocatorT_Pythia8__HelicityParticle_t_t,
  _swigc__p_std__vectorT_Pythia8__InBeam_std__allocatorT_Pythia8__InBeam_t_t,
  _swigc__p_std__vectorT_Pythia8__InPair_std__allocatorT_Pythia8__InPair_t_t,
  _swigc__p_std__vectorT_Pythia8__LHAParticle_std__allocatorT_Pythia8__LHAParticle_t_t,
  _swigc__p_std__vectorT_Pythia8__LHAgenerator_std__allocatorT_Pythia8__LHAgenerator_t_t,
  _swigc__p_std__vectorT_Pythia8__LHblockT_int_t_std__allocatorT_Pythia8__LHblockT_int_t_t_t,
  _swigc__p_std__vectorT_Pythia8__LHdecayTable_std__allocatorT_Pythia8__LHdecayTable_t_t,
  _swigc__p_std__vectorT_Pythia8__Nucleon_std__allocatorT_Pythia8__Nucleon_t_t,
  _swigc__p_std__vectorT_Pythia8__PhaseSpace_p_std__allocatorT_Pythia8__PhaseSpace_p_t_t,
  _swigc__p_std__vectorT_Pythia8__ProcessContainer_p_std__allocatorT_Pythia8__ProcessContainer_p_t_t,
  _swigc__p_std__vectorT_Pythia8__ResonanceWidths_p_std__allocatorT_Pythia8__ResonanceWidths_p_t_t,
  _swigc__p_std__vectorT_Pythia8__SigmaProcess_p_std__allocatorT_Pythia8__SigmaProcess_p_t_t,
  _swigc__p_std__vectorT_Pythia8__StringRegion_std__allocatorT_Pythia8__StringRegion_t_t,
  _swigc__p_std__vectorT_Pythia8__StringVertex_std__allocatorT_Pythia8__StringVertex_t_t,
  _swigc__p_std__vectorT_Pythia8__UserHooks_p_std__allocatorT_Pythia8__UserHooks_p_t_t,
  _swigc__p_std__vectorT_Pythia8__Vec4_std__allocatorT_Pythia8__Vec4_t_t,
  _swigc__p_std__vectorT_Pythia8__XMLTag_p_std__allocatorT_Pythia8__XMLTag_p_t_t,
  _swigc__p_std__vectorT_bool_std__allocatorT_bool_t_t,
  _swigc__p_std__vectorT_double_std__allocatorT_double_t_t,
  _swigc__p_std__vectorT_int_std__allocatorT_int_t_t,
  _swigc__p_std__vectorT_long_std__allocatorT_long_t_t,
  _swigc__p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t,
  _swigc__p_std__vectorT_std__pairT_int_int_t_std__allocatorT_std__pairT_int_int_t_t_t,
  _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
  _swigc__p_std__vectorT_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t_std__allocatorT_std__vectorT_Pythia8__ColourDipole_p_std__allocatorT_Pythia8__ColourDipole_p_t_t_t_t,
  _swigc__p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,
  _swigc__p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t,
  _swigc__p_std__vectorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_std__allocatorT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t_t,
  _swigc__p_std__vectorT_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t_std__allocatorT_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t_t_t,
  _swigc__p_streamoff,
  _swigc__p_streampos,
  _swigc__p_stringstream,
  _swigc__p_swig__SwigPyIterator,
  _swigc__p_traits_type,
  _swigc__p_unsigned_int,
  _swigc__p_unsigned_long,
  _swigc__p_unsigned_long_long,
  _swigc__p_unsigned_short,
  _swigc__p_value_type,
};


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

static swig_const_info swig_const_table[] = {
{ SWIG_PY_POINTER, (char*)"endl_cb_ptr", 0, 0, (void *)((std::basic_ostream< char,std::char_traits< char > > & (*)(std::basic_ostream< char,std::char_traits< char > > &))(std::endl< char,std::char_traits< char > >)), &SWIGTYPE_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t },
{ SWIG_PY_POINTER, (char*)"ends_cb_ptr", 0, 0, (void *)((std::basic_ostream< char,std::char_traits< char > > & (*)(std::basic_ostream< char,std::char_traits< char > > &))(std::ends< char,std::char_traits< char > >)), &SWIGTYPE_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t },
{ SWIG_PY_POINTER, (char*)"flush_cb_ptr", 0, 0, (void *)((std::basic_ostream< char,std::char_traits< char > > & (*)(std::basic_ostream< char,std::char_traits< char > > &))(std::flush< char,std::char_traits< char > >)), &SWIGTYPE_p_f_r_std__basic_ostream__char_std__char_traits__char______r_std__basic_ostreamT_char_std__char_traitsT_char_t_t },
{0, 0, 0, 0.0, 0, 0}};

#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
 * Type initialization:
 * This problem is tough by the requirement that no dynamic
 * memory is used. Also, since swig_type_info structures store pointers to
 * swig_cast_info structures and swig_cast_info structures store pointers back
 * to swig_type_info structures, we need some lookup code at initialization.
 * The idea is that swig generates all the structures that are needed.
 * The runtime then collects these partially filled structures.
 * The SWIG_InitializeModule function takes these initial arrays out of
 * swig_module, and does all the lookup, filling in the swig_module.types
 * array with the correct data and linking the correct swig_cast_info
 * structures together.
 *
 * The generated swig_type_info structures are assigned statically to an initial
 * array. We just loop through that array, and handle each type individually.
 * First we lookup if this type has been already loaded, and if so, use the
 * loaded structure instead of the generated one. Then we have to fill in the
 * cast linked list. The cast data is initially stored in something like a
 * two-dimensional array. Each row corresponds to a type (there are the same
 * number of rows as there are in the swig_type_initial array). Each entry in
 * a column is one of the swig_cast_info structures for that type.
 * The cast_initial array is actually an array of arrays, because each row has
 * a variable number of columns. So to actually build the cast linked list,
 * we find the array of casts associated with the type, and loop through it
 * adding the casts to the list. The one last trick we need to do is making
 * sure the type pointer in the swig_cast_info struct is correct.
 *
 * First off, we lookup the cast->type name to see if it is already loaded.
 * There are three cases to handle:
 *  1) If the cast->type has already been loaded AND the type we are adding
 *     casting info to has not been loaded (it is in this module), THEN we
 *     replace the cast->type pointer with the type pointer that has already
 *     been loaded.
 *  2) If BOTH types (the one we are adding casting info to, and the
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 *     the previous module so we just ignore it.
 *  3) Finally, if cast->type has not already been loaded, then we add that
 *     swig_cast_info to the linked list (because the cast->type) pointer will
 *     be correct.
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif

#if 0
#define SWIGRUNTIME_DEBUG
#endif


SWIGRUNTIME void
SWIG_InitializeModule(void *clientdata) {
  size_t i;
  swig_module_info *module_head, *iter;
  int init;
  
  /* check to see if the circular list has been setup, if not, set it up */
  if (swig_module.next==0) {
    /* Initialize the swig_module */
    swig_module.type_initial = swig_type_initial;
    swig_module.cast_initial = swig_cast_initial;
    swig_module.next = &swig_module;
    init = 1;
  } else {
    init = 0;
  }
  
  /* Try and load any already created modules */
  module_head = SWIG_GetModule(clientdata);
  if (!module_head) {
    /* This is the first module loaded for this interpreter */
    /* so set the swig module into the interpreter */
    SWIG_SetModule(clientdata, &swig_module);
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    iter=module_head;
    do {
      if (iter==&swig_module) {
        /* Our module is already in the list, so there's nothing more to do. */
        return;
      }
      iter=iter->next;
    } while (iter!= module_head);
    
    /* otherwise we must add our module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }
  
  /* When multiple interpreters are used, a module could have already been initialized in
       a different interpreter, but not yet have a pointer in this interpreter.
       In this case, we do not want to continue adding types... everything should be
       set up already */
  if (init == 0) return;
  
  /* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
#endif
  for (i = 0; i < swig_module.size; ++i) {
    swig_type_info *type = 0;
    swig_type_info *ret;
    swig_cast_info *cast;
    
#ifdef SWIGRUNTIME_DEBUG
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
#endif
    
    /* if there is another module already loaded */
    if (swig_module.next != &swig_module) {
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
    }
    if (type) {
      /* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
      if (swig_module.type_initial[i]->clientdata) {
        type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
      }
    } else {
      type = swig_module.type_initial[i];
    }
    
    /* Insert casting types */
    cast = swig_module.cast_initial[i];
    while (cast->type) {
      /* Don't need to add information already in the list */
      ret = 0;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
      if (swig_module.next != &swig_module) {
        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
        if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
      }
      if (ret) {
        if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
          printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
          cast->type = ret;
          ret = 0;
        } else {
          /* Check for casting already in the list */
          swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
          if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
          if (!ocast) ret = 0;
        }
      }
      
      if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
        if (type->cast) {
          type->cast->prev = cast;
          cast->next = type->cast;
        }
        type->cast = cast;
      }
      cast++;
    }
    /* Set entry in modules->types array equal to the type */
    swig_module.types[i] = type;
  }
  swig_module.types[i] = 0;
  
#ifdef SWIGRUNTIME_DEBUG
  printf("**** SWIG_InitializeModule: Cast List ******\n");
  for (i = 0; i < swig_module.size; ++i) {
    int j = 0;
    swig_cast_info *cast = swig_module.cast_initial[i];
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
    while (cast->type) {
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
      cast++;
      ++j;
    }
    printf("---- Total casts: %d\n",j);
  }
  printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}

/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types.  It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
  size_t i;
  swig_cast_info *equiv;
  static int init_run = 0;
  
  if (init_run) return;
  init_run = 1;
  
  for (i = 0; i < swig_module.size; i++) {
    if (swig_module.types[i]->clientdata) {
      equiv = swig_module.types[i]->cast;
      while (equiv) {
        if (!equiv->converter) {
          if (equiv->type && !equiv->type->clientdata)
          SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
        }
        equiv = equiv->next;
      }
    }
  }
}

#ifdef __cplusplus
#if 0
{
  /* c-mode */
#endif
}
#endif



#ifdef __cplusplus
extern "C" {
#endif
  
  /* Python-specific SWIG API */
#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
  
  /* -----------------------------------------------------------------------------
   * global variable support code.
   * ----------------------------------------------------------------------------- */
  
  typedef struct swig_globalvar {
    char       *name;                  /* Name of global variable */
    PyObject *(*get_attr)(void);       /* Return the current value */
    int       (*set_attr)(PyObject *); /* Set the value */
    struct swig_globalvar *next;
  } swig_globalvar;
  
  typedef struct swig_varlinkobject {
    PyObject_HEAD
    swig_globalvar *vars;
  } swig_varlinkobject;
  
  SWIGINTERN PyObject *
  swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
#if PY_VERSION_HEX >= 0x03000000
    return PyUnicode_InternFromString("<Swig global variables>");
#else
    return PyString_FromString("<Swig global variables>");
#endif
  }
  
  SWIGINTERN PyObject *
  swig_varlink_str(swig_varlinkobject *v) {
#if PY_VERSION_HEX >= 0x03000000
    PyObject *str = PyUnicode_InternFromString("(");
    PyObject *tail;
    PyObject *joined;
    swig_globalvar *var;
    for (var = v->vars; var; var=var->next) {
      tail = PyUnicode_FromString(var->name);
      joined = PyUnicode_Concat(str, tail);
      Py_DecRef(str);
      Py_DecRef(tail);
      str = joined;
      if (var->next) {
        tail = PyUnicode_InternFromString(", ");
        joined = PyUnicode_Concat(str, tail);
        Py_DecRef(str);
        Py_DecRef(tail);
        str = joined;
      }
    }
    tail = PyUnicode_InternFromString(")");
    joined = PyUnicode_Concat(str, tail);
    Py_DecRef(str);
    Py_DecRef(tail);
    str = joined;
#else
    PyObject *str = PyString_FromString("(");
    swig_globalvar *var;
    for (var = v->vars; var; var=var->next) {
      PyString_ConcatAndDel(&str,PyString_FromString(var->name));
      if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
    }
    PyString_ConcatAndDel(&str,PyString_FromString(")"));
#endif
    return str;
  }
  
  SWIGINTERN int
  swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
    char *tmp;
    PyObject *str = swig_varlink_str(v);
    fprintf(fp,"Swig global variables ");
    fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
    SWIG_Python_str_DelForPy3(tmp);
    Py_DECREF(str);
    return 0;
  }
  
  SWIGINTERN void
  swig_varlink_dealloc(swig_varlinkobject *v) {
    swig_globalvar *var = v->vars;
    while (var) {
      swig_globalvar *n = var->next;
      free(var->name);
      free(var);
      var = n;
    }
  }
  
  SWIGINTERN PyObject *
  swig_varlink_getattr(swig_varlinkobject *v, char *n) {
    PyObject *res = NULL;
    swig_globalvar *var = v->vars;
    while (var) {
      if (strcmp(var->name,n) == 0) {
        res = (*var->get_attr)();
        break;
      }
      var = var->next;
    }
    if (res == NULL && !PyErr_Occurred()) {
      PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
    }
    return res;
  }
  
  SWIGINTERN int
  swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
    int res = 1;
    swig_globalvar *var = v->vars;
    while (var) {
      if (strcmp(var->name,n) == 0) {
        res = (*var->set_attr)(p);
        break;
      }
      var = var->next;
    }
    if (res == 1 && !PyErr_Occurred()) {
      PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
    }
    return res;
  }
  
  SWIGINTERN PyTypeObject*
  swig_varlink_type(void) {
    static char varlink__doc__[] = "Swig var link object";
    static PyTypeObject varlink_type;
    static int type_init = 0;
    if (!type_init) {
      const PyTypeObject tmp = {
        /* PyObject header changed in Python 3 */
#if PY_VERSION_HEX >= 0x03000000
        PyVarObject_HEAD_INIT(NULL, 0)
#else
        PyObject_HEAD_INIT(NULL)
        0,                                  /* ob_size */
#endif
        (char *)"swigvarlink",              /* tp_name */
        sizeof(swig_varlinkobject),         /* tp_basicsize */
        0,                                  /* tp_itemsize */
        (destructor) swig_varlink_dealloc,  /* tp_dealloc */
        (printfunc) swig_varlink_print,     /* tp_print */
        (getattrfunc) swig_varlink_getattr, /* tp_getattr */
        (setattrfunc) swig_varlink_setattr, /* tp_setattr */
        0,                                  /* tp_compare */
        (reprfunc) swig_varlink_repr,       /* tp_repr */
        0,                                  /* tp_as_number */
        0,                                  /* tp_as_sequence */
        0,                                  /* tp_as_mapping */
        0,                                  /* tp_hash */
        0,                                  /* tp_call */
        (reprfunc) swig_varlink_str,        /* tp_str */
        0,                                  /* tp_getattro */
        0,                                  /* tp_setattro */
        0,                                  /* tp_as_buffer */
        0,                                  /* tp_flags */
        varlink__doc__,                     /* tp_doc */
        0,                                  /* tp_traverse */
        0,                                  /* tp_clear */
        0,                                  /* tp_richcompare */
        0,                                  /* tp_weaklistoffset */
#if PY_VERSION_HEX >= 0x02020000
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
#endif
#if PY_VERSION_HEX >= 0x02030000
        0,                                  /* tp_del */
#endif
#if PY_VERSION_HEX >= 0x02060000
        0,                                  /* tp_version_tag */
#endif
#if PY_VERSION_HEX >= 0x03040000
        0,                                  /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
        0,                                  /* tp_allocs */
        0,                                  /* tp_frees */
        0,                                  /* tp_maxalloc */
#if PY_VERSION_HEX >= 0x02050000
        0,                                  /* tp_prev */
#endif
        0                                   /* tp_next */
#endif
      };
      varlink_type = tmp;
      type_init = 1;
#if PY_VERSION_HEX < 0x02020000
      varlink_type.ob_type = &PyType_Type;
#else
      if (PyType_Ready(&varlink_type) < 0)
      return NULL;
#endif
    }
    return &varlink_type;
  }
  
  /* Create a variable linking object for use later */
  SWIGINTERN PyObject *
  SWIG_Python_newvarlink(void) {
    swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
    if (result) {
      result->vars = 0;
    }
    return ((PyObject*) result);
  }
  
  SWIGINTERN void 
  SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
    swig_varlinkobject *v = (swig_varlinkobject *) p;
    swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
    if (gv) {
      size_t size = strlen(name)+1;
      gv->name = (char *)malloc(size);
      if (gv->name) {
        strncpy(gv->name,name,size);
        gv->get_attr = get_attr;
        gv->set_attr = set_attr;
        gv->next = v->vars;
      }
    }
    v->vars = gv;
  }
  
  SWIGINTERN PyObject *
  SWIG_globals(void) {
    static PyObject *_SWIG_globals = 0; 
    if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();  
    return _SWIG_globals;
  }
  
  /* -----------------------------------------------------------------------------
   * constants/methods manipulation
   * ----------------------------------------------------------------------------- */
  
  /* Install Constants */
  SWIGINTERN void
  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
    PyObject *obj = 0;
    size_t i;
    for (i = 0; constants[i].type; ++i) {
      switch(constants[i].type) {
      case SWIG_PY_POINTER:
        obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
        break;
      case SWIG_PY_BINARY:
        obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
        break;
      default:
        obj = 0;
        break;
      }
      if (obj) {
        PyDict_SetItemString(d, constants[i].name, obj);
        Py_DECREF(obj);
      }
    }
  }
  
  /* -----------------------------------------------------------------------------*/
  /* Fix SwigMethods to carry the callback ptrs when needed */
  /* -----------------------------------------------------------------------------*/
  
  SWIGINTERN void
  SWIG_Python_FixMethods(PyMethodDef *methods,
    swig_const_info *const_table,
    swig_type_info **types,
    swig_type_info **types_initial) {
    size_t i;
    for (i = 0; methods[i].ml_name; ++i) {
      const char *c = methods[i].ml_doc;
      if (!c) continue;
      c = strstr(c, "swig_ptr: ");
      if (c) {
        int j;
        swig_const_info *ci = 0;
        const char *name = c + 10;
        for (j = 0; const_table[j].type; ++j) {
          if (strncmp(const_table[j].name, name, 
              strlen(const_table[j].name)) == 0) {
            ci = &(const_table[j]);
            break;
          }
        }
        if (ci) {
          void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
          if (ptr) {
            size_t shift = (ci->ptype) - types;
            swig_type_info *ty = types_initial[shift];
            size_t ldoc = (c - methods[i].ml_doc);
            size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
            char *ndoc = (char*)malloc(ldoc + lptr + 10);
            if (ndoc) {
              char *buff = ndoc;
              strncpy(buff, methods[i].ml_doc, ldoc);
              buff += ldoc;
              strncpy(buff, "swig_ptr: ", 10);
              buff += 10;
              SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
              methods[i].ml_doc = ndoc;
            }
          }
        }
      }
    }
  } 
  
#ifdef __cplusplus
}
#endif

/* -----------------------------------------------------------------------------*
 *  Partial Init method
 * -----------------------------------------------------------------------------*/

#ifdef __cplusplus
extern "C"
#endif

SWIGEXPORT 
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
  PyObject *m, *d, *md;
#if PY_VERSION_HEX >= 0x03000000
  static struct PyModuleDef SWIG_module = {
# if PY_VERSION_HEX >= 0x03020000
    PyModuleDef_HEAD_INIT,
# else
    {
      PyObject_HEAD_INIT(NULL)
      NULL, /* m_init */
      0,    /* m_index */
      NULL, /* m_copy */
    },
# endif
    (char *) SWIG_name,
    NULL,
    -1,
    SwigMethods,
    NULL,
    NULL,
    NULL,
    NULL
  };
#endif
  
#if defined(SWIGPYTHON_BUILTIN)
  static SwigPyClientData SwigPyObject_clientdata = {
    0, 0, 0, 0, 0, 0, 0
  };
  static PyGetSetDef this_getset_def = {
    (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
  };
  static SwigPyGetSet thisown_getset_closure = {
    (PyCFunction) SwigPyObject_own,
    (PyCFunction) SwigPyObject_own
  };
  static PyGetSetDef thisown_getset_def = {
    (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
  };
  PyObject *metatype_args;
  PyTypeObject *builtin_pytype;
  int builtin_base_count;
  swig_type_info *builtin_basetype;
  PyObject *tuple;
  PyGetSetDescrObject *static_getset;
  PyTypeObject *metatype;
  SwigPyClientData *cd;
  PyObject *public_interface, *public_symbol;
  PyObject *this_descr;
  PyObject *thisown_descr;
  PyObject *self = 0;
  int i;
  
  (void)builtin_pytype;
  (void)builtin_base_count;
  (void)builtin_basetype;
  (void)tuple;
  (void)static_getset;
  (void)self;
  
  /* metatype is used to implement static member variables. */
  metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
  assert(metatype_args);
  metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
  assert(metatype);
  Py_DECREF(metatype_args);
  metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
  assert(PyType_Ready(metatype) >= 0);
#endif
  
  /* Fix SwigMethods to carry the callback ptrs when needed */
  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
  
#if PY_VERSION_HEX >= 0x03000000
  m = PyModule_Create(&SWIG_module);
#else
  m = Py_InitModule((char *) SWIG_name, SwigMethods);
#endif
  
  md = d = PyModule_GetDict(m);
  (void)md;
  
  SWIG_InitializeModule(0);
  
#ifdef SWIGPYTHON_BUILTIN
  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
  assert(SwigPyObject_stype);
  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
  if (!cd) {
    SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
    SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce();
  } else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) {
    PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
# if PY_VERSION_HEX >= 0x03000000
    return NULL;
# else
    return;
# endif
  }
  
  /* All objects have a 'this' attribute */
  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
  (void)this_descr;
  
  /* All objects have a 'thisown' attribute */
  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
  (void)thisown_descr;
  
  public_interface = PyList_New(0);
  public_symbol = 0;
  (void)public_symbol;
  
  PyDict_SetItemString(md, "__all__", public_interface);
  Py_DECREF(public_interface);
  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
  for (i = 0; swig_const_table[i].name != 0; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
  
  SWIG_InstallConstants(d,swig_const_table);
  
  PyDict_SetItemString(md,(char*)"cvar", SWIG_globals());
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_boolalpha",Swig_var_ios_base_boolalpha_get, Swig_var_ios_base_boolalpha_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_dec",Swig_var_ios_base_dec_get, Swig_var_ios_base_dec_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_fixed",Swig_var_ios_base_fixed_get, Swig_var_ios_base_fixed_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_hex",Swig_var_ios_base_hex_get, Swig_var_ios_base_hex_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_internal",Swig_var_ios_base_internal_get, Swig_var_ios_base_internal_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_left",Swig_var_ios_base_left_get, Swig_var_ios_base_left_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_oct",Swig_var_ios_base_oct_get, Swig_var_ios_base_oct_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_right",Swig_var_ios_base_right_get, Swig_var_ios_base_right_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_scientific",Swig_var_ios_base_scientific_get, Swig_var_ios_base_scientific_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_showbase",Swig_var_ios_base_showbase_get, Swig_var_ios_base_showbase_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_showpoint",Swig_var_ios_base_showpoint_get, Swig_var_ios_base_showpoint_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_showpos",Swig_var_ios_base_showpos_get, Swig_var_ios_base_showpos_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_skipws",Swig_var_ios_base_skipws_get, Swig_var_ios_base_skipws_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_unitbuf",Swig_var_ios_base_unitbuf_get, Swig_var_ios_base_unitbuf_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_uppercase",Swig_var_ios_base_uppercase_get, Swig_var_ios_base_uppercase_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_adjustfield",Swig_var_ios_base_adjustfield_get, Swig_var_ios_base_adjustfield_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_basefield",Swig_var_ios_base_basefield_get, Swig_var_ios_base_basefield_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_floatfield",Swig_var_ios_base_floatfield_get, Swig_var_ios_base_floatfield_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_badbit",Swig_var_ios_base_badbit_get, Swig_var_ios_base_badbit_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_eofbit",Swig_var_ios_base_eofbit_get, Swig_var_ios_base_eofbit_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_failbit",Swig_var_ios_base_failbit_get, Swig_var_ios_base_failbit_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_goodbit",Swig_var_ios_base_goodbit_get, Swig_var_ios_base_goodbit_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_app",Swig_var_ios_base_app_get, Swig_var_ios_base_app_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_ate",Swig_var_ios_base_ate_get, Swig_var_ios_base_ate_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_binary",Swig_var_ios_base_binary_get, Swig_var_ios_base_binary_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_ios_base_in",Swig_var_ios_base_ios_base_in_get, Swig_var_ios_base_ios_base_in_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_out",Swig_var_ios_base_out_get, Swig_var_ios_base_out_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_trunc",Swig_var_ios_base_trunc_get, Swig_var_ios_base_trunc_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_beg",Swig_var_ios_base_beg_get, Swig_var_ios_base_beg_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_cur",Swig_var_ios_base_cur_get, Swig_var_ios_base_cur_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ios_base_end",Swig_var_ios_base_end_get, Swig_var_ios_base_end_set);
  SWIG_Python_SetConstant(d, "ios_base_erase_event",SWIG_From_int(static_cast< int >(std::ios_base::erase_event)));
  SWIG_Python_SetConstant(d, "ios_base_imbue_event",SWIG_From_int(static_cast< int >(std::ios_base::imbue_event)));
  SWIG_Python_SetConstant(d, "ios_base_copyfmt_event",SWIG_From_int(static_cast< int >(std::ios_base::copyfmt_event)));
  SWIG_addvarlink(SWIG_globals(),(char*)"cin",Swig_var_cin_get, Swig_var_cin_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"cout",Swig_var_cout_get, Swig_var_cout_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"cerr",Swig_var_cerr_get, Swig_var_cerr_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"clog",Swig_var_clog_get, Swig_var_clog_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"XMLTag_end",Swig_var_XMLTag_end_get, Swig_var_XMLTag_end_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ResonanceWidths_NPOINT",Swig_var_ResonanceWidths_NPOINT_get, Swig_var_ResonanceWidths_NPOINT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ResonanceWidths_MASSMIN",Swig_var_ResonanceWidths_MASSMIN_get, Swig_var_ResonanceWidths_MASSMIN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"ResonanceWidths_MASSMARGIN",Swig_var_ResonanceWidths_MASSMARGIN_get, Swig_var_ResonanceWidths_MASSMARGIN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StringRegion_MJOIN",Swig_var_StringRegion_MJOIN_get, Swig_var_StringRegion_MJOIN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StringRegion_TINY",Swig_var_StringRegion_TINY_get, Swig_var_StringRegion_TINY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"LHAup_CONVERTMB2PB",Swig_var_LHAup_CONVERTMB2PB_get, Swig_var_LHAup_CONVERTMB2PB_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SigmaProcess_CONVERT2MB",Swig_var_SigmaProcess_CONVERT2MB_get, Swig_var_SigmaProcess_CONVERT2MB_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SigmaProcess_MASSMARGIN",Swig_var_SigmaProcess_MASSMARGIN_get, Swig_var_SigmaProcess_MASSMARGIN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SigmaProcess_COMPRELERR",Swig_var_SigmaProcess_COMPRELERR_get, Swig_var_SigmaProcess_COMPRELERR_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"SigmaProcess_NCOMPSTEP",Swig_var_SigmaProcess_NCOMPSTEP_get, Swig_var_SigmaProcess_NCOMPSTEP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PhaseSpace_NMAXTRY",Swig_var_PhaseSpace_NMAXTRY_get, Swig_var_PhaseSpace_NMAXTRY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PhaseSpace_NTRY3BODY",Swig_var_PhaseSpace_NTRY3BODY_get, Swig_var_PhaseSpace_NTRY3BODY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PhaseSpace_SAFETYMARGIN",Swig_var_PhaseSpace_SAFETYMARGIN_get, Swig_var_PhaseSpace_SAFETYMARGIN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PhaseSpace_TINY",Swig_var_PhaseSpace_TINY_get, Swig_var_PhaseSpace_TINY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PhaseSpace_EVENFRAC",Swig_var_PhaseSpace_EVENFRAC_get, Swig_var_PhaseSpace_EVENFRAC_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PhaseSpace_SAMESIGMA",Swig_var_PhaseSpace_SAMESIGMA_get, Swig_var_PhaseSpace_SAMESIGMA_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PhaseSpace_MRESMINABS",Swig_var_PhaseSpace_MRESMINABS_get, Swig_var_PhaseSpace_MRESMINABS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PhaseSpace_WIDTHMARGIN",Swig_var_PhaseSpace_WIDTHMARGIN_get, Swig_var_PhaseSpace_WIDTHMARGIN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PhaseSpace_SAMEMASS",Swig_var_PhaseSpace_SAMEMASS_get, Swig_var_PhaseSpace_SAMEMASS_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PhaseSpace_MASSMARGIN",Swig_var_PhaseSpace_MASSMARGIN_get, Swig_var_PhaseSpace_MASSMARGIN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PhaseSpace_EXTRABWWTMAX",Swig_var_PhaseSpace_EXTRABWWTMAX_get, Swig_var_PhaseSpace_EXTRABWWTMAX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PhaseSpace_THRESHOLDSIZE",Swig_var_PhaseSpace_THRESHOLDSIZE_get, Swig_var_PhaseSpace_THRESHOLDSIZE_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PhaseSpace_THRESHOLDSTEP",Swig_var_PhaseSpace_THRESHOLDSTEP_get, Swig_var_PhaseSpace_THRESHOLDSTEP_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PhaseSpace_YRANGEMARGIN",Swig_var_PhaseSpace_YRANGEMARGIN_get, Swig_var_PhaseSpace_YRANGEMARGIN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PhaseSpace_LEPTONXMIN",Swig_var_PhaseSpace_LEPTONXMIN_get, Swig_var_PhaseSpace_LEPTONXMIN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PhaseSpace_LEPTONXMAX",Swig_var_PhaseSpace_LEPTONXMAX_get, Swig_var_PhaseSpace_LEPTONXMAX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PhaseSpace_LEPTONXLOGMIN",Swig_var_PhaseSpace_LEPTONXLOGMIN_get, Swig_var_PhaseSpace_LEPTONXLOGMIN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PhaseSpace_LEPTONXLOGMAX",Swig_var_PhaseSpace_LEPTONXLOGMAX_get, Swig_var_PhaseSpace_LEPTONXLOGMAX_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PhaseSpace_LEPTONTAUMIN",Swig_var_PhaseSpace_LEPTONTAUMIN_get, Swig_var_PhaseSpace_LEPTONTAUMIN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PhaseSpace_SHATMINZ",Swig_var_PhaseSpace_SHATMINZ_get, Swig_var_PhaseSpace_SHATMINZ_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PhaseSpace_PT2RATMINZ",Swig_var_PhaseSpace_PT2RATMINZ_get, Swig_var_PhaseSpace_PT2RATMINZ_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"PhaseSpace_WTCORRECTION",Swig_var_PhaseSpace_WTCORRECTION_get, Swig_var_PhaseSpace_WTCORRECTION_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StringEnd_TINY",Swig_var_StringEnd_TINY_get, Swig_var_StringEnd_TINY_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StringEnd_PT2SAME",Swig_var_StringEnd_PT2SAME_get, Swig_var_StringEnd_PT2SAME_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StringEnd_MEANMMIN",Swig_var_StringEnd_MEANMMIN_get, Swig_var_StringEnd_MEANMMIN_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StringEnd_MEANM",Swig_var_StringEnd_MEANM_get, Swig_var_StringEnd_MEANM_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"StringEnd_MEANPT",Swig_var_StringEnd_MEANPT_get, Swig_var_StringEnd_MEANPT_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"femtometer",Swig_var_femtometer_get, Swig_var_femtometer_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"millimeter",Swig_var_millimeter_get, Swig_var_millimeter_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"femtometer2",Swig_var_femtometer2_get, Swig_var_femtometer2_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"millibarn",Swig_var_millibarn_get, Swig_var_millibarn_set);
  SWIG_addvarlink(SWIG_globals(),(char*)"nanobarn",Swig_var_nanobarn_get, Swig_var_nanobarn_set);
  SWIG_Python_SetConstant(d, "Nucleon_UNWOUNDED",SWIG_From_int(static_cast< int >(Pythia8::Nucleon::UNWOUNDED)));
  SWIG_Python_SetConstant(d, "Nucleon_ELASTIC",SWIG_From_int(static_cast< int >(Pythia8::Nucleon::ELASTIC)));
  SWIG_Python_SetConstant(d, "Nucleon_DIFF",SWIG_From_int(static_cast< int >(Pythia8::Nucleon::DIFF)));
  SWIG_Python_SetConstant(d, "Nucleon_ABS",SWIG_From_int(static_cast< int >(Pythia8::Nucleon::ABS)));
  SWIG_Python_SetConstant(d, "SubCollision_NONE",SWIG_From_int(static_cast< int >(Pythia8::SubCollision::NONE)));
  SWIG_Python_SetConstant(d, "SubCollision_ELASTIC",SWIG_From_int(static_cast< int >(Pythia8::SubCollision::ELASTIC)));
  SWIG_Python_SetConstant(d, "SubCollision_SDEP",SWIG_From_int(static_cast< int >(Pythia8::SubCollision::SDEP)));
  SWIG_Python_SetConstant(d, "SubCollision_SDET",SWIG_From_int(static_cast< int >(Pythia8::SubCollision::SDET)));
  SWIG_Python_SetConstant(d, "SubCollision_DDE",SWIG_From_int(static_cast< int >(Pythia8::SubCollision::DDE)));
  SWIG_Python_SetConstant(d, "SubCollision_CDE",SWIG_From_int(static_cast< int >(Pythia8::SubCollision::CDE)));
  SWIG_Python_SetConstant(d, "SubCollision_ABS",SWIG_From_int(static_cast< int >(Pythia8::SubCollision::ABS)));
  SWIG_Python_SetConstant(d, "LHAupMadgraph_Auto",SWIG_From_int(static_cast< int >(Pythia8::LHAupMadgraph::Auto)));
  SWIG_Python_SetConstant(d, "LHAupMadgraph_Configure",SWIG_From_int(static_cast< int >(Pythia8::LHAupMadgraph::Configure)));
  SWIG_Python_SetConstant(d, "LHAupMadgraph_Generate",SWIG_From_int(static_cast< int >(Pythia8::LHAupMadgraph::Generate)));
  SWIG_Python_SetConstant(d, "LHAupMadgraph_Launch",SWIG_From_int(static_cast< int >(Pythia8::LHAupMadgraph::Launch)));
  SWIG_Python_SetConstant(d, "Angantyr_HADRON",SWIG_From_int(static_cast< int >(Pythia8::Angantyr::HADRON)));
  SWIG_Python_SetConstant(d, "Angantyr_MBIAS",SWIG_From_int(static_cast< int >(Pythia8::Angantyr::MBIAS)));
  SWIG_Python_SetConstant(d, "Angantyr_SASD",SWIG_From_int(static_cast< int >(Pythia8::Angantyr::SASD)));
  SWIG_Python_SetConstant(d, "Angantyr_SIGPP",SWIG_From_int(static_cast< int >(Pythia8::Angantyr::SIGPP)));
  SWIG_Python_SetConstant(d, "Angantyr_SIGPN",SWIG_From_int(static_cast< int >(Pythia8::Angantyr::SIGPN)));
  SWIG_Python_SetConstant(d, "Angantyr_SIGNP",SWIG_From_int(static_cast< int >(Pythia8::Angantyr::SIGNP)));
  SWIG_Python_SetConstant(d, "Angantyr_SIGNN",SWIG_From_int(static_cast< int >(Pythia8::Angantyr::SIGNN)));
  SWIG_Python_SetConstant(d, "Angantyr_ALL",SWIG_From_int(static_cast< int >(Pythia8::Angantyr::ALL)));
#if PY_VERSION_HEX >= 0x03000000
  return m;
#else
  return;
#endif
}

// PYTHON SOURCE
//"""
//Copyright (C) 2018 Torbjorn Sjostrand.
//PYTHIA is licenced under the GNU GPL v2 or later, see COPYING for details.
//Please respect the MCnet Guidelines, see GUIDELINES for details.
//
//This module is a Python interface to PYTHIA 8, generated
//automatically with SWIG. An attempt has been made to translate all
//PYTHIA classes and functions as directly as possible. The following
//features are included:
//
//* All PYTHIA classes and functions are available. See main01.py for
//  a direct Python translation of the C++ main01.cc example.
//* Most of the plugin classes are also available in the
//  interface. See main34.py for a direct Python translation of the C++
//  main34.cc example which uses the LHAupMadgraph class from
//  include/Pythia8Plugins/LHAMadgraph.h.
//* When available, documentation through the built-in help function
//  in Python is provided. Please note that this documentation is
//  automatically generated, similar to the Doxygen
//  documentation. Consequently, the inline Python documentation is not a
//  replacement for this manual.
//* All operators defined in C++, e.g. Vec4*double, as well as reverse
//  operators, e.g. double*Vec4, are available.
//* Classes with defined [] operators are iterable, using standard
//  Python iteration, e.g. for prt in pythia.event.
//* Classes with a << operator or a list function can be printed
//  via the built-in print function in Python. Note this means that a
//  string representation via str is also available for these classes in
//  Python.
//* Specific versions of templates needed by PYTHIA classes are
//  available where the naming scheme is the template class name followed
//  by its arguments (stripped of namespace specifiers); pointers to
//  classes are prepended with Ptr. For example, vector<int> is available
//  via the interface as VectorInt, map<string, Mode> as MapStringMode,
//  and vector<ProcessContainer*> as VectorProcessContainerPtr.
//* Derived classes in Python, for a subset of PYTHIA classes, can be
//  passed back to PYTHIA. This is possible for all classes that can be
//  passed to the Pythia class via the setXPtr functions and includes the
//  following classes: BeamShape, DecayHandler, LHAup, MergingHooks, PDF,
//  PhaseSpace, ResonanceWidths, RndmEngine, SigmaProcess, SpaceShower,
//  TimeShower, and UserHooks. The protected functions and members of
//  these classes are available through the Python interface. See
//  main10.py for a direct Python translation of the C++ main10.cc example
//  which uses a derived class from the UserHooks class to veto events.
//
//This interface currently suffers from the following limitations:
//
//* In the CoupSUSY class all public members that are 3-by-3 arrays
//  cannot be accessed, these include LsddX, LsuuX, LsduX, LsudX, LsvvX,
//  LsllX, LsvlX, LslvX, as well as the equivalent R versions of these
//  members. Additionally, rvLLE, rvLQD, and rvUDD cannot be accessed.
//* In the MergingHooks class, the protected methods orderHistories,
//  allowCutonRecState, and doWeakClustering with bool return values have
//  been renamed as getOrderHistories, getAllowCutonRecState, and
//  getDoWeakClustering, respectively, in the Python interface.
//* The public headerStream, initStream, and eventStream members of
//  the Writer class, used for writing LHEF output, cannot be accessed
//  from the Python interface.
//* For derived Python classes of the PYTHIA class LHAup, the
//  protected member osLHEF cannot be accessed.
//* The wrapper generated by SWIG is large (10 MB), and consequently
//  the compile time can be significant. The only way to reduce the size
//  of the wrapper is to remove functionality from the interface.
//* Creating a derived Python class from a PYTHIA class, as described
//  above in the features, is only possible for a subset of PYTHIA
//  classes. However, if this feature is needed for specific classes, they
//  can be added in the future upon request. This feature is not enabled
//  by default for all classes to reduce the generated wrapper size.
//* Python interfaces have not been generated for plugins within
//  include/Pythia8Plugins which have direct external dependencies. This
//  means there are no Python interfaces for any of the classes or
//  functions defined in EvtGen.h, FastJet3.h, HepMC2.h, or
//  LHAFortran.h. However, interfaces are available for all remaining
//  plugins, including both LHAMadgraph.h and PowhegProcs.h.
//"""

//# This file was automatically generated by SWIG (http://www.swig.org).
//# Version 3.0.8
//#
//# Do not make changes to this file unless you know what you are doing--modify
//# the SWIG interface file instead.
//
//
//
//
//
//from sys import version_info
//if version_info >= (2, 6, 0):
//    def swig_import_helper():
//        from os.path import dirname
//        import imp
//        fp = None
//        try:
//            fp, pathname, description = imp.find_module('_pythia8', [dirname(__file__)])
//        except ImportError:
//            import _pythia8
//            return _pythia8
//        if fp is not None:
//            try:
//                _mod = imp.load_module('_pythia8', fp, pathname, description)
//            finally:
//                fp.close()
//            return _mod
//    _pythia8 = swig_import_helper()
//    del swig_import_helper
//else:
//    import _pythia8
//del version_info
//try:
//    _swig_property = property
//except NameError:
//    pass  # Python < 2.2 doesn't have 'property'.
//
//
//def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
//    if (name == "thisown"):
//        return self.this.own(value)
//    if (name == "this"):
//        if type(value).__name__ == 'SwigPyObject':
//            self.__dict__[name] = value
//            return
//    method = class_type.__swig_setmethods__.get(name, None)
//    if method:
//        return method(self, value)
//    if (not static):
//        if _newclass:
//            object.__setattr__(self, name, value)
//        else:
//            self.__dict__[name] = value
//    else:
//        raise AttributeError("You cannot add attributes to %s" % self)
//
//
//def _swig_setattr(self, class_type, name, value):
//    return _swig_setattr_nondynamic(self, class_type, name, value, 0)
//
//
//def _swig_getattr_nondynamic(self, class_type, name, static=1):
//    if (name == "thisown"):
//        return self.this.own()
//    method = class_type.__swig_getmethods__.get(name, None)
//    if method:
//        return method(self)
//    if (not static):
//        return object.__getattr__(self, name)
//    else:
//        raise AttributeError(name)
//
//def _swig_getattr(self, class_type, name):
//    return _swig_getattr_nondynamic(self, class_type, name, 0)
//
//
//def _swig_repr(self):
//    try:
//        strthis = "proxy of " + self.this.__repr__()
//    except Exception:
//        strthis = ""
//    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
//
//try:
//    _object = object
//    _newclass = 1
//except AttributeError:
//    class _object:
//        pass
//    _newclass = 0
//
//
//try:
//    import weakref
//    weakref_proxy = weakref.proxy
//except Exception:
//    weakref_proxy = lambda x: x
//
//
//class SwigPyIterator(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
//
//    def __init__(self, *args, **kwargs):
//        raise AttributeError("No constructor defined - class is abstract")
//    __repr__ = _swig_repr
//    __swig_destroy__ = _pythia8.delete_SwigPyIterator
//    __del__ = lambda self: None
//
//    def value(self):
//        return _pythia8.SwigPyIterator_value(self)
//
//    def incr(self, n=1):
//        return _pythia8.SwigPyIterator_incr(self, n)
//
//    def decr(self, n=1):
//        return _pythia8.SwigPyIterator_decr(self, n)
//
//    def distance(self, x):
//        return _pythia8.SwigPyIterator_distance(self, x)
//
//    def equal(self, x):
//        return _pythia8.SwigPyIterator_equal(self, x)
//
//    def copy(self):
//        return _pythia8.SwigPyIterator_copy(self)
//
//    def next(self):
//        return _pythia8.SwigPyIterator_next(self)
//
//    def __next__(self):
//        return _pythia8.SwigPyIterator___next__(self)
//
//    def previous(self):
//        return _pythia8.SwigPyIterator_previous(self)
//
//    def advance(self, n):
//        return _pythia8.SwigPyIterator_advance(self, n)
//
//    def __eq__(self, x):
//        return _pythia8.SwigPyIterator___eq__(self, x)
//
//    def __ne__(self, x):
//        return _pythia8.SwigPyIterator___ne__(self, x)
//
//    def __iadd__(self, n):
//        return _pythia8.SwigPyIterator___iadd__(self, n)
//
//    def __isub__(self, n):
//        return _pythia8.SwigPyIterator___isub__(self, n)
//
//    def __add__(self, n):
//        return _pythia8.SwigPyIterator___add__(self, n)
//
//    def __sub__(self, *args):
//        return _pythia8.SwigPyIterator___sub__(self, *args)
//    def __iter__(self):
//        return self
//SwigPyIterator_swigregister = _pythia8.SwigPyIterator_swigregister
//SwigPyIterator_swigregister(SwigPyIterator)
//
//class ios_base(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ios_base, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, ios_base, name)
//
//    def __init__(self, *args, **kwargs):
//        raise AttributeError("No constructor defined")
//    __repr__ = _swig_repr
//    erase_event = _pythia8.ios_base_erase_event
//    imbue_event = _pythia8.ios_base_imbue_event
//    copyfmt_event = _pythia8.ios_base_copyfmt_event
//
//    def register_callback(self, __fn, __index):
//        return _pythia8.ios_base_register_callback(self, __fn, __index)
//
//    def flags(self, *args):
//        return _pythia8.ios_base_flags(self, *args)
//
//    def setf(self, *args):
//        return _pythia8.ios_base_setf(self, *args)
//
//    def unsetf(self, __mask):
//        return _pythia8.ios_base_unsetf(self, __mask)
//
//    def precision(self, *args):
//        return _pythia8.ios_base_precision(self, *args)
//
//    def width(self, *args):
//        return _pythia8.ios_base_width(self, *args)
//    __swig_getmethods__["sync_with_stdio"] = lambda x: _pythia8.ios_base_sync_with_stdio
//    if _newclass:
//        sync_with_stdio = staticmethod(_pythia8.ios_base_sync_with_stdio)
//
//    def imbue(self, __loc):
//        return _pythia8.ios_base_imbue(self, __loc)
//
//    def getloc(self):
//        return _pythia8.ios_base_getloc(self)
//    __swig_getmethods__["xalloc"] = lambda x: _pythia8.ios_base_xalloc
//    if _newclass:
//        xalloc = staticmethod(_pythia8.ios_base_xalloc)
//
//    def iword(self, __ix):
//        return _pythia8.ios_base_iword(self, __ix)
//
//    def pword(self, __ix):
//        return _pythia8.ios_base_pword(self, __ix)
//    __swig_destroy__ = _pythia8.delete_ios_base
//    __del__ = lambda self: None
//ios_base_swigregister = _pythia8.ios_base_swigregister
//ios_base_swigregister(ios_base)
//cvar = _pythia8.cvar
//ios_base.boolalpha = _pythia8.cvar.ios_base_boolalpha
//ios_base.dec = _pythia8.cvar.ios_base_dec
//ios_base.fixed = _pythia8.cvar.ios_base_fixed
//ios_base.hex = _pythia8.cvar.ios_base_hex
//ios_base.internal = _pythia8.cvar.ios_base_internal
//ios_base.left = _pythia8.cvar.ios_base_left
//ios_base.oct = _pythia8.cvar.ios_base_oct
//ios_base.right = _pythia8.cvar.ios_base_right
//ios_base.scientific = _pythia8.cvar.ios_base_scientific
//ios_base.showbase = _pythia8.cvar.ios_base_showbase
//ios_base.showpoint = _pythia8.cvar.ios_base_showpoint
//ios_base.showpos = _pythia8.cvar.ios_base_showpos
//ios_base.skipws = _pythia8.cvar.ios_base_skipws
//ios_base.unitbuf = _pythia8.cvar.ios_base_unitbuf
//ios_base.uppercase = _pythia8.cvar.ios_base_uppercase
//ios_base.adjustfield = _pythia8.cvar.ios_base_adjustfield
//ios_base.basefield = _pythia8.cvar.ios_base_basefield
//ios_base.floatfield = _pythia8.cvar.ios_base_floatfield
//ios_base.badbit = _pythia8.cvar.ios_base_badbit
//ios_base.eofbit = _pythia8.cvar.ios_base_eofbit
//ios_base.failbit = _pythia8.cvar.ios_base_failbit
//ios_base.goodbit = _pythia8.cvar.ios_base_goodbit
//ios_base.app = _pythia8.cvar.ios_base_app
//ios_base.ate = _pythia8.cvar.ios_base_ate
//ios_base.binary = _pythia8.cvar.ios_base_binary
//ios_base.ios_base_in = _pythia8.cvar.ios_base_ios_base_in
//ios_base.out = _pythia8.cvar.ios_base_out
//ios_base.trunc = _pythia8.cvar.ios_base_trunc
//ios_base.beg = _pythia8.cvar.ios_base_beg
//ios_base.cur = _pythia8.cvar.ios_base_cur
//ios_base.end = _pythia8.cvar.ios_base_end
//
//def ios_base_sync_with_stdio(__sync=True):
//    return _pythia8.ios_base_sync_with_stdio(__sync)
//ios_base_sync_with_stdio = _pythia8.ios_base_sync_with_stdio
//
//def ios_base_xalloc():
//    return _pythia8.ios_base_xalloc()
//ios_base_xalloc = _pythia8.ios_base_xalloc
//
//class ios(ios_base):
//    __swig_setmethods__ = {}
//    for _s in [ios_base]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ios, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ios_base]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ios, name)
//    __repr__ = _swig_repr
//
//    def rdstate(self):
//        return _pythia8.ios_rdstate(self)
//
//    def clear(self, *args):
//        return _pythia8.ios_clear(self, *args)
//
//    def setstate(self, __state):
//        return _pythia8.ios_setstate(self, __state)
//
//    def good(self):
//        return _pythia8.ios_good(self)
//
//    def eof(self):
//        return _pythia8.ios_eof(self)
//
//    def fail(self):
//        return _pythia8.ios_fail(self)
//
//    def bad(self):
//        return _pythia8.ios_bad(self)
//
//    def exceptions(self, *args):
//        return _pythia8.ios_exceptions(self, *args)
//
//    def __init__(self, __sb):
//        this = _pythia8.new_ios(__sb)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ios
//    __del__ = lambda self: None
//
//    def tie(self, *args):
//        return _pythia8.ios_tie(self, *args)
//
//    def rdbuf(self, *args):
//        return _pythia8.ios_rdbuf(self, *args)
//
//    def copyfmt(self, __rhs):
//        return _pythia8.ios_copyfmt(self, __rhs)
//
//    def fill(self, *args):
//        return _pythia8.ios_fill(self, *args)
//
//    def imbue(self, __loc):
//        return _pythia8.ios_imbue(self, __loc)
//
//    def narrow(self, __c, __dfault):
//        return _pythia8.ios_narrow(self, __c, __dfault)
//
//    def widen(self, __c):
//        return _pythia8.ios_widen(self, __c)
//ios_swigregister = _pythia8.ios_swigregister
//ios_swigregister(ios)
//
//class ostream(ios):
//    __swig_setmethods__ = {}
//    for _s in [ios]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ostream, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ios]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ostream, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, __sb):
//        this = _pythia8.new_ostream(__sb)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ostream
//    __del__ = lambda self: None
//
//    def __lshift__(self, *args):
//        return _pythia8.ostream___lshift__(self, *args)
//
//    def put(self, __c):
//        return _pythia8.ostream_put(self, __c)
//
//    def write(self, __s, __n):
//        return _pythia8.ostream_write(self, __s, __n)
//
//    def flush(self):
//        return _pythia8.ostream_flush(self)
//
//    def tellp(self):
//        return _pythia8.ostream_tellp(self)
//
//    def seekp(self, *args):
//        return _pythia8.ostream_seekp(self, *args)
//ostream_swigregister = _pythia8.ostream_swigregister
//ostream_swigregister(ostream)
//cin = cvar.cin
//cout = cvar.cout
//cerr = cvar.cerr
//clog = cvar.clog
//
//class istream(ios):
//    __swig_setmethods__ = {}
//    for _s in [ios]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, istream, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ios]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, istream, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, __sb):
//        this = _pythia8.new_istream(__sb)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_istream
//    __del__ = lambda self: None
//
//    def __rshift__(self, *args):
//        return _pythia8.istream___rshift__(self, *args)
//
//    def gcount(self):
//        return _pythia8.istream_gcount(self)
//
//    def get(self, *args):
//        return _pythia8.istream_get(self, *args)
//
//    def getline(self, *args):
//        return _pythia8.istream_getline(self, *args)
//
//    def ignore(self, *args):
//        return _pythia8.istream_ignore(self, *args)
//
//    def peek(self):
//        return _pythia8.istream_peek(self)
//
//    def read(self, __s, __n):
//        return _pythia8.istream_read(self, __s, __n)
//
//    def readsome(self, __s, __n):
//        return _pythia8.istream_readsome(self, __s, __n)
//
//    def putback(self, __c):
//        return _pythia8.istream_putback(self, __c)
//
//    def unget(self):
//        return _pythia8.istream_unget(self)
//
//    def sync(self):
//        return _pythia8.istream_sync(self)
//
//    def tellg(self):
//        return _pythia8.istream_tellg(self)
//
//    def seekg(self, *args):
//        return _pythia8.istream_seekg(self, *args)
//istream_swigregister = _pythia8.istream_swigregister
//istream_swigregister(istream)
//
//class iostream(istream, ostream):
//    __swig_setmethods__ = {}
//    for _s in [istream, ostream]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, iostream, name, value)
//    __swig_getmethods__ = {}
//    for _s in [istream, ostream]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, iostream, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, __sb):
//        this = _pythia8.new_iostream(__sb)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_iostream
//    __del__ = lambda self: None
//iostream_swigregister = _pythia8.iostream_swigregister
//iostream_swigregister(iostream)
//
//
//_pythia8.endl_cb_ptr_swigconstant(_pythia8)
//endl_cb_ptr = _pythia8.endl_cb_ptr
//
//def endl(arg1):
//    return _pythia8.endl(arg1)
//endl = _pythia8.endl
//
//_pythia8.ends_cb_ptr_swigconstant(_pythia8)
//ends_cb_ptr = _pythia8.ends_cb_ptr
//
//def ends(arg1):
//    return _pythia8.ends(arg1)
//ends = _pythia8.ends
//
//_pythia8.flush_cb_ptr_swigconstant(_pythia8)
//flush_cb_ptr = _pythia8.flush_cb_ptr
//
//def flush(arg1):
//    return _pythia8.flush(arg1)
//flush = _pythia8.flush
//class streambuf(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, streambuf, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, streambuf, name)
//
//    def __init__(self, *args, **kwargs):
//        raise AttributeError("No constructor defined")
//    __repr__ = _swig_repr
//    __swig_destroy__ = _pythia8.delete_streambuf
//    __del__ = lambda self: None
//
//    def pubimbue(self, __loc):
//        return _pythia8.streambuf_pubimbue(self, __loc)
//
//    def getloc(self):
//        return _pythia8.streambuf_getloc(self)
//
//    def pubsetbuf(self, __s, __n):
//        return _pythia8.streambuf_pubsetbuf(self, __s, __n)
//
//    def pubseekoff(self, *args):
//        return _pythia8.streambuf_pubseekoff(self, *args)
//
//    def pubseekpos(self, *args):
//        return _pythia8.streambuf_pubseekpos(self, *args)
//
//    def pubsync(self):
//        return _pythia8.streambuf_pubsync(self)
//
//    def in_avail(self):
//        return _pythia8.streambuf_in_avail(self)
//
//    def snextc(self):
//        return _pythia8.streambuf_snextc(self)
//
//    def sbumpc(self):
//        return _pythia8.streambuf_sbumpc(self)
//
//    def sgetc(self):
//        return _pythia8.streambuf_sgetc(self)
//
//    def sgetn(self, __s, __n):
//        return _pythia8.streambuf_sgetn(self, __s, __n)
//
//    def sputbackc(self, __c):
//        return _pythia8.streambuf_sputbackc(self, __c)
//
//    def sungetc(self):
//        return _pythia8.streambuf_sungetc(self)
//
//    def sputc(self, __c):
//        return _pythia8.streambuf_sputc(self, __c)
//
//    def sputn(self, __s, __n):
//        return _pythia8.streambuf_sputn(self, __s, __n)
//streambuf_swigregister = _pythia8.streambuf_swigregister
//streambuf_swigregister(streambuf)
//
//class istringstream(istream):
//    __swig_setmethods__ = {}
//    for _s in [istream]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, istringstream, name, value)
//    __swig_getmethods__ = {}
//    for _s in [istream]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, istringstream, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        this = _pythia8.new_istringstream(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_istringstream
//    __del__ = lambda self: None
//
//    def rdbuf(self):
//        return _pythia8.istringstream_rdbuf(self)
//
//    def str(self, *args):
//        return _pythia8.istringstream_str(self, *args)
//istringstream_swigregister = _pythia8.istringstream_swigregister
//istringstream_swigregister(istringstream)
//
//class ostringstream(ostream):
//    __swig_setmethods__ = {}
//    for _s in [ostream]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ostringstream, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ostream]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ostringstream, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        this = _pythia8.new_ostringstream(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ostringstream
//    __del__ = lambda self: None
//
//    def rdbuf(self):
//        return _pythia8.ostringstream_rdbuf(self)
//
//    def str(self):
//        return _pythia8.ostringstream_str(self)
//ostringstream_swigregister = _pythia8.ostringstream_swigregister
//ostringstream_swigregister(ostringstream)
//
//class stringstream(iostream):
//    __swig_setmethods__ = {}
//    for _s in [iostream]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, stringstream, name, value)
//    __swig_getmethods__ = {}
//    for _s in [iostream]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, stringstream, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        this = _pythia8.new_stringstream(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_stringstream
//    __del__ = lambda self: None
//
//    def rdbuf(self):
//        return _pythia8.stringstream_rdbuf(self)
//
//    def str(self, *args):
//        return _pythia8.stringstream_str(self, *args)
//stringstream_swigregister = _pythia8.stringstream_swigregister
//stringstream_swigregister(stringstream)
//
//class PairIntInt(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, PairIntInt, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, PairIntInt, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        this = _pythia8.new_PairIntInt(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["first"] = _pythia8.PairIntInt_first_set
//    __swig_getmethods__["first"] = _pythia8.PairIntInt_first_get
//    if _newclass:
//        first = _swig_property(_pythia8.PairIntInt_first_get, _pythia8.PairIntInt_first_set)
//    __swig_setmethods__["second"] = _pythia8.PairIntInt_second_set
//    __swig_getmethods__["second"] = _pythia8.PairIntInt_second_get
//    if _newclass:
//        second = _swig_property(_pythia8.PairIntInt_second_get, _pythia8.PairIntInt_second_set)
//    def __len__(self):
//        return 2
//    def __repr__(self):
//        return str((self.first, self.second))
//    def __getitem__(self, index): 
//        if not (index % 2):
//            return self.first
//        else:
//            return self.second
//    def __setitem__(self, index, val):
//        if not (index % 2):
//            self.first = val
//        else:
//            self.second = val
//    __swig_destroy__ = _pythia8.delete_PairIntInt
//    __del__ = lambda self: None
//PairIntInt_swigregister = _pythia8.PairIntInt_swigregister
//PairIntInt_swigregister(PairIntInt)
//
//class MapIntInt(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, MapIntInt, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, MapIntInt, name)
//    __repr__ = _swig_repr
//
//    def iterator(self):
//        return _pythia8.MapIntInt_iterator(self)
//    def __iter__(self):
//        return self.iterator()
//
//    def __nonzero__(self):
//        return _pythia8.MapIntInt___nonzero__(self)
//
//    def __bool__(self):
//        return _pythia8.MapIntInt___bool__(self)
//
//    def __len__(self):
//        return _pythia8.MapIntInt___len__(self)
//    def __iter__(self):
//        return self.key_iterator()
//    def iterkeys(self):
//        return self.key_iterator()
//    def itervalues(self):
//        return self.value_iterator()
//    def iteritems(self):
//        return self.iterator()
//
//    def __getitem__(self, key):
//        return _pythia8.MapIntInt___getitem__(self, key)
//
//    def __delitem__(self, key):
//        return _pythia8.MapIntInt___delitem__(self, key)
//
//    def has_key(self, key):
//        return _pythia8.MapIntInt_has_key(self, key)
//
//    def keys(self):
//        return _pythia8.MapIntInt_keys(self)
//
//    def values(self):
//        return _pythia8.MapIntInt_values(self)
//
//    def items(self):
//        return _pythia8.MapIntInt_items(self)
//
//    def __contains__(self, key):
//        return _pythia8.MapIntInt___contains__(self, key)
//
//    def key_iterator(self):
//        return _pythia8.MapIntInt_key_iterator(self)
//
//    def value_iterator(self):
//        return _pythia8.MapIntInt_value_iterator(self)
//
//    def __setitem__(self, *args):
//        return _pythia8.MapIntInt___setitem__(self, *args)
//
//    def asdict(self):
//        return _pythia8.MapIntInt_asdict(self)
//
//    def __init__(self, *args):
//        this = _pythia8.new_MapIntInt(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def empty(self):
//        return _pythia8.MapIntInt_empty(self)
//
//    def size(self):
//        return _pythia8.MapIntInt_size(self)
//
//    def swap(self, v):
//        return _pythia8.MapIntInt_swap(self, v)
//
//    def begin(self):
//        return _pythia8.MapIntInt_begin(self)
//
//    def end(self):
//        return _pythia8.MapIntInt_end(self)
//
//    def rbegin(self):
//        return _pythia8.MapIntInt_rbegin(self)
//
//    def rend(self):
//        return _pythia8.MapIntInt_rend(self)
//
//    def clear(self):
//        return _pythia8.MapIntInt_clear(self)
//
//    def get_allocator(self):
//        return _pythia8.MapIntInt_get_allocator(self)
//
//    def count(self, x):
//        return _pythia8.MapIntInt_count(self, x)
//
//    def erase(self, *args):
//        return _pythia8.MapIntInt_erase(self, *args)
//
//    def find(self, x):
//        return _pythia8.MapIntInt_find(self, x)
//
//    def lower_bound(self, x):
//        return _pythia8.MapIntInt_lower_bound(self, x)
//
//    def upper_bound(self, x):
//        return _pythia8.MapIntInt_upper_bound(self, x)
//    __swig_destroy__ = _pythia8.delete_MapIntInt
//    __del__ = lambda self: None
//MapIntInt_swigregister = _pythia8.MapIntInt_swigregister
//MapIntInt_swigregister(MapIntInt)
//
//class MapStringString(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, MapStringString, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, MapStringString, name)
//    __repr__ = _swig_repr
//
//    def iterator(self):
//        return _pythia8.MapStringString_iterator(self)
//    def __iter__(self):
//        return self.iterator()
//
//    def __nonzero__(self):
//        return _pythia8.MapStringString___nonzero__(self)
//
//    def __bool__(self):
//        return _pythia8.MapStringString___bool__(self)
//
//    def __len__(self):
//        return _pythia8.MapStringString___len__(self)
//    def __iter__(self):
//        return self.key_iterator()
//    def iterkeys(self):
//        return self.key_iterator()
//    def itervalues(self):
//        return self.value_iterator()
//    def iteritems(self):
//        return self.iterator()
//
//    def __getitem__(self, key):
//        return _pythia8.MapStringString___getitem__(self, key)
//
//    def __delitem__(self, key):
//        return _pythia8.MapStringString___delitem__(self, key)
//
//    def has_key(self, key):
//        return _pythia8.MapStringString_has_key(self, key)
//
//    def keys(self):
//        return _pythia8.MapStringString_keys(self)
//
//    def values(self):
//        return _pythia8.MapStringString_values(self)
//
//    def items(self):
//        return _pythia8.MapStringString_items(self)
//
//    def __contains__(self, key):
//        return _pythia8.MapStringString___contains__(self, key)
//
//    def key_iterator(self):
//        return _pythia8.MapStringString_key_iterator(self)
//
//    def value_iterator(self):
//        return _pythia8.MapStringString_value_iterator(self)
//
//    def __setitem__(self, *args):
//        return _pythia8.MapStringString___setitem__(self, *args)
//
//    def asdict(self):
//        return _pythia8.MapStringString_asdict(self)
//
//    def __init__(self, *args):
//        this = _pythia8.new_MapStringString(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def empty(self):
//        return _pythia8.MapStringString_empty(self)
//
//    def size(self):
//        return _pythia8.MapStringString_size(self)
//
//    def swap(self, v):
//        return _pythia8.MapStringString_swap(self, v)
//
//    def begin(self):
//        return _pythia8.MapStringString_begin(self)
//
//    def end(self):
//        return _pythia8.MapStringString_end(self)
//
//    def rbegin(self):
//        return _pythia8.MapStringString_rbegin(self)
//
//    def rend(self):
//        return _pythia8.MapStringString_rend(self)
//
//    def clear(self):
//        return _pythia8.MapStringString_clear(self)
//
//    def get_allocator(self):
//        return _pythia8.MapStringString_get_allocator(self)
//
//    def count(self, x):
//        return _pythia8.MapStringString_count(self, x)
//
//    def erase(self, *args):
//        return _pythia8.MapStringString_erase(self, *args)
//
//    def find(self, x):
//        return _pythia8.MapStringString_find(self, x)
//
//    def lower_bound(self, x):
//        return _pythia8.MapStringString_lower_bound(self, x)
//
//    def upper_bound(self, x):
//        return _pythia8.MapStringString_upper_bound(self, x)
//    __swig_destroy__ = _pythia8.delete_MapStringString
//    __del__ = lambda self: None
//MapStringString_swigregister = _pythia8.MapStringString_swigregister
//MapStringString_swigregister(MapStringString)
//
//class MapDoublePairIntInt(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, MapDoublePairIntInt, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, MapDoublePairIntInt, name)
//    __repr__ = _swig_repr
//
//    def iterator(self):
//        return _pythia8.MapDoublePairIntInt_iterator(self)
//    def __iter__(self):
//        return self.iterator()
//
//    def __nonzero__(self):
//        return _pythia8.MapDoublePairIntInt___nonzero__(self)
//
//    def __bool__(self):
//        return _pythia8.MapDoublePairIntInt___bool__(self)
//
//    def __len__(self):
//        return _pythia8.MapDoublePairIntInt___len__(self)
//    def __iter__(self):
//        return self.key_iterator()
//    def iterkeys(self):
//        return self.key_iterator()
//    def itervalues(self):
//        return self.value_iterator()
//    def iteritems(self):
//        return self.iterator()
//
//    def __getitem__(self, key):
//        return _pythia8.MapDoublePairIntInt___getitem__(self, key)
//
//    def __delitem__(self, key):
//        return _pythia8.MapDoublePairIntInt___delitem__(self, key)
//
//    def has_key(self, key):
//        return _pythia8.MapDoublePairIntInt_has_key(self, key)
//
//    def keys(self):
//        return _pythia8.MapDoublePairIntInt_keys(self)
//
//    def values(self):
//        return _pythia8.MapDoublePairIntInt_values(self)
//
//    def items(self):
//        return _pythia8.MapDoublePairIntInt_items(self)
//
//    def __contains__(self, key):
//        return _pythia8.MapDoublePairIntInt___contains__(self, key)
//
//    def key_iterator(self):
//        return _pythia8.MapDoublePairIntInt_key_iterator(self)
//
//    def value_iterator(self):
//        return _pythia8.MapDoublePairIntInt_value_iterator(self)
//
//    def __setitem__(self, *args):
//        return _pythia8.MapDoublePairIntInt___setitem__(self, *args)
//
//    def asdict(self):
//        return _pythia8.MapDoublePairIntInt_asdict(self)
//
//    def __init__(self, *args):
//        this = _pythia8.new_MapDoublePairIntInt(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def empty(self):
//        return _pythia8.MapDoublePairIntInt_empty(self)
//
//    def size(self):
//        return _pythia8.MapDoublePairIntInt_size(self)
//
//    def swap(self, v):
//        return _pythia8.MapDoublePairIntInt_swap(self, v)
//
//    def begin(self):
//        return _pythia8.MapDoublePairIntInt_begin(self)
//
//    def end(self):
//        return _pythia8.MapDoublePairIntInt_end(self)
//
//    def rbegin(self):
//        return _pythia8.MapDoublePairIntInt_rbegin(self)
//
//    def rend(self):
//        return _pythia8.MapDoublePairIntInt_rend(self)
//
//    def clear(self):
//        return _pythia8.MapDoublePairIntInt_clear(self)
//
//    def get_allocator(self):
//        return _pythia8.MapDoublePairIntInt_get_allocator(self)
//
//    def count(self, x):
//        return _pythia8.MapDoublePairIntInt_count(self, x)
//
//    def erase(self, *args):
//        return _pythia8.MapDoublePairIntInt_erase(self, *args)
//
//    def find(self, x):
//        return _pythia8.MapDoublePairIntInt_find(self, x)
//
//    def lower_bound(self, x):
//        return _pythia8.MapDoublePairIntInt_lower_bound(self, x)
//
//    def upper_bound(self, x):
//        return _pythia8.MapDoublePairIntInt_upper_bound(self, x)
//    __swig_destroy__ = _pythia8.delete_MapDoublePairIntInt
//    __del__ = lambda self: None
//MapDoublePairIntInt_swigregister = _pythia8.MapDoublePairIntInt_swigregister
//MapDoublePairIntInt_swigregister(MapDoublePairIntInt)
//
//class VectorBool(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, VectorBool, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, VectorBool, name)
//    __repr__ = _swig_repr
//
//    def iterator(self):
//        return _pythia8.VectorBool_iterator(self)
//    def __iter__(self):
//        return self.iterator()
//
//    def __nonzero__(self):
//        return _pythia8.VectorBool___nonzero__(self)
//
//    def __bool__(self):
//        return _pythia8.VectorBool___bool__(self)
//
//    def __len__(self):
//        return _pythia8.VectorBool___len__(self)
//
//    def __getslice__(self, i, j):
//        return _pythia8.VectorBool___getslice__(self, i, j)
//
//    def __setslice__(self, *args):
//        return _pythia8.VectorBool___setslice__(self, *args)
//
//    def __delslice__(self, i, j):
//        return _pythia8.VectorBool___delslice__(self, i, j)
//
//    def __delitem__(self, *args):
//        return _pythia8.VectorBool___delitem__(self, *args)
//
//    def __getitem__(self, *args):
//        return _pythia8.VectorBool___getitem__(self, *args)
//
//    def __setitem__(self, *args):
//        return _pythia8.VectorBool___setitem__(self, *args)
//
//    def pop(self):
//        return _pythia8.VectorBool_pop(self)
//
//    def append(self, x):
//        return _pythia8.VectorBool_append(self, x)
//
//    def empty(self):
//        return _pythia8.VectorBool_empty(self)
//
//    def size(self):
//        return _pythia8.VectorBool_size(self)
//
//    def swap(self, v):
//        return _pythia8.VectorBool_swap(self, v)
//
//    def begin(self):
//        return _pythia8.VectorBool_begin(self)
//
//    def end(self):
//        return _pythia8.VectorBool_end(self)
//
//    def rbegin(self):
//        return _pythia8.VectorBool_rbegin(self)
//
//    def rend(self):
//        return _pythia8.VectorBool_rend(self)
//
//    def clear(self):
//        return _pythia8.VectorBool_clear(self)
//
//    def get_allocator(self):
//        return _pythia8.VectorBool_get_allocator(self)
//
//    def pop_back(self):
//        return _pythia8.VectorBool_pop_back(self)
//
//    def erase(self, *args):
//        return _pythia8.VectorBool_erase(self, *args)
//
//    def __init__(self, *args):
//        this = _pythia8.new_VectorBool(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def push_back(self, x):
//        return _pythia8.VectorBool_push_back(self, x)
//
//    def front(self):
//        return _pythia8.VectorBool_front(self)
//
//    def back(self):
//        return _pythia8.VectorBool_back(self)
//
//    def assign(self, n, x):
//        return _pythia8.VectorBool_assign(self, n, x)
//
//    def resize(self, *args):
//        return _pythia8.VectorBool_resize(self, *args)
//
//    def insert(self, *args):
//        return _pythia8.VectorBool_insert(self, *args)
//
//    def reserve(self, n):
//        return _pythia8.VectorBool_reserve(self, n)
//
//    def capacity(self):
//        return _pythia8.VectorBool_capacity(self)
//    __swig_destroy__ = _pythia8.delete_VectorBool
//    __del__ = lambda self: None
//VectorBool_swigregister = _pythia8.VectorBool_swigregister
//VectorBool_swigregister(VectorBool)
//
//class VectorComplex(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, VectorComplex, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, VectorComplex, name)
//    __repr__ = _swig_repr
//
//    def iterator(self):
//        return _pythia8.VectorComplex_iterator(self)
//    def __iter__(self):
//        return self.iterator()
//
//    def __nonzero__(self):
//        return _pythia8.VectorComplex___nonzero__(self)
//
//    def __bool__(self):
//        return _pythia8.VectorComplex___bool__(self)
//
//    def __len__(self):
//        return _pythia8.VectorComplex___len__(self)
//
//    def __getslice__(self, i, j):
//        return _pythia8.VectorComplex___getslice__(self, i, j)
//
//    def __setslice__(self, *args):
//        return _pythia8.VectorComplex___setslice__(self, *args)
//
//    def __delslice__(self, i, j):
//        return _pythia8.VectorComplex___delslice__(self, i, j)
//
//    def __delitem__(self, *args):
//        return _pythia8.VectorComplex___delitem__(self, *args)
//
//    def __getitem__(self, *args):
//        return _pythia8.VectorComplex___getitem__(self, *args)
//
//    def __setitem__(self, *args):
//        return _pythia8.VectorComplex___setitem__(self, *args)
//
//    def pop(self):
//        return _pythia8.VectorComplex_pop(self)
//
//    def append(self, x):
//        return _pythia8.VectorComplex_append(self, x)
//
//    def empty(self):
//        return _pythia8.VectorComplex_empty(self)
//
//    def size(self):
//        return _pythia8.VectorComplex_size(self)
//
//    def swap(self, v):
//        return _pythia8.VectorComplex_swap(self, v)
//
//    def begin(self):
//        return _pythia8.VectorComplex_begin(self)
//
//    def end(self):
//        return _pythia8.VectorComplex_end(self)
//
//    def rbegin(self):
//        return _pythia8.VectorComplex_rbegin(self)
//
//    def rend(self):
//        return _pythia8.VectorComplex_rend(self)
//
//    def clear(self):
//        return _pythia8.VectorComplex_clear(self)
//
//    def get_allocator(self):
//        return _pythia8.VectorComplex_get_allocator(self)
//
//    def pop_back(self):
//        return _pythia8.VectorComplex_pop_back(self)
//
//    def erase(self, *args):
//        return _pythia8.VectorComplex_erase(self, *args)
//
//    def __init__(self, *args):
//        this = _pythia8.new_VectorComplex(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def push_back(self, x):
//        return _pythia8.VectorComplex_push_back(self, x)
//
//    def front(self):
//        return _pythia8.VectorComplex_front(self)
//
//    def back(self):
//        return _pythia8.VectorComplex_back(self)
//
//    def assign(self, n, x):
//        return _pythia8.VectorComplex_assign(self, n, x)
//
//    def resize(self, *args):
//        return _pythia8.VectorComplex_resize(self, *args)
//
//    def insert(self, *args):
//        return _pythia8.VectorComplex_insert(self, *args)
//
//    def reserve(self, n):
//        return _pythia8.VectorComplex_reserve(self, n)
//
//    def capacity(self):
//        return _pythia8.VectorComplex_capacity(self)
//    __swig_destroy__ = _pythia8.delete_VectorComplex
//    __del__ = lambda self: None
//VectorComplex_swigregister = _pythia8.VectorComplex_swigregister
//VectorComplex_swigregister(VectorComplex)
//
//class VectorDouble(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, VectorDouble, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, VectorDouble, name)
//    __repr__ = _swig_repr
//
//    def iterator(self):
//        return _pythia8.VectorDouble_iterator(self)
//    def __iter__(self):
//        return self.iterator()
//
//    def __nonzero__(self):
//        return _pythia8.VectorDouble___nonzero__(self)
//
//    def __bool__(self):
//        return _pythia8.VectorDouble___bool__(self)
//
//    def __len__(self):
//        return _pythia8.VectorDouble___len__(self)
//
//    def __getslice__(self, i, j):
//        return _pythia8.VectorDouble___getslice__(self, i, j)
//
//    def __setslice__(self, *args):
//        return _pythia8.VectorDouble___setslice__(self, *args)
//
//    def __delslice__(self, i, j):
//        return _pythia8.VectorDouble___delslice__(self, i, j)
//
//    def __delitem__(self, *args):
//        return _pythia8.VectorDouble___delitem__(self, *args)
//
//    def __getitem__(self, *args):
//        return _pythia8.VectorDouble___getitem__(self, *args)
//
//    def __setitem__(self, *args):
//        return _pythia8.VectorDouble___setitem__(self, *args)
//
//    def pop(self):
//        return _pythia8.VectorDouble_pop(self)
//
//    def append(self, x):
//        return _pythia8.VectorDouble_append(self, x)
//
//    def empty(self):
//        return _pythia8.VectorDouble_empty(self)
//
//    def size(self):
//        return _pythia8.VectorDouble_size(self)
//
//    def swap(self, v):
//        return _pythia8.VectorDouble_swap(self, v)
//
//    def begin(self):
//        return _pythia8.VectorDouble_begin(self)
//
//    def end(self):
//        return _pythia8.VectorDouble_end(self)
//
//    def rbegin(self):
//        return _pythia8.VectorDouble_rbegin(self)
//
//    def rend(self):
//        return _pythia8.VectorDouble_rend(self)
//
//    def clear(self):
//        return _pythia8.VectorDouble_clear(self)
//
//    def get_allocator(self):
//        return _pythia8.VectorDouble_get_allocator(self)
//
//    def pop_back(self):
//        return _pythia8.VectorDouble_pop_back(self)
//
//    def erase(self, *args):
//        return _pythia8.VectorDouble_erase(self, *args)
//
//    def __init__(self, *args):
//        this = _pythia8.new_VectorDouble(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def push_back(self, x):
//        return _pythia8.VectorDouble_push_back(self, x)
//
//    def front(self):
//        return _pythia8.VectorDouble_front(self)
//
//    def back(self):
//        return _pythia8.VectorDouble_back(self)
//
//    def assign(self, n, x):
//        return _pythia8.VectorDouble_assign(self, n, x)
//
//    def resize(self, *args):
//        return _pythia8.VectorDouble_resize(self, *args)
//
//    def insert(self, *args):
//        return _pythia8.VectorDouble_insert(self, *args)
//
//    def reserve(self, n):
//        return _pythia8.VectorDouble_reserve(self, n)
//
//    def capacity(self):
//        return _pythia8.VectorDouble_capacity(self)
//    __swig_destroy__ = _pythia8.delete_VectorDouble
//    __del__ = lambda self: None
//VectorDouble_swigregister = _pythia8.VectorDouble_swigregister
//VectorDouble_swigregister(VectorDouble)
//
//class VectorInt(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, VectorInt, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, VectorInt, name)
//    __repr__ = _swig_repr
//
//    def iterator(self):
//        return _pythia8.VectorInt_iterator(self)
//    def __iter__(self):
//        return self.iterator()
//
//    def __nonzero__(self):
//        return _pythia8.VectorInt___nonzero__(self)
//
//    def __bool__(self):
//        return _pythia8.VectorInt___bool__(self)
//
//    def __len__(self):
//        return _pythia8.VectorInt___len__(self)
//
//    def __getslice__(self, i, j):
//        return _pythia8.VectorInt___getslice__(self, i, j)
//
//    def __setslice__(self, *args):
//        return _pythia8.VectorInt___setslice__(self, *args)
//
//    def __delslice__(self, i, j):
//        return _pythia8.VectorInt___delslice__(self, i, j)
//
//    def __delitem__(self, *args):
//        return _pythia8.VectorInt___delitem__(self, *args)
//
//    def __getitem__(self, *args):
//        return _pythia8.VectorInt___getitem__(self, *args)
//
//    def __setitem__(self, *args):
//        return _pythia8.VectorInt___setitem__(self, *args)
//
//    def pop(self):
//        return _pythia8.VectorInt_pop(self)
//
//    def append(self, x):
//        return _pythia8.VectorInt_append(self, x)
//
//    def empty(self):
//        return _pythia8.VectorInt_empty(self)
//
//    def size(self):
//        return _pythia8.VectorInt_size(self)
//
//    def swap(self, v):
//        return _pythia8.VectorInt_swap(self, v)
//
//    def begin(self):
//        return _pythia8.VectorInt_begin(self)
//
//    def end(self):
//        return _pythia8.VectorInt_end(self)
//
//    def rbegin(self):
//        return _pythia8.VectorInt_rbegin(self)
//
//    def rend(self):
//        return _pythia8.VectorInt_rend(self)
//
//    def clear(self):
//        return _pythia8.VectorInt_clear(self)
//
//    def get_allocator(self):
//        return _pythia8.VectorInt_get_allocator(self)
//
//    def pop_back(self):
//        return _pythia8.VectorInt_pop_back(self)
//
//    def erase(self, *args):
//        return _pythia8.VectorInt_erase(self, *args)
//
//    def __init__(self, *args):
//        this = _pythia8.new_VectorInt(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def push_back(self, x):
//        return _pythia8.VectorInt_push_back(self, x)
//
//    def front(self):
//        return _pythia8.VectorInt_front(self)
//
//    def back(self):
//        return _pythia8.VectorInt_back(self)
//
//    def assign(self, n, x):
//        return _pythia8.VectorInt_assign(self, n, x)
//
//    def resize(self, *args):
//        return _pythia8.VectorInt_resize(self, *args)
//
//    def insert(self, *args):
//        return _pythia8.VectorInt_insert(self, *args)
//
//    def reserve(self, n):
//        return _pythia8.VectorInt_reserve(self, n)
//
//    def capacity(self):
//        return _pythia8.VectorInt_capacity(self)
//    __swig_destroy__ = _pythia8.delete_VectorInt
//    __del__ = lambda self: None
//VectorInt_swigregister = _pythia8.VectorInt_swigregister
//VectorInt_swigregister(VectorInt)
//
//class VectorString(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, VectorString, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, VectorString, name)
//    __repr__ = _swig_repr
//
//    def iterator(self):
//        return _pythia8.VectorString_iterator(self)
//    def __iter__(self):
//        return self.iterator()
//
//    def __nonzero__(self):
//        return _pythia8.VectorString___nonzero__(self)
//
//    def __bool__(self):
//        return _pythia8.VectorString___bool__(self)
//
//    def __len__(self):
//        return _pythia8.VectorString___len__(self)
//
//    def __getslice__(self, i, j):
//        return _pythia8.VectorString___getslice__(self, i, j)
//
//    def __setslice__(self, *args):
//        return _pythia8.VectorString___setslice__(self, *args)
//
//    def __delslice__(self, i, j):
//        return _pythia8.VectorString___delslice__(self, i, j)
//
//    def __delitem__(self, *args):
//        return _pythia8.VectorString___delitem__(self, *args)
//
//    def __getitem__(self, *args):
//        return _pythia8.VectorString___getitem__(self, *args)
//
//    def __setitem__(self, *args):
//        return _pythia8.VectorString___setitem__(self, *args)
//
//    def pop(self):
//        return _pythia8.VectorString_pop(self)
//
//    def append(self, x):
//        return _pythia8.VectorString_append(self, x)
//
//    def empty(self):
//        return _pythia8.VectorString_empty(self)
//
//    def size(self):
//        return _pythia8.VectorString_size(self)
//
//    def swap(self, v):
//        return _pythia8.VectorString_swap(self, v)
//
//    def begin(self):
//        return _pythia8.VectorString_begin(self)
//
//    def end(self):
//        return _pythia8.VectorString_end(self)
//
//    def rbegin(self):
//        return _pythia8.VectorString_rbegin(self)
//
//    def rend(self):
//        return _pythia8.VectorString_rend(self)
//
//    def clear(self):
//        return _pythia8.VectorString_clear(self)
//
//    def get_allocator(self):
//        return _pythia8.VectorString_get_allocator(self)
//
//    def pop_back(self):
//        return _pythia8.VectorString_pop_back(self)
//
//    def erase(self, *args):
//        return _pythia8.VectorString_erase(self, *args)
//
//    def __init__(self, *args):
//        this = _pythia8.new_VectorString(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def push_back(self, x):
//        return _pythia8.VectorString_push_back(self, x)
//
//    def front(self):
//        return _pythia8.VectorString_front(self)
//
//    def back(self):
//        return _pythia8.VectorString_back(self)
//
//    def assign(self, n, x):
//        return _pythia8.VectorString_assign(self, n, x)
//
//    def resize(self, *args):
//        return _pythia8.VectorString_resize(self, *args)
//
//    def insert(self, *args):
//        return _pythia8.VectorString_insert(self, *args)
//
//    def reserve(self, n):
//        return _pythia8.VectorString_reserve(self, n)
//
//    def capacity(self):
//        return _pythia8.VectorString_capacity(self)
//    __swig_destroy__ = _pythia8.delete_VectorString
//    __del__ = lambda self: None
//VectorString_swigregister = _pythia8.VectorString_swigregister
//VectorString_swigregister(VectorString)
//
//class VectorPairIntInt(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, VectorPairIntInt, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, VectorPairIntInt, name)
//    __repr__ = _swig_repr
//
//    def iterator(self):
//        return _pythia8.VectorPairIntInt_iterator(self)
//    def __iter__(self):
//        return self.iterator()
//
//    def __nonzero__(self):
//        return _pythia8.VectorPairIntInt___nonzero__(self)
//
//    def __bool__(self):
//        return _pythia8.VectorPairIntInt___bool__(self)
//
//    def __len__(self):
//        return _pythia8.VectorPairIntInt___len__(self)
//
//    def __getslice__(self, i, j):
//        return _pythia8.VectorPairIntInt___getslice__(self, i, j)
//
//    def __setslice__(self, *args):
//        return _pythia8.VectorPairIntInt___setslice__(self, *args)
//
//    def __delslice__(self, i, j):
//        return _pythia8.VectorPairIntInt___delslice__(self, i, j)
//
//    def __delitem__(self, *args):
//        return _pythia8.VectorPairIntInt___delitem__(self, *args)
//
//    def __getitem__(self, *args):
//        return _pythia8.VectorPairIntInt___getitem__(self, *args)
//
//    def __setitem__(self, *args):
//        return _pythia8.VectorPairIntInt___setitem__(self, *args)
//
//    def pop(self):
//        return _pythia8.VectorPairIntInt_pop(self)
//
//    def append(self, x):
//        return _pythia8.VectorPairIntInt_append(self, x)
//
//    def empty(self):
//        return _pythia8.VectorPairIntInt_empty(self)
//
//    def size(self):
//        return _pythia8.VectorPairIntInt_size(self)
//
//    def swap(self, v):
//        return _pythia8.VectorPairIntInt_swap(self, v)
//
//    def begin(self):
//        return _pythia8.VectorPairIntInt_begin(self)
//
//    def end(self):
//        return _pythia8.VectorPairIntInt_end(self)
//
//    def rbegin(self):
//        return _pythia8.VectorPairIntInt_rbegin(self)
//
//    def rend(self):
//        return _pythia8.VectorPairIntInt_rend(self)
//
//    def clear(self):
//        return _pythia8.VectorPairIntInt_clear(self)
//
//    def get_allocator(self):
//        return _pythia8.VectorPairIntInt_get_allocator(self)
//
//    def pop_back(self):
//        return _pythia8.VectorPairIntInt_pop_back(self)
//
//    def erase(self, *args):
//        return _pythia8.VectorPairIntInt_erase(self, *args)
//
//    def __init__(self, *args):
//        this = _pythia8.new_VectorPairIntInt(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def push_back(self, x):
//        return _pythia8.VectorPairIntInt_push_back(self, x)
//
//    def front(self):
//        return _pythia8.VectorPairIntInt_front(self)
//
//    def back(self):
//        return _pythia8.VectorPairIntInt_back(self)
//
//    def assign(self, n, x):
//        return _pythia8.VectorPairIntInt_assign(self, n, x)
//
//    def resize(self, *args):
//        return _pythia8.VectorPairIntInt_resize(self, *args)
//
//    def insert(self, *args):
//        return _pythia8.VectorPairIntInt_insert(self, *args)
//
//    def reserve(self, n):
//        return _pythia8.VectorPairIntInt_reserve(self, n)
//
//    def capacity(self):
//        return _pythia8.VectorPairIntInt_capacity(self)
//    __swig_destroy__ = _pythia8.delete_VectorPairIntInt
//    __del__ = lambda self: None
//VectorPairIntInt_swigregister = _pythia8.VectorPairIntInt_swigregister
//VectorPairIntInt_swigregister(VectorPairIntInt)
//
//class VectorVectorInt(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, VectorVectorInt, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, VectorVectorInt, name)
//    __repr__ = _swig_repr
//
//    def iterator(self):
//        return _pythia8.VectorVectorInt_iterator(self)
//    def __iter__(self):
//        return self.iterator()
//
//    def __nonzero__(self):
//        return _pythia8.VectorVectorInt___nonzero__(self)
//
//    def __bool__(self):
//        return _pythia8.VectorVectorInt___bool__(self)
//
//    def __len__(self):
//        return _pythia8.VectorVectorInt___len__(self)
//
//    def __getslice__(self, i, j):
//        return _pythia8.VectorVectorInt___getslice__(self, i, j)
//
//    def __setslice__(self, *args):
//        return _pythia8.VectorVectorInt___setslice__(self, *args)
//
//    def __delslice__(self, i, j):
//        return _pythia8.VectorVectorInt___delslice__(self, i, j)
//
//    def __delitem__(self, *args):
//        return _pythia8.VectorVectorInt___delitem__(self, *args)
//
//    def __getitem__(self, *args):
//        return _pythia8.VectorVectorInt___getitem__(self, *args)
//
//    def __setitem__(self, *args):
//        return _pythia8.VectorVectorInt___setitem__(self, *args)
//
//    def pop(self):
//        return _pythia8.VectorVectorInt_pop(self)
//
//    def append(self, x):
//        return _pythia8.VectorVectorInt_append(self, x)
//
//    def empty(self):
//        return _pythia8.VectorVectorInt_empty(self)
//
//    def size(self):
//        return _pythia8.VectorVectorInt_size(self)
//
//    def swap(self, v):
//        return _pythia8.VectorVectorInt_swap(self, v)
//
//    def begin(self):
//        return _pythia8.VectorVectorInt_begin(self)
//
//    def end(self):
//        return _pythia8.VectorVectorInt_end(self)
//
//    def rbegin(self):
//        return _pythia8.VectorVectorInt_rbegin(self)
//
//    def rend(self):
//        return _pythia8.VectorVectorInt_rend(self)
//
//    def clear(self):
//        return _pythia8.VectorVectorInt_clear(self)
//
//    def get_allocator(self):
//        return _pythia8.VectorVectorInt_get_allocator(self)
//
//    def pop_back(self):
//        return _pythia8.VectorVectorInt_pop_back(self)
//
//    def erase(self, *args):
//        return _pythia8.VectorVectorInt_erase(self, *args)
//
//    def __init__(self, *args):
//        this = _pythia8.new_VectorVectorInt(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def push_back(self, x):
//        return _pythia8.VectorVectorInt_push_back(self, x)
//
//    def front(self):
//        return _pythia8.VectorVectorInt_front(self)
//
//    def back(self):
//        return _pythia8.VectorVectorInt_back(self)
//
//    def assign(self, n, x):
//        return _pythia8.VectorVectorInt_assign(self, n, x)
//
//    def resize(self, *args):
//        return _pythia8.VectorVectorInt_resize(self, *args)
//
//    def insert(self, *args):
//        return _pythia8.VectorVectorInt_insert(self, *args)
//
//    def reserve(self, n):
//        return _pythia8.VectorVectorInt_reserve(self, n)
//
//    def capacity(self):
//        return _pythia8.VectorVectorInt_capacity(self)
//    __swig_destroy__ = _pythia8.delete_VectorVectorInt
//    __del__ = lambda self: None
//VectorVectorInt_swigregister = _pythia8.VectorVectorInt_swigregister
//VectorVectorInt_swigregister(VectorVectorInt)
//
//class VectorVectorComplex(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, VectorVectorComplex, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, VectorVectorComplex, name)
//    __repr__ = _swig_repr
//
//    def iterator(self):
//        return _pythia8.VectorVectorComplex_iterator(self)
//    def __iter__(self):
//        return self.iterator()
//
//    def __nonzero__(self):
//        return _pythia8.VectorVectorComplex___nonzero__(self)
//
//    def __bool__(self):
//        return _pythia8.VectorVectorComplex___bool__(self)
//
//    def __len__(self):
//        return _pythia8.VectorVectorComplex___len__(self)
//
//    def __getslice__(self, i, j):
//        return _pythia8.VectorVectorComplex___getslice__(self, i, j)
//
//    def __setslice__(self, *args):
//        return _pythia8.VectorVectorComplex___setslice__(self, *args)
//
//    def __delslice__(self, i, j):
//        return _pythia8.VectorVectorComplex___delslice__(self, i, j)
//
//    def __delitem__(self, *args):
//        return _pythia8.VectorVectorComplex___delitem__(self, *args)
//
//    def __getitem__(self, *args):
//        return _pythia8.VectorVectorComplex___getitem__(self, *args)
//
//    def __setitem__(self, *args):
//        return _pythia8.VectorVectorComplex___setitem__(self, *args)
//
//    def pop(self):
//        return _pythia8.VectorVectorComplex_pop(self)
//
//    def append(self, x):
//        return _pythia8.VectorVectorComplex_append(self, x)
//
//    def empty(self):
//        return _pythia8.VectorVectorComplex_empty(self)
//
//    def size(self):
//        return _pythia8.VectorVectorComplex_size(self)
//
//    def swap(self, v):
//        return _pythia8.VectorVectorComplex_swap(self, v)
//
//    def begin(self):
//        return _pythia8.VectorVectorComplex_begin(self)
//
//    def end(self):
//        return _pythia8.VectorVectorComplex_end(self)
//
//    def rbegin(self):
//        return _pythia8.VectorVectorComplex_rbegin(self)
//
//    def rend(self):
//        return _pythia8.VectorVectorComplex_rend(self)
//
//    def clear(self):
//        return _pythia8.VectorVectorComplex_clear(self)
//
//    def get_allocator(self):
//        return _pythia8.VectorVectorComplex_get_allocator(self)
//
//    def pop_back(self):
//        return _pythia8.VectorVectorComplex_pop_back(self)
//
//    def erase(self, *args):
//        return _pythia8.VectorVectorComplex_erase(self, *args)
//
//    def __init__(self, *args):
//        this = _pythia8.new_VectorVectorComplex(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def push_back(self, x):
//        return _pythia8.VectorVectorComplex_push_back(self, x)
//
//    def front(self):
//        return _pythia8.VectorVectorComplex_front(self)
//
//    def back(self):
//        return _pythia8.VectorVectorComplex_back(self)
//
//    def assign(self, n, x):
//        return _pythia8.VectorVectorComplex_assign(self, n, x)
//
//    def resize(self, *args):
//        return _pythia8.VectorVectorComplex_resize(self, *args)
//
//    def insert(self, *args):
//        return _pythia8.VectorVectorComplex_insert(self, *args)
//
//    def reserve(self, n):
//        return _pythia8.VectorVectorComplex_reserve(self, n)
//
//    def capacity(self):
//        return _pythia8.VectorVectorComplex_capacity(self)
//    __swig_destroy__ = _pythia8.delete_VectorVectorComplex
//    __del__ = lambda self: None
//VectorVectorComplex_swigregister = _pythia8.VectorVectorComplex_swigregister
//VectorVectorComplex_swigregister(VectorVectorComplex)
//
//class RndmEngine(_object):
//    """
//RndmEngine is the base class for external random number generators.
//There is only one pure virtual method, that should do the generation.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, RndmEngine, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, RndmEngine, name)
//    __repr__ = _swig_repr
//    __swig_destroy__ = _pythia8.delete_RndmEngine
//    __del__ = lambda self: None
//
//    def flat(self):
//        """
//A pure virtual method, wherein the derived class method
//generates a random number uniformly distributed between 1 and 1.
//"""
//        return _pythia8.RndmEngine_flat(self)
//
//    def __init__(self):
//        if self.__class__ == RndmEngine:
//            _self = None
//        else:
//            _self = self
//        this = _pythia8.new_RndmEngine(_self, )
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    def __disown__(self):
//        self.this.disown()
//        _pythia8.disown_RndmEngine(self)
//        return weakref_proxy(self)
//RndmEngine_swigregister = _pythia8.RndmEngine_swigregister
//RndmEngine_swigregister(RndmEngine)
//
//class Rndm(_object):
//    """
//Rndm class.
//This class handles random number generation according to the
//Marsaglia-Zaman-Tsang algorithm.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Rndm, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, Rndm, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_Rndm(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def rndmEnginePtr(self, rndmEngPtrIn):
//        """
//Possibility to pass in pointer for external random number generation.
//"""
//        return _pythia8.Rndm_rndmEnginePtr(self, rndmEngPtrIn)
//
//    def init(self, seedIn=0):
//        """
//Initialize, normally at construction or in first call.
//"""
//        return _pythia8.Rndm_init(self, seedIn)
//
//    def flat(self):
//        """
//"""
//        return _pythia8.Rndm_flat(self)
//
//    def exp(self):
//        """
//Generate random numbers according to exp(-x).
//"""
//        return _pythia8.Rndm_exp(self)
//
//    def xexp(self):
//        """
//Generate random numbers according to x * exp(-x).
//"""
//        return _pythia8.Rndm_xexp(self)
//
//    def gauss(self):
//        """
//Generate random numbers according to exp(-x^2/2).
//"""
//        return _pythia8.Rndm_gauss(self)
//
//    def gauss2(self):
//        """
//Generate two random numbers according to exp(-x^2/2-y^2/2).
//"""
//        return _pythia8.Rndm_gauss2(self)
//
//    def pick(self, prob):
//        """
//Pick one option among  vector of (positive) probabilities.
//"""
//        return _pythia8.Rndm_pick(self, prob)
//
//    def dumpState(self, fileName):
//        """
//Save or read current state to or from a binary file.
//"""
//        return _pythia8.Rndm_dumpState(self, fileName)
//
//    def readState(self, fileName):
//        """
//"""
//        return _pythia8.Rndm_readState(self, fileName)
//    __swig_destroy__ = _pythia8.delete_Rndm
//    __del__ = lambda self: None
//Rndm_swigregister = _pythia8.Rndm_swigregister
//Rndm_swigregister(Rndm)
//
//class Vec4(_object):
//    """
//Vec4 class.
//This class implements four-vectors, in energy-momentum space.
//(But can equally well be used to hold space-time four-vectors.)
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Vec4, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, Vec4, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_Vec4(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def reset(self):
//        """
//Member functions for input.
//"""
//        return _pythia8.Vec4_reset(self)
//
//    def p(self, *args):
//        """
//"""
//        return _pythia8.Vec4_p(self, *args)
//
//    def px(self, *args):
//        """
//Member functions for output.
//"""
//        return _pythia8.Vec4_px(self, *args)
//
//    def py(self, *args):
//        """
//"""
//        return _pythia8.Vec4_py(self, *args)
//
//    def pz(self, *args):
//        """
//"""
//        return _pythia8.Vec4_pz(self, *args)
//
//    def e(self, *args):
//        """
//"""
//        return _pythia8.Vec4_e(self, *args)
//
//    def mCalc(self):
//        """
//"""
//        return _pythia8.Vec4_mCalc(self)
//
//    def m2Calc(self):
//        """
//"""
//        return _pythia8.Vec4_m2Calc(self)
//
//    def pT(self):
//        """
//"""
//        return _pythia8.Vec4_pT(self)
//
//    def pT2(self):
//        """
//"""
//        return _pythia8.Vec4_pT2(self)
//
//    def pAbs(self):
//        """
//"""
//        return _pythia8.Vec4_pAbs(self)
//
//    def pAbs2(self):
//        """
//"""
//        return _pythia8.Vec4_pAbs2(self)
//
//    def eT(self):
//        """
//"""
//        return _pythia8.Vec4_eT(self)
//
//    def eT2(self):
//        """
//"""
//        return _pythia8.Vec4_eT2(self)
//
//    def theta(self):
//        """
//theta is polar angle between v1 and v2.
//"""
//        return _pythia8.Vec4_theta(self)
//
//    def phi(self):
//        """
//phi is azimuthal angle between v1 and v2 around n axis.
//"""
//        return _pythia8.Vec4_phi(self)
//
//    def thetaXZ(self):
//        """
//"""
//        return _pythia8.Vec4_thetaXZ(self)
//
//    def pPos(self):
//        """
//"""
//        return _pythia8.Vec4_pPos(self)
//
//    def pNeg(self):
//        """
//"""
//        return _pythia8.Vec4_pNeg(self)
//
//    def rap(self):
//        """
//"""
//        return _pythia8.Vec4_rap(self)
//
//    def eta(self):
//        """
//"""
//        return _pythia8.Vec4_eta(self)
//
//    def rescale3(self, fac):
//        """
//Member functions that perform operations.
//"""
//        return _pythia8.Vec4_rescale3(self, fac)
//
//    def rescale4(self, fac):
//        """
//"""
//        return _pythia8.Vec4_rescale4(self, fac)
//
//    def flip3(self):
//        """
//"""
//        return _pythia8.Vec4_flip3(self)
//
//    def flip4(self):
//        """
//"""
//        return _pythia8.Vec4_flip4(self)
//
//    def rot(self, thetaIn, phiIn):
//        """
//"""
//        return _pythia8.Vec4_rot(self, thetaIn, phiIn)
//
//    def rotaxis(self, *args):
//        """
//"""
//        return _pythia8.Vec4_rotaxis(self, *args)
//
//    def bst(self, *args):
//        """
//"""
//        return _pythia8.Vec4_bst(self, *args)
//
//    def bstback(self, *args):
//        """
//"""
//        return _pythia8.Vec4_bstback(self, *args)
//
//    def rotbst(self, M):
//        """
//"""
//        return _pythia8.Vec4_rotbst(self, M)
//
//    def __neg__(self):
//        return _pythia8.Vec4___neg__(self)
//
//    def __iadd__(self, v):
//        return _pythia8.Vec4___iadd__(self, v)
//
//    def __isub__(self, v):
//        return _pythia8.Vec4___isub__(self, v)
//
//    def __imul__(self, f):
//        return _pythia8.Vec4___imul__(self, f)
//
//    def __idiv__(self, f):
//        return _pythia8.Vec4___idiv__(self, f)
//
//    def __add__(self, v):
//        return _pythia8.Vec4___add__(self, v)
//
//    def __sub__(self, v):
//        return _pythia8.Vec4___sub__(self, v)
//
//    def __div__(self, f):
//        return _pythia8.Vec4___div__(self, f)
//
//    def __mul__(self, *args):
//        return _pythia8.Vec4___mul__(self, *args)
//
//    def __str__(self):
//        return _pythia8.Vec4___str__(self)
//
//    def __getitem__(self, i):
//        return _pythia8.Vec4___getitem__(self, i)
//
//    def __rmul__(self, f):
//        return _pythia8.Vec4___rmul__(self, f)
//    __swig_destroy__ = _pythia8.delete_Vec4
//    __del__ = lambda self: None
//Vec4_swigregister = _pythia8.Vec4_swigregister
//Vec4_swigregister(Vec4)
//
//
//def dot3(v1, v2):
//    return _pythia8.dot3(v1, v2)
//dot3 = _pythia8.dot3
//
//def cross3(v1, v2):
//    return _pythia8.cross3(v1, v2)
//cross3 = _pythia8.cross3
//
//def cross4(a, b, c):
//    return _pythia8.cross4(a, b, c)
//cross4 = _pythia8.cross4
//
//def theta(v1, v2):
//    return _pythia8.theta(v1, v2)
//theta = _pythia8.theta
//
//def costheta(v1, v2):
//    return _pythia8.costheta(v1, v2)
//costheta = _pythia8.costheta
//
//def phi(*args):
//    return _pythia8.phi(*args)
//phi = _pythia8.phi
//
//def cosphi(*args):
//    return _pythia8.cosphi(*args)
//cosphi = _pythia8.cosphi
//
//def RRapPhi(v1, v2):
//    return _pythia8.RRapPhi(v1, v2)
//RRapPhi = _pythia8.RRapPhi
//
//def REtaPhi(v1, v2):
//    return _pythia8.REtaPhi(v1, v2)
//REtaPhi = _pythia8.REtaPhi
//
//def pShift(p1Move, p2Move, m1New, m2New):
//    return _pythia8.pShift(p1Move, p2Move, m1New, m2New)
//pShift = _pythia8.pShift
//
//def getTwoPerpendicular(v1, v2):
//    return _pythia8.getTwoPerpendicular(v1, v2)
//getTwoPerpendicular = _pythia8.getTwoPerpendicular
//class RotBstMatrix(_object):
//    """
//RotBstMatrix class.
//This class implements 4 * 4 matrices that encode an arbitrary combination
//of rotations and boosts, that can be applied to Vec4 four-vectors.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, RotBstMatrix, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, RotBstMatrix, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_RotBstMatrix(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def rot(self, *args):
//        """
//"""
//        return _pythia8.RotBstMatrix_rot(self, *args)
//
//    def bstback(self, arg2):
//        """
//"""
//        return _pythia8.RotBstMatrix_bstback(self, arg2)
//
//    def bst(self, *args):
//        """
//"""
//        return _pythia8.RotBstMatrix_bst(self, *args)
//
//    def toCMframe(self, arg2, arg3):
//        """
//"""
//        return _pythia8.RotBstMatrix_toCMframe(self, arg2, arg3)
//
//    def fromCMframe(self, arg2, arg3):
//        """
//"""
//        return _pythia8.RotBstMatrix_fromCMframe(self, arg2, arg3)
//
//    def rotbst(self, arg2):
//        """
//"""
//        return _pythia8.RotBstMatrix_rotbst(self, arg2)
//
//    def invert(self):
//        """
//"""
//        return _pythia8.RotBstMatrix_invert(self)
//
//    def reset(self):
//        """
//"""
//        return _pythia8.RotBstMatrix_reset(self)
//
//    def value(self, i, j):
//        """
//Return value of matrix element.
//"""
//        return _pythia8.RotBstMatrix_value(self, i, j)
//
//    def deviation(self):
//        """
//Crude estimate deviation from unit matrix.
//"""
//        return _pythia8.RotBstMatrix_deviation(self)
//
//    def __str__(self):
//        return _pythia8.RotBstMatrix___str__(self)
//    __swig_destroy__ = _pythia8.delete_RotBstMatrix
//    __del__ = lambda self: None
//RotBstMatrix_swigregister = _pythia8.RotBstMatrix_swigregister
//RotBstMatrix_swigregister(RotBstMatrix)
//
//class Hist(_object):
//    """
//Hist class.
//This class handles a single histogram at a time.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Hist, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, Hist, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_Hist(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def book(self, *args):
//        """
//Book a histogram.
//"""
//        return _pythia8.Hist_book(self, *args)
//
//    def title(self, *args):
//        """
//Set title of a histogram.
//"""
//        return _pythia8.Hist_title(self, *args)
//
//    def null(self):
//        """
//Reset bin contents.
//"""
//        return _pythia8.Hist_null(self)
//
//    def fill(self, x, w=1.):
//        """
//Fill bin with weight.
//"""
//        return _pythia8.Hist_fill(self, x, w)
//
//    def table(self, *args):
//        """
//"""
//        return _pythia8.Hist_table(self, *args)
//
//    def rivetTable(self, *args):
//        """
//"""
//        return _pythia8.Hist_rivetTable(self, *args)
//
//    def pyplotTable(self, *args):
//        """
//"""
//        return _pythia8.Hist_pyplotTable(self, *args)
//
//    def getTitle(self):
//        """
//Return title and size of histogram. Also if logarithmic x scale.
//"""
//        return _pythia8.Hist_getTitle(self)
//
//    def getBinNumber(self):
//        """
//"""
//        return _pythia8.Hist_getBinNumber(self)
//
//    def getLinX(self):
//        """
//"""
//        return _pythia8.Hist_getLinX(self)
//
//    def getBinContent(self, iBin):
//        """
//Return content of specific bin: 0 gives underflow and nBin+1 overflow.
//"""
//        return _pythia8.Hist_getBinContent(self, iBin)
//
//    def getEntries(self):
//        """
//Return number of entries.
//"""
//        return _pythia8.Hist_getEntries(self)
//
//    def sameSize(self, h):
//        """
//Check whether another histogram has same size and limits.
//"""
//        return _pythia8.Hist_sameSize(self, h)
//
//    def takeLog(self, tenLog=True):
//        """
//Take logarithm (base 10 or e) of bin contents.
//"""
//        return _pythia8.Hist_takeLog(self, tenLog)
//
//    def takeSqrt(self):
//        """
//Take square root of bin contents.
//"""
//        return _pythia8.Hist_takeSqrt(self)
//
//    def smallestAbsValue(self):
//        """
//Find smallest nonzero absolute value of bin contents.
//"""
//        return _pythia8.Hist_smallestAbsValue(self)
//
//    def __iadd__(self, *args):
//        return _pythia8.Hist___iadd__(self, *args)
//
//    def __isub__(self, *args):
//        return _pythia8.Hist___isub__(self, *args)
//
//    def __imul__(self, *args):
//        return _pythia8.Hist___imul__(self, *args)
//
//    def __idiv__(self, *args):
//        return _pythia8.Hist___idiv__(self, *args)
//
//    def __add__(self, *args):
//        return _pythia8.Hist___add__(self, *args)
//
//    def __sub__(self, *args):
//        return _pythia8.Hist___sub__(self, *args)
//
//    def __mul__(self, *args):
//        return _pythia8.Hist___mul__(self, *args)
//
//    def __div__(self, *args):
//        return _pythia8.Hist___div__(self, *args)
//
//    def __str__(self):
//        return _pythia8.Hist___str__(self)
//
//    def __radd__(self, f):
//        return _pythia8.Hist___radd__(self, f)
//
//    def __rsub__(self, f):
//        return _pythia8.Hist___rsub__(self, f)
//
//    def __rmul__(self, f):
//        return _pythia8.Hist___rmul__(self, f)
//
//    def __rdiv__(self, f):
//        return _pythia8.Hist___rdiv__(self, f)
//    __swig_destroy__ = _pythia8.delete_Hist
//    __del__ = lambda self: None
//Hist_swigregister = _pythia8.Hist_swigregister
//Hist_swigregister(Hist)
//
//
//def table(*args):
//    return _pythia8.table(*args)
//table = _pythia8.table
//
//def __div__(f, h1):
//    return _pythia8.__div__(f, h1)
//__div__ = _pythia8.__div__
//class HistPlot(_object):
//    """
//HistPlot class.
//Writes a Python program that can generate PDF plots from Hist histograms.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HistPlot, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, HistPlot, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, pythonName):
//        """
//Constructor requires name of Python program (and adds .py).
//"""
//        this = _pythia8.new_HistPlot(pythonName)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HistPlot
//    __del__ = lambda self: None
//
//    def frame(self, *args):
//        """
//"""
//        return _pythia8.HistPlot_frame(self, *args)
//
//    def add(self, *args):
//        """
//"""
//        return _pythia8.HistPlot_add(self, *args)
//
//    def plot(self, logY=False):
//        """
//Plot a frame given the information from the new and add calls.
//"""
//        return _pythia8.HistPlot_plot(self, logY)
//
//    def plotFrame(self, *args):
//        """
// Omnibus single call when only one histogram in the frame.
//"""
//        return _pythia8.HistPlot_plotFrame(self, *args)
//HistPlot_swigregister = _pythia8.HistPlot_swigregister
//HistPlot_swigregister(HistPlot)
//
//class XMLTag(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, XMLTag, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, XMLTag, name)
//    __repr__ = _swig_repr
//    __swig_destroy__ = _pythia8.delete_XMLTag
//    __del__ = lambda self: None
//    __swig_setmethods__["name"] = _pythia8.XMLTag_name_set
//    __swig_getmethods__["name"] = _pythia8.XMLTag_name_get
//    if _newclass:
//        name = _swig_property(_pythia8.XMLTag_name_get, _pythia8.XMLTag_name_set)
//    __swig_setmethods__["attr"] = _pythia8.XMLTag_attr_set
//    __swig_getmethods__["attr"] = _pythia8.XMLTag_attr_get
//    if _newclass:
//        attr = _swig_property(_pythia8.XMLTag_attr_get, _pythia8.XMLTag_attr_set)
//    __swig_setmethods__["tags"] = _pythia8.XMLTag_tags_set
//    __swig_getmethods__["tags"] = _pythia8.XMLTag_tags_get
//    if _newclass:
//        tags = _swig_property(_pythia8.XMLTag_tags_get, _pythia8.XMLTag_tags_set)
//    __swig_setmethods__["contents"] = _pythia8.XMLTag_contents_set
//    __swig_getmethods__["contents"] = _pythia8.XMLTag_contents_get
//    if _newclass:
//        contents = _swig_property(_pythia8.XMLTag_contents_get, _pythia8.XMLTag_contents_set)
//
//    def getattr(self, *args):
//        return _pythia8.XMLTag_getattr(self, *args)
//    __swig_getmethods__["findXMLTags"] = lambda x: _pythia8.XMLTag_findXMLTags
//    if _newclass:
//        findXMLTags = staticmethod(_pythia8.XMLTag_findXMLTags)
//
//    def __str__(self):
//        return _pythia8.XMLTag___str__(self)
//
//    def __init__(self):
//        this = _pythia8.new_XMLTag()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//XMLTag_swigregister = _pythia8.XMLTag_swigregister
//XMLTag_swigregister(XMLTag)
//XMLTag.end = _pythia8.cvar.XMLTag_end
//
//def XMLTag_findXMLTags(str, leftover=None):
//    return _pythia8.XMLTag_findXMLTags(str, leftover)
//XMLTag_findXMLTags = _pythia8.XMLTag_findXMLTags
//
//class LHAweights(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, LHAweights, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, LHAweights, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        this = _pythia8.new_LHAweights(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def clear(self):
//        return _pythia8.LHAweights_clear(self)
//    __swig_setmethods__["weights"] = _pythia8.LHAweights_weights_set
//    __swig_getmethods__["weights"] = _pythia8.LHAweights_weights_get
//    if _newclass:
//        weights = _swig_property(_pythia8.LHAweights_weights_get, _pythia8.LHAweights_weights_set)
//    __swig_setmethods__["attributes"] = _pythia8.LHAweights_attributes_set
//    __swig_getmethods__["attributes"] = _pythia8.LHAweights_attributes_get
//    if _newclass:
//        attributes = _swig_property(_pythia8.LHAweights_attributes_get, _pythia8.LHAweights_attributes_set)
//    __swig_setmethods__["contents"] = _pythia8.LHAweights_contents_set
//    __swig_getmethods__["contents"] = _pythia8.LHAweights_contents_get
//    if _newclass:
//        contents = _swig_property(_pythia8.LHAweights_contents_get, _pythia8.LHAweights_contents_set)
//
//    def size(self):
//        return _pythia8.LHAweights_size(self)
//
//    def __str__(self):
//        return _pythia8.LHAweights___str__(self)
//    __swig_destroy__ = _pythia8.delete_LHAweights
//    __del__ = lambda self: None
//LHAweights_swigregister = _pythia8.LHAweights_swigregister
//LHAweights_swigregister(LHAweights)
//
//class LHAscales(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, LHAscales, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, LHAscales, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        this = _pythia8.new_LHAscales(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def clear(self):
//        return _pythia8.LHAscales_clear(self)
//    __swig_setmethods__["muf"] = _pythia8.LHAscales_muf_set
//    __swig_getmethods__["muf"] = _pythia8.LHAscales_muf_get
//    if _newclass:
//        muf = _swig_property(_pythia8.LHAscales_muf_get, _pythia8.LHAscales_muf_set)
//    __swig_setmethods__["mur"] = _pythia8.LHAscales_mur_set
//    __swig_getmethods__["mur"] = _pythia8.LHAscales_mur_get
//    if _newclass:
//        mur = _swig_property(_pythia8.LHAscales_mur_get, _pythia8.LHAscales_mur_set)
//    __swig_setmethods__["mups"] = _pythia8.LHAscales_mups_set
//    __swig_getmethods__["mups"] = _pythia8.LHAscales_mups_get
//    if _newclass:
//        mups = _swig_property(_pythia8.LHAscales_mups_get, _pythia8.LHAscales_mups_set)
//    __swig_setmethods__["attributes"] = _pythia8.LHAscales_attributes_set
//    __swig_getmethods__["attributes"] = _pythia8.LHAscales_attributes_get
//    if _newclass:
//        attributes = _swig_property(_pythia8.LHAscales_attributes_get, _pythia8.LHAscales_attributes_set)
//    __swig_setmethods__["SCALUP"] = _pythia8.LHAscales_SCALUP_set
//    __swig_getmethods__["SCALUP"] = _pythia8.LHAscales_SCALUP_get
//    if _newclass:
//        SCALUP = _swig_property(_pythia8.LHAscales_SCALUP_get, _pythia8.LHAscales_SCALUP_set)
//    __swig_setmethods__["contents"] = _pythia8.LHAscales_contents_set
//    __swig_getmethods__["contents"] = _pythia8.LHAscales_contents_get
//    if _newclass:
//        contents = _swig_property(_pythia8.LHAscales_contents_get, _pythia8.LHAscales_contents_set)
//
//    def __str__(self):
//        return _pythia8.LHAscales___str__(self)
//    __swig_destroy__ = _pythia8.delete_LHAscales
//    __del__ = lambda self: None
//LHAscales_swigregister = _pythia8.LHAscales_swigregister
//LHAscales_swigregister(LHAscales)
//
//class LHAgenerator(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, LHAgenerator, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, LHAgenerator, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        this = _pythia8.new_LHAgenerator(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def clear(self):
//        return _pythia8.LHAgenerator_clear(self)
//    __swig_setmethods__["name"] = _pythia8.LHAgenerator_name_set
//    __swig_getmethods__["name"] = _pythia8.LHAgenerator_name_get
//    if _newclass:
//        name = _swig_property(_pythia8.LHAgenerator_name_get, _pythia8.LHAgenerator_name_set)
//    __swig_setmethods__["version"] = _pythia8.LHAgenerator_version_set
//    __swig_getmethods__["version"] = _pythia8.LHAgenerator_version_get
//    if _newclass:
//        version = _swig_property(_pythia8.LHAgenerator_version_get, _pythia8.LHAgenerator_version_set)
//    __swig_setmethods__["attributes"] = _pythia8.LHAgenerator_attributes_set
//    __swig_getmethods__["attributes"] = _pythia8.LHAgenerator_attributes_get
//    if _newclass:
//        attributes = _swig_property(_pythia8.LHAgenerator_attributes_get, _pythia8.LHAgenerator_attributes_set)
//    __swig_setmethods__["contents"] = _pythia8.LHAgenerator_contents_set
//    __swig_getmethods__["contents"] = _pythia8.LHAgenerator_contents_get
//    if _newclass:
//        contents = _swig_property(_pythia8.LHAgenerator_contents_get, _pythia8.LHAgenerator_contents_set)
//
//    def __str__(self):
//        return _pythia8.LHAgenerator___str__(self)
//    __swig_destroy__ = _pythia8.delete_LHAgenerator
//    __del__ = lambda self: None
//LHAgenerator_swigregister = _pythia8.LHAgenerator_swigregister
//LHAgenerator_swigregister(LHAgenerator)
//
//class LHAwgt(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, LHAwgt, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, LHAwgt, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        this = _pythia8.new_LHAwgt(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def clear(self):
//        return _pythia8.LHAwgt_clear(self)
//    __swig_setmethods__["id"] = _pythia8.LHAwgt_id_set
//    __swig_getmethods__["id"] = _pythia8.LHAwgt_id_get
//    if _newclass:
//        id = _swig_property(_pythia8.LHAwgt_id_get, _pythia8.LHAwgt_id_set)
//    __swig_setmethods__["attributes"] = _pythia8.LHAwgt_attributes_set
//    __swig_getmethods__["attributes"] = _pythia8.LHAwgt_attributes_get
//    if _newclass:
//        attributes = _swig_property(_pythia8.LHAwgt_attributes_get, _pythia8.LHAwgt_attributes_set)
//    __swig_setmethods__["contents"] = _pythia8.LHAwgt_contents_set
//    __swig_getmethods__["contents"] = _pythia8.LHAwgt_contents_get
//    if _newclass:
//        contents = _swig_property(_pythia8.LHAwgt_contents_get, _pythia8.LHAwgt_contents_set)
//
//    def __str__(self):
//        return _pythia8.LHAwgt___str__(self)
//    __swig_destroy__ = _pythia8.delete_LHAwgt
//    __del__ = lambda self: None
//LHAwgt_swigregister = _pythia8.LHAwgt_swigregister
//LHAwgt_swigregister(LHAwgt)
//
//class LHAweight(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, LHAweight, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, LHAweight, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        this = _pythia8.new_LHAweight(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def clear(self):
//        return _pythia8.LHAweight_clear(self)
//    __swig_setmethods__["id"] = _pythia8.LHAweight_id_set
//    __swig_getmethods__["id"] = _pythia8.LHAweight_id_get
//    if _newclass:
//        id = _swig_property(_pythia8.LHAweight_id_get, _pythia8.LHAweight_id_set)
//    __swig_setmethods__["attributes"] = _pythia8.LHAweight_attributes_set
//    __swig_getmethods__["attributes"] = _pythia8.LHAweight_attributes_get
//    if _newclass:
//        attributes = _swig_property(_pythia8.LHAweight_attributes_get, _pythia8.LHAweight_attributes_set)
//    __swig_setmethods__["contents"] = _pythia8.LHAweight_contents_set
//    __swig_getmethods__["contents"] = _pythia8.LHAweight_contents_get
//    if _newclass:
//        contents = _swig_property(_pythia8.LHAweight_contents_get, _pythia8.LHAweight_contents_set)
//
//    def __str__(self):
//        return _pythia8.LHAweight___str__(self)
//    __swig_destroy__ = _pythia8.delete_LHAweight
//    __del__ = lambda self: None
//LHAweight_swigregister = _pythia8.LHAweight_swigregister
//LHAweight_swigregister(LHAweight)
//
//class LHAweightgroup(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, LHAweightgroup, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, LHAweightgroup, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        this = _pythia8.new_LHAweightgroup(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def clear(self):
//        return _pythia8.LHAweightgroup_clear(self)
//    __swig_setmethods__["contents"] = _pythia8.LHAweightgroup_contents_set
//    __swig_getmethods__["contents"] = _pythia8.LHAweightgroup_contents_get
//    if _newclass:
//        contents = _swig_property(_pythia8.LHAweightgroup_contents_get, _pythia8.LHAweightgroup_contents_set)
//    __swig_setmethods__["name"] = _pythia8.LHAweightgroup_name_set
//    __swig_getmethods__["name"] = _pythia8.LHAweightgroup_name_get
//    if _newclass:
//        name = _swig_property(_pythia8.LHAweightgroup_name_get, _pythia8.LHAweightgroup_name_set)
//    __swig_setmethods__["weights"] = _pythia8.LHAweightgroup_weights_set
//    __swig_getmethods__["weights"] = _pythia8.LHAweightgroup_weights_get
//    if _newclass:
//        weights = _swig_property(_pythia8.LHAweightgroup_weights_get, _pythia8.LHAweightgroup_weights_set)
//    __swig_setmethods__["weightsKeys"] = _pythia8.LHAweightgroup_weightsKeys_set
//    __swig_getmethods__["weightsKeys"] = _pythia8.LHAweightgroup_weightsKeys_get
//    if _newclass:
//        weightsKeys = _swig_property(_pythia8.LHAweightgroup_weightsKeys_get, _pythia8.LHAweightgroup_weightsKeys_set)
//    __swig_setmethods__["attributes"] = _pythia8.LHAweightgroup_attributes_set
//    __swig_getmethods__["attributes"] = _pythia8.LHAweightgroup_attributes_get
//    if _newclass:
//        attributes = _swig_property(_pythia8.LHAweightgroup_attributes_get, _pythia8.LHAweightgroup_attributes_set)
//
//    def size(self):
//        return _pythia8.LHAweightgroup_size(self)
//
//    def __str__(self):
//        return _pythia8.LHAweightgroup___str__(self)
//    __swig_destroy__ = _pythia8.delete_LHAweightgroup
//    __del__ = lambda self: None
//LHAweightgroup_swigregister = _pythia8.LHAweightgroup_swigregister
//LHAweightgroup_swigregister(LHAweightgroup)
//
//class LHArwgt(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, LHArwgt, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, LHArwgt, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        this = _pythia8.new_LHArwgt(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def clear(self):
//        return _pythia8.LHArwgt_clear(self)
//    __swig_setmethods__["contents"] = _pythia8.LHArwgt_contents_set
//    __swig_getmethods__["contents"] = _pythia8.LHArwgt_contents_get
//    if _newclass:
//        contents = _swig_property(_pythia8.LHArwgt_contents_get, _pythia8.LHArwgt_contents_set)
//    __swig_setmethods__["wgts"] = _pythia8.LHArwgt_wgts_set
//    __swig_getmethods__["wgts"] = _pythia8.LHArwgt_wgts_get
//    if _newclass:
//        wgts = _swig_property(_pythia8.LHArwgt_wgts_get, _pythia8.LHArwgt_wgts_set)
//    __swig_setmethods__["wgtsKeys"] = _pythia8.LHArwgt_wgtsKeys_set
//    __swig_getmethods__["wgtsKeys"] = _pythia8.LHArwgt_wgtsKeys_get
//    if _newclass:
//        wgtsKeys = _swig_property(_pythia8.LHArwgt_wgtsKeys_get, _pythia8.LHArwgt_wgtsKeys_set)
//    __swig_setmethods__["attributes"] = _pythia8.LHArwgt_attributes_set
//    __swig_getmethods__["attributes"] = _pythia8.LHArwgt_attributes_get
//    if _newclass:
//        attributes = _swig_property(_pythia8.LHArwgt_attributes_get, _pythia8.LHArwgt_attributes_set)
//
//    def size(self):
//        return _pythia8.LHArwgt_size(self)
//
//    def __str__(self):
//        return _pythia8.LHArwgt___str__(self)
//    __swig_destroy__ = _pythia8.delete_LHArwgt
//    __del__ = lambda self: None
//LHArwgt_swigregister = _pythia8.LHArwgt_swigregister
//LHArwgt_swigregister(LHArwgt)
//
//class LHAinitrwgt(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, LHAinitrwgt, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, LHAinitrwgt, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        this = _pythia8.new_LHAinitrwgt(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def clear(self):
//        return _pythia8.LHAinitrwgt_clear(self)
//    __swig_setmethods__["contents"] = _pythia8.LHAinitrwgt_contents_set
//    __swig_getmethods__["contents"] = _pythia8.LHAinitrwgt_contents_get
//    if _newclass:
//        contents = _swig_property(_pythia8.LHAinitrwgt_contents_get, _pythia8.LHAinitrwgt_contents_set)
//    __swig_setmethods__["weights"] = _pythia8.LHAinitrwgt_weights_set
//    __swig_getmethods__["weights"] = _pythia8.LHAinitrwgt_weights_get
//    if _newclass:
//        weights = _swig_property(_pythia8.LHAinitrwgt_weights_get, _pythia8.LHAinitrwgt_weights_set)
//    __swig_setmethods__["weightsKeys"] = _pythia8.LHAinitrwgt_weightsKeys_set
//    __swig_getmethods__["weightsKeys"] = _pythia8.LHAinitrwgt_weightsKeys_get
//    if _newclass:
//        weightsKeys = _swig_property(_pythia8.LHAinitrwgt_weightsKeys_get, _pythia8.LHAinitrwgt_weightsKeys_set)
//    __swig_setmethods__["weightgroups"] = _pythia8.LHAinitrwgt_weightgroups_set
//    __swig_getmethods__["weightgroups"] = _pythia8.LHAinitrwgt_weightgroups_get
//    if _newclass:
//        weightgroups = _swig_property(_pythia8.LHAinitrwgt_weightgroups_get, _pythia8.LHAinitrwgt_weightgroups_set)
//    __swig_setmethods__["weightgroupsKeys"] = _pythia8.LHAinitrwgt_weightgroupsKeys_set
//    __swig_getmethods__["weightgroupsKeys"] = _pythia8.LHAinitrwgt_weightgroupsKeys_get
//    if _newclass:
//        weightgroupsKeys = _swig_property(_pythia8.LHAinitrwgt_weightgroupsKeys_get, _pythia8.LHAinitrwgt_weightgroupsKeys_set)
//    __swig_setmethods__["attributes"] = _pythia8.LHAinitrwgt_attributes_set
//    __swig_getmethods__["attributes"] = _pythia8.LHAinitrwgt_attributes_get
//    if _newclass:
//        attributes = _swig_property(_pythia8.LHAinitrwgt_attributes_get, _pythia8.LHAinitrwgt_attributes_set)
//
//    def size(self):
//        return _pythia8.LHAinitrwgt_size(self)
//
//    def sizeWeightGroups(self):
//        return _pythia8.LHAinitrwgt_sizeWeightGroups(self)
//
//    def __str__(self):
//        return _pythia8.LHAinitrwgt___str__(self)
//    __swig_destroy__ = _pythia8.delete_LHAinitrwgt
//    __del__ = lambda self: None
//LHAinitrwgt_swigregister = _pythia8.LHAinitrwgt_swigregister
//LHAinitrwgt_swigregister(LHAinitrwgt)
//
//class HEPRUP(_object):
//    """
//The HEPRUP class is a simple container corresponding to the Les Houches
//accord (<A HREF="http://arxiv.org/abs/hep-ph/0109068">hep-ph/0109068</A>)
//common block with the same name. The members are named in the same
//way as in the common block. However, fortran arrays are represented
//by vectors, except for the arrays of length two which are
//represented by pair objects.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HEPRUP, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, HEPRUP, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Default constructor.
//"""
//        this = _pythia8.new_HEPRUP()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HEPRUP
//    __del__ = lambda self: None
//
//    def resize(self, *args):
//        """
//Assuming the NPRUP variable, corresponding to the number of
//sub-processes, is correctly set, resize the relevant vectors
//accordingly.
//"""
//        return _pythia8.HEPRUP_resize(self, *args)
//
//    def clear(self):
//        """
//Clear all members.
//"""
//        return _pythia8.HEPRUP_clear(self)
//    __swig_setmethods__["IDBMUP"] = _pythia8.HEPRUP_IDBMUP_set
//    __swig_getmethods__["IDBMUP"] = _pythia8.HEPRUP_IDBMUP_get
//    if _newclass:
//        IDBMUP = _swig_property(_pythia8.HEPRUP_IDBMUP_get, _pythia8.HEPRUP_IDBMUP_set)
//    __swig_setmethods__["EBMUP"] = _pythia8.HEPRUP_EBMUP_set
//    __swig_getmethods__["EBMUP"] = _pythia8.HEPRUP_EBMUP_get
//    if _newclass:
//        EBMUP = _swig_property(_pythia8.HEPRUP_EBMUP_get, _pythia8.HEPRUP_EBMUP_set)
//    __swig_setmethods__["PDFGUP"] = _pythia8.HEPRUP_PDFGUP_set
//    __swig_getmethods__["PDFGUP"] = _pythia8.HEPRUP_PDFGUP_get
//    if _newclass:
//        PDFGUP = _swig_property(_pythia8.HEPRUP_PDFGUP_get, _pythia8.HEPRUP_PDFGUP_set)
//    __swig_setmethods__["PDFSUP"] = _pythia8.HEPRUP_PDFSUP_set
//    __swig_getmethods__["PDFSUP"] = _pythia8.HEPRUP_PDFSUP_get
//    if _newclass:
//        PDFSUP = _swig_property(_pythia8.HEPRUP_PDFSUP_get, _pythia8.HEPRUP_PDFSUP_set)
//    __swig_setmethods__["IDWTUP"] = _pythia8.HEPRUP_IDWTUP_set
//    __swig_getmethods__["IDWTUP"] = _pythia8.HEPRUP_IDWTUP_get
//    if _newclass:
//        IDWTUP = _swig_property(_pythia8.HEPRUP_IDWTUP_get, _pythia8.HEPRUP_IDWTUP_set)
//    __swig_setmethods__["NPRUP"] = _pythia8.HEPRUP_NPRUP_set
//    __swig_getmethods__["NPRUP"] = _pythia8.HEPRUP_NPRUP_get
//    if _newclass:
//        NPRUP = _swig_property(_pythia8.HEPRUP_NPRUP_get, _pythia8.HEPRUP_NPRUP_set)
//    __swig_setmethods__["XSECUP"] = _pythia8.HEPRUP_XSECUP_set
//    __swig_getmethods__["XSECUP"] = _pythia8.HEPRUP_XSECUP_get
//    if _newclass:
//        XSECUP = _swig_property(_pythia8.HEPRUP_XSECUP_get, _pythia8.HEPRUP_XSECUP_set)
//    __swig_setmethods__["XERRUP"] = _pythia8.HEPRUP_XERRUP_set
//    __swig_getmethods__["XERRUP"] = _pythia8.HEPRUP_XERRUP_get
//    if _newclass:
//        XERRUP = _swig_property(_pythia8.HEPRUP_XERRUP_get, _pythia8.HEPRUP_XERRUP_set)
//    __swig_setmethods__["XMAXUP"] = _pythia8.HEPRUP_XMAXUP_set
//    __swig_getmethods__["XMAXUP"] = _pythia8.HEPRUP_XMAXUP_get
//    if _newclass:
//        XMAXUP = _swig_property(_pythia8.HEPRUP_XMAXUP_get, _pythia8.HEPRUP_XMAXUP_set)
//    __swig_setmethods__["LPRUP"] = _pythia8.HEPRUP_LPRUP_set
//    __swig_getmethods__["LPRUP"] = _pythia8.HEPRUP_LPRUP_get
//    if _newclass:
//        LPRUP = _swig_property(_pythia8.HEPRUP_LPRUP_get, _pythia8.HEPRUP_LPRUP_set)
//    __swig_setmethods__["initrwgt"] = _pythia8.HEPRUP_initrwgt_set
//    __swig_getmethods__["initrwgt"] = _pythia8.HEPRUP_initrwgt_get
//    if _newclass:
//        initrwgt = _swig_property(_pythia8.HEPRUP_initrwgt_get, _pythia8.HEPRUP_initrwgt_set)
//    __swig_setmethods__["generators"] = _pythia8.HEPRUP_generators_set
//    __swig_getmethods__["generators"] = _pythia8.HEPRUP_generators_get
//    if _newclass:
//        generators = _swig_property(_pythia8.HEPRUP_generators_get, _pythia8.HEPRUP_generators_set)
//    __swig_setmethods__["weightgroups"] = _pythia8.HEPRUP_weightgroups_set
//    __swig_getmethods__["weightgroups"] = _pythia8.HEPRUP_weightgroups_get
//    if _newclass:
//        weightgroups = _swig_property(_pythia8.HEPRUP_weightgroups_get, _pythia8.HEPRUP_weightgroups_set)
//    __swig_setmethods__["weights"] = _pythia8.HEPRUP_weights_set
//    __swig_getmethods__["weights"] = _pythia8.HEPRUP_weights_get
//    if _newclass:
//        weights = _swig_property(_pythia8.HEPRUP_weights_get, _pythia8.HEPRUP_weights_set)
//HEPRUP_swigregister = _pythia8.HEPRUP_swigregister
//HEPRUP_swigregister(HEPRUP)
//
//class HEPEUP(_object):
//    """
//The HEPEUP class is a simple container corresponding to the Les Houches
//accord (<A HREF="http://arxiv.org/abs/hep-ph/0109068">hep-ph/0109068</A>)
//common block with the same name. The members are named in the same
//way as in the common block. However, fortran arrays are represented
//by vectors, except for the arrays of length two which are
//represented by pair objects.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HEPEUP, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, HEPEUP, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Copy constructor
//"""
//        this = _pythia8.new_HEPEUP(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def setEvent(self, x):
//        """
//"""
//        return _pythia8.HEPEUP_setEvent(self, x)
//    __swig_destroy__ = _pythia8.delete_HEPEUP
//    __del__ = lambda self: None
//
//    def reset(self):
//        """
//"""
//        return _pythia8.HEPEUP_reset(self)
//
//    def clear(self):
//        """
//Clear the HEPEUP object.
//"""
//        return _pythia8.HEPEUP_clear(self)
//
//    def weight(self):
//        """
//Return the main weight for this event.
//"""
//        return _pythia8.HEPEUP_weight(self)
//
//    def resize(self, *args):
//        """
//Assuming the NUP variable, corresponding to the number of
//particles in the current event, is correctly set, resize the
//relevant vectors accordingly.
//"""
//        return _pythia8.HEPEUP_resize(self, *args)
//    __swig_setmethods__["NUP"] = _pythia8.HEPEUP_NUP_set
//    __swig_getmethods__["NUP"] = _pythia8.HEPEUP_NUP_get
//    if _newclass:
//        NUP = _swig_property(_pythia8.HEPEUP_NUP_get, _pythia8.HEPEUP_NUP_set)
//    __swig_setmethods__["IDPRUP"] = _pythia8.HEPEUP_IDPRUP_set
//    __swig_getmethods__["IDPRUP"] = _pythia8.HEPEUP_IDPRUP_get
//    if _newclass:
//        IDPRUP = _swig_property(_pythia8.HEPEUP_IDPRUP_get, _pythia8.HEPEUP_IDPRUP_set)
//    __swig_setmethods__["XWGTUP"] = _pythia8.HEPEUP_XWGTUP_set
//    __swig_getmethods__["XWGTUP"] = _pythia8.HEPEUP_XWGTUP_get
//    if _newclass:
//        XWGTUP = _swig_property(_pythia8.HEPEUP_XWGTUP_get, _pythia8.HEPEUP_XWGTUP_set)
//    __swig_setmethods__["XPDWUP"] = _pythia8.HEPEUP_XPDWUP_set
//    __swig_getmethods__["XPDWUP"] = _pythia8.HEPEUP_XPDWUP_get
//    if _newclass:
//        XPDWUP = _swig_property(_pythia8.HEPEUP_XPDWUP_get, _pythia8.HEPEUP_XPDWUP_set)
//    __swig_setmethods__["SCALUP"] = _pythia8.HEPEUP_SCALUP_set
//    __swig_getmethods__["SCALUP"] = _pythia8.HEPEUP_SCALUP_get
//    if _newclass:
//        SCALUP = _swig_property(_pythia8.HEPEUP_SCALUP_get, _pythia8.HEPEUP_SCALUP_set)
//    __swig_setmethods__["AQEDUP"] = _pythia8.HEPEUP_AQEDUP_set
//    __swig_getmethods__["AQEDUP"] = _pythia8.HEPEUP_AQEDUP_get
//    if _newclass:
//        AQEDUP = _swig_property(_pythia8.HEPEUP_AQEDUP_get, _pythia8.HEPEUP_AQEDUP_set)
//    __swig_setmethods__["AQCDUP"] = _pythia8.HEPEUP_AQCDUP_set
//    __swig_getmethods__["AQCDUP"] = _pythia8.HEPEUP_AQCDUP_get
//    if _newclass:
//        AQCDUP = _swig_property(_pythia8.HEPEUP_AQCDUP_get, _pythia8.HEPEUP_AQCDUP_set)
//    __swig_setmethods__["IDUP"] = _pythia8.HEPEUP_IDUP_set
//    __swig_getmethods__["IDUP"] = _pythia8.HEPEUP_IDUP_get
//    if _newclass:
//        IDUP = _swig_property(_pythia8.HEPEUP_IDUP_get, _pythia8.HEPEUP_IDUP_set)
//    __swig_setmethods__["ISTUP"] = _pythia8.HEPEUP_ISTUP_set
//    __swig_getmethods__["ISTUP"] = _pythia8.HEPEUP_ISTUP_get
//    if _newclass:
//        ISTUP = _swig_property(_pythia8.HEPEUP_ISTUP_get, _pythia8.HEPEUP_ISTUP_set)
//    __swig_setmethods__["MOTHUP"] = _pythia8.HEPEUP_MOTHUP_set
//    __swig_getmethods__["MOTHUP"] = _pythia8.HEPEUP_MOTHUP_get
//    if _newclass:
//        MOTHUP = _swig_property(_pythia8.HEPEUP_MOTHUP_get, _pythia8.HEPEUP_MOTHUP_set)
//    __swig_setmethods__["ICOLUP"] = _pythia8.HEPEUP_ICOLUP_set
//    __swig_getmethods__["ICOLUP"] = _pythia8.HEPEUP_ICOLUP_get
//    if _newclass:
//        ICOLUP = _swig_property(_pythia8.HEPEUP_ICOLUP_get, _pythia8.HEPEUP_ICOLUP_set)
//    __swig_setmethods__["PUP"] = _pythia8.HEPEUP_PUP_set
//    __swig_getmethods__["PUP"] = _pythia8.HEPEUP_PUP_get
//    if _newclass:
//        PUP = _swig_property(_pythia8.HEPEUP_PUP_get, _pythia8.HEPEUP_PUP_set)
//    __swig_setmethods__["VTIMUP"] = _pythia8.HEPEUP_VTIMUP_set
//    __swig_getmethods__["VTIMUP"] = _pythia8.HEPEUP_VTIMUP_get
//    if _newclass:
//        VTIMUP = _swig_property(_pythia8.HEPEUP_VTIMUP_get, _pythia8.HEPEUP_VTIMUP_set)
//    __swig_setmethods__["SPINUP"] = _pythia8.HEPEUP_SPINUP_set
//    __swig_getmethods__["SPINUP"] = _pythia8.HEPEUP_SPINUP_get
//    if _newclass:
//        SPINUP = _swig_property(_pythia8.HEPEUP_SPINUP_get, _pythia8.HEPEUP_SPINUP_set)
//    __swig_setmethods__["heprup"] = _pythia8.HEPEUP_heprup_set
//    __swig_getmethods__["heprup"] = _pythia8.HEPEUP_heprup_get
//    if _newclass:
//        heprup = _swig_property(_pythia8.HEPEUP_heprup_get, _pythia8.HEPEUP_heprup_set)
//    __swig_setmethods__["weights_detailed"] = _pythia8.HEPEUP_weights_detailed_set
//    __swig_getmethods__["weights_detailed"] = _pythia8.HEPEUP_weights_detailed_get
//    if _newclass:
//        weights_detailed = _swig_property(_pythia8.HEPEUP_weights_detailed_get, _pythia8.HEPEUP_weights_detailed_set)
//    __swig_setmethods__["weights_compressed"] = _pythia8.HEPEUP_weights_compressed_set
//    __swig_getmethods__["weights_compressed"] = _pythia8.HEPEUP_weights_compressed_get
//    if _newclass:
//        weights_compressed = _swig_property(_pythia8.HEPEUP_weights_compressed_get, _pythia8.HEPEUP_weights_compressed_set)
//    __swig_setmethods__["scalesSave"] = _pythia8.HEPEUP_scalesSave_set
//    __swig_getmethods__["scalesSave"] = _pythia8.HEPEUP_scalesSave_get
//    if _newclass:
//        scalesSave = _swig_property(_pythia8.HEPEUP_scalesSave_get, _pythia8.HEPEUP_scalesSave_set)
//    __swig_setmethods__["weightsSave"] = _pythia8.HEPEUP_weightsSave_set
//    __swig_getmethods__["weightsSave"] = _pythia8.HEPEUP_weightsSave_get
//    if _newclass:
//        weightsSave = _swig_property(_pythia8.HEPEUP_weightsSave_get, _pythia8.HEPEUP_weightsSave_set)
//    __swig_setmethods__["rwgtSave"] = _pythia8.HEPEUP_rwgtSave_set
//    __swig_getmethods__["rwgtSave"] = _pythia8.HEPEUP_rwgtSave_get
//    if _newclass:
//        rwgtSave = _swig_property(_pythia8.HEPEUP_rwgtSave_get, _pythia8.HEPEUP_rwgtSave_set)
//    __swig_setmethods__["attributes"] = _pythia8.HEPEUP_attributes_set
//    __swig_getmethods__["attributes"] = _pythia8.HEPEUP_attributes_get
//    if _newclass:
//        attributes = _swig_property(_pythia8.HEPEUP_attributes_get, _pythia8.HEPEUP_attributes_set)
//HEPEUP_swigregister = _pythia8.HEPEUP_swigregister
//HEPEUP_swigregister(HEPEUP)
//
//class Reader(_object):
//    """
//The Reader class is initialized with a stream from which to read a
//version 1/3 Les Houches Accord event file. In the constructor of
//the Reader object the optional header information is read and then
//the mandatory init is read. After this the whole header block
//including the enclosing lines with tags are available in the public
//headerBlock member variable. Also the information from the init
//block is available in the heprup member variable and any additional
//comment lines are available in initComments. After each successful
//call to the readEvent() function the standard Les Houches Accord
//information about the event is available in the hepeup member
//variable and any additional comments in the eventComments
//variable. A typical reading sequence would look as follows:
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Reader, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, Reader, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//The copy constructor should never be used.
//"""
//        this = _pythia8.new_Reader(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_Reader
//    __del__ = lambda self: None
//
//    def setup(self, filenameIn):
//        """
//(Re)initialize the Reader with a filename from which to read an event
//file. After this, all information from the header and init block is
//available.
//filename: File name (not used as the input file stream is given)
//isIn    : Name of the input file stream.
//"""
//        return _pythia8.Reader_setup(self, filenameIn)
//
//    def readEvent(self, peup=None):
//        """
//Read an event from the file and store it in the hepeup
//object. Optional comment lines are stored in the eventComments
//member variable.
//"""
//        return _pythia8.Reader_readEvent(self, peup)
//
//    def clearEvent(self):
//        """
//Reset values of all event-related members to their defaults.
//"""
//        return _pythia8.Reader_clearEvent(self)
//    __swig_setmethods__["isGood"] = _pythia8.Reader_isGood_set
//    __swig_getmethods__["isGood"] = _pythia8.Reader_isGood_get
//    if _newclass:
//        isGood = _swig_property(_pythia8.Reader_isGood_get, _pythia8.Reader_isGood_set)
//    __swig_setmethods__["version"] = _pythia8.Reader_version_set
//    __swig_getmethods__["version"] = _pythia8.Reader_version_get
//    if _newclass:
//        version = _swig_property(_pythia8.Reader_version_get, _pythia8.Reader_version_set)
//    __swig_setmethods__["outsideBlock"] = _pythia8.Reader_outsideBlock_set
//    __swig_getmethods__["outsideBlock"] = _pythia8.Reader_outsideBlock_get
//    if _newclass:
//        outsideBlock = _swig_property(_pythia8.Reader_outsideBlock_get, _pythia8.Reader_outsideBlock_set)
//    __swig_setmethods__["headerBlock"] = _pythia8.Reader_headerBlock_set
//    __swig_getmethods__["headerBlock"] = _pythia8.Reader_headerBlock_get
//    if _newclass:
//        headerBlock = _swig_property(_pythia8.Reader_headerBlock_get, _pythia8.Reader_headerBlock_set)
//    __swig_setmethods__["headerComments"] = _pythia8.Reader_headerComments_set
//    __swig_getmethods__["headerComments"] = _pythia8.Reader_headerComments_get
//    if _newclass:
//        headerComments = _swig_property(_pythia8.Reader_headerComments_get, _pythia8.Reader_headerComments_set)
//    __swig_setmethods__["heprup"] = _pythia8.Reader_heprup_set
//    __swig_getmethods__["heprup"] = _pythia8.Reader_heprup_get
//    if _newclass:
//        heprup = _swig_property(_pythia8.Reader_heprup_get, _pythia8.Reader_heprup_set)
//    __swig_setmethods__["initComments"] = _pythia8.Reader_initComments_set
//    __swig_getmethods__["initComments"] = _pythia8.Reader_initComments_get
//    if _newclass:
//        initComments = _swig_property(_pythia8.Reader_initComments_get, _pythia8.Reader_initComments_set)
//    __swig_setmethods__["hepeup"] = _pythia8.Reader_hepeup_set
//    __swig_getmethods__["hepeup"] = _pythia8.Reader_hepeup_get
//    if _newclass:
//        hepeup = _swig_property(_pythia8.Reader_hepeup_get, _pythia8.Reader_hepeup_set)
//    __swig_setmethods__["eventComments"] = _pythia8.Reader_eventComments_set
//    __swig_getmethods__["eventComments"] = _pythia8.Reader_eventComments_get
//    if _newclass:
//        eventComments = _swig_property(_pythia8.Reader_eventComments_get, _pythia8.Reader_eventComments_set)
//    __swig_setmethods__["weights_detailed_vec"] = _pythia8.Reader_weights_detailed_vec_set
//    __swig_getmethods__["weights_detailed_vec"] = _pythia8.Reader_weights_detailed_vec_get
//    if _newclass:
//        weights_detailed_vec = _swig_property(_pythia8.Reader_weights_detailed_vec_get, _pythia8.Reader_weights_detailed_vec_set)
//Reader_swigregister = _pythia8.Reader_swigregister
//Reader_swigregister(Reader)
//
//class Writer(_object):
//    """
//The Writer class is initialized with a stream to which to write a
//version 1.0 or 3.0 Les Houches Accord event file. In the init() function of
//the Writer object the main XML tag, header and init blocks are written,
//with the corresponding end tag is written by list_end_tag().
//After a Writer object (in the following called "writer") has been created,
//it is possible to assign version (3 by default) information by
//  writer.version = <value>;
//The header block (called "someHeaderString" below) is assigned by
//  writer.headerBlock() << someHeaderString;
//and the init block comments (called "someInitString" below) are assigned via
//  writer.initComments() << someInitString;
//The standard init information (including amendments for LHEF 3.0) can
//be assigned by the heprup member variable:
//  writer.heprup = heprup;
//where heprup is an object of type HEPRUP. All of the above information
//will be writen by calling the init() function.
//Before each event is written out with the writeEvent() function,
//the standard event information can be assigned to the hepeup
//variable by
//  writer.hepeup = hepeup;
//where hepeup is of type HEPEUP. Event comments (called
//"someCommentString" below) can be assigned through
//  writer.eventComments() << someCommentString;
//All of this event information is written by the writeEvent() function.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Writer, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, Writer, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//The copy constructor should never be used.
//"""
//        this = _pythia8.new_Writer(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_Writer
//    __del__ = lambda self: None
//
//    def headerBlock(self):
//        """
//Add header lines consisting of XML code with this stream.
//"""
//        return _pythia8.Writer_headerBlock(self)
//
//    def initComments(self):
//        """
//Add comment lines to the init block with this stream.
//"""
//        return _pythia8.Writer_initComments(self)
//
//    def eventComments(self):
//        """
//Add comment lines to the next event to be written out with this stream.
//"""
//        return _pythia8.Writer_eventComments(self)
//
//    def init(self):
//        """
//Write out an optional header block followed by the standard init
//block information together with any comment lines.
//"""
//        return _pythia8.Writer_init(self)
//
//    def writeEvent(self, peup=None, pDigits=15):
//        """
//Write out the event stored in hepeup, followed by optional
//comment lines.
//"""
//        return _pythia8.Writer_writeEvent(self, peup, pDigits)
//
//    def getEventString(self, peup=None):
//        """
//Write out an event as a string.
//"""
//        return _pythia8.Writer_getEventString(self, peup)
//    __swig_setmethods__["heprup"] = _pythia8.Writer_heprup_set
//    __swig_getmethods__["heprup"] = _pythia8.Writer_heprup_get
//    if _newclass:
//        heprup = _swig_property(_pythia8.Writer_heprup_get, _pythia8.Writer_heprup_set)
//    __swig_setmethods__["hepeup"] = _pythia8.Writer_hepeup_set
//    __swig_getmethods__["hepeup"] = _pythia8.Writer_hepeup_get
//    if _newclass:
//        hepeup = _swig_property(_pythia8.Writer_hepeup_get, _pythia8.Writer_hepeup_set)
//    __swig_setmethods__["version"] = _pythia8.Writer_version_set
//    __swig_getmethods__["version"] = _pythia8.Writer_version_get
//    if _newclass:
//        version = _swig_property(_pythia8.Writer_version_get, _pythia8.Writer_version_set)
//Writer_swigregister = _pythia8.Writer_swigregister
//Writer_swigregister(Writer)
//
//class PartonSystem(_object):
//    """
//Pointer to MergingHooks object for user interaction with the merging.
//Parameters to specify trial shower usage.
//Parameters to store to veto trial showers.
//Parameters to specify merging usage.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, PartonSystem, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, PartonSystem, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructors.
//"""
//        this = _pythia8.new_PartonSystem()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["iInA"] = _pythia8.PartonSystem_iInA_set
//    __swig_getmethods__["iInA"] = _pythia8.PartonSystem_iInA_get
//    if _newclass:
//        iInA = _swig_property(_pythia8.PartonSystem_iInA_get, _pythia8.PartonSystem_iInA_set)
//    __swig_setmethods__["iInB"] = _pythia8.PartonSystem_iInB_set
//    __swig_getmethods__["iInB"] = _pythia8.PartonSystem_iInB_get
//    if _newclass:
//        iInB = _swig_property(_pythia8.PartonSystem_iInB_get, _pythia8.PartonSystem_iInB_set)
//    __swig_setmethods__["iOut"] = _pythia8.PartonSystem_iOut_set
//    __swig_getmethods__["iOut"] = _pythia8.PartonSystem_iOut_get
//    if _newclass:
//        iOut = _swig_property(_pythia8.PartonSystem_iOut_get, _pythia8.PartonSystem_iOut_set)
//    __swig_setmethods__["sHat"] = _pythia8.PartonSystem_sHat_set
//    __swig_getmethods__["sHat"] = _pythia8.PartonSystem_sHat_get
//    if _newclass:
//        sHat = _swig_property(_pythia8.PartonSystem_sHat_get, _pythia8.PartonSystem_sHat_set)
//    __swig_setmethods__["pTHat"] = _pythia8.PartonSystem_pTHat_set
//    __swig_getmethods__["pTHat"] = _pythia8.PartonSystem_pTHat_get
//    if _newclass:
//        pTHat = _swig_property(_pythia8.PartonSystem_pTHat_get, _pythia8.PartonSystem_pTHat_set)
//    __swig_destroy__ = _pythia8.delete_PartonSystem
//    __del__ = lambda self: None
//PartonSystem_swigregister = _pythia8.PartonSystem_swigregister
//PartonSystem_swigregister(PartonSystem)
//
//class PartonSystems(_object):
//    """
//Stored quantities.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, PartonSystems, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, PartonSystems, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_PartonSystems()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def clear(self):
//        """
//Reset system list to empty.
//"""
//        return _pythia8.PartonSystems_clear(self)
//
//    def addSys(self):
//        """
//Add new subsystem to list; return its index. Number of subsystems.
//"""
//        return _pythia8.PartonSystems_addSys(self)
//
//    def sizeSys(self):
//        """
//"""
//        return _pythia8.PartonSystems_sizeSys(self)
//
//    def setInA(self, iSys, iPos):
//        """
//Set, add or replace info to one system.
//"""
//        return _pythia8.PartonSystems_setInA(self, iSys, iPos)
//
//    def setInB(self, iSys, iPos):
//        """
//"""
//        return _pythia8.PartonSystems_setInB(self, iSys, iPos)
//
//    def addOut(self, iSys, iPos):
//        """
//"""
//        return _pythia8.PartonSystems_addOut(self, iSys, iPos)
//
//    def popBackOut(self, iSys):
//        """
//"""
//        return _pythia8.PartonSystems_popBackOut(self, iSys)
//
//    def setOut(self, iSys, iMem, iPos):
//        """
//"""
//        return _pythia8.PartonSystems_setOut(self, iSys, iMem, iPos)
//
//    def replace(self, iSys, iPosOld, iPosNew):
//        """
//"""
//        return _pythia8.PartonSystems_replace(self, iSys, iPosOld, iPosNew)
//
//    def setSHat(self, iSys, sHatIn):
//        """
//"""
//        return _pythia8.PartonSystems_setSHat(self, iSys, sHatIn)
//
//    def setPTHat(self, iSys, pTHatIn):
//        """
//"""
//        return _pythia8.PartonSystems_setPTHat(self, iSys, pTHatIn)
//
//    def setSizeSys(self, iSize):
//        """
//"""
//        return _pythia8.PartonSystems_setSizeSys(self, iSize)
//
//    def hasInAB(self, iSys):
//        """
//Get info on one system.
//"""
//        return _pythia8.PartonSystems_hasInAB(self, iSys)
//
//    def getInA(self, iSys):
//        """
//"""
//        return _pythia8.PartonSystems_getInA(self, iSys)
//
//    def getInB(self, iSys):
//        """
//"""
//        return _pythia8.PartonSystems_getInB(self, iSys)
//
//    def sizeOut(self, iSys):
//        """
//"""
//        return _pythia8.PartonSystems_sizeOut(self, iSys)
//
//    def getOut(self, iSys, iMem):
//        """
//"""
//        return _pythia8.PartonSystems_getOut(self, iSys, iMem)
//
//    def sizeAll(self, iSys):
//        """
//"""
//        return _pythia8.PartonSystems_sizeAll(self, iSys)
//
//    def getAll(self, iSys, iMem):
//        """
//"""
//        return _pythia8.PartonSystems_getAll(self, iSys, iMem)
//
//    def getSHat(self, iSys):
//        """
//"""
//        return _pythia8.PartonSystems_getSHat(self, iSys)
//
//    def getPTHat(self, iSys):
//        """
//"""
//        return _pythia8.PartonSystems_getPTHat(self, iSys)
//
//    def getSystemOf(self, iPos, alsoIn=False):
//        """
//Find system of given outgoing parton, optionally also incoming one.
//"""
//        return _pythia8.PartonSystems_getSystemOf(self, iPos, alsoIn)
//
//    def getIndexOfOut(self, iSys, iPos):
//        """
//Find iOut index of given system and event record index
//"""
//        return _pythia8.PartonSystems_getIndexOfOut(self, iSys, iPos)
//
//    def popBack(self):
//        """
//Remove the last system.
//"""
//        return _pythia8.PartonSystems_popBack(self)
//
//    def __str__(self):
//        return _pythia8.PartonSystems___str__(self)
//    __swig_destroy__ = _pythia8.delete_PartonSystems
//    __del__ = lambda self: None
//PartonSystems_swigregister = _pythia8.PartonSystems_swigregister
//PartonSystems_swigregister(PartonSystems)
//
//class ProgressLog(_object):
//    """
//ProgressLog is a simple helper class to monitor the progress of a run.
//When used in the main event loop, it will with suitably (logarithmically)
//spaced intervals, print out one line with information about the number
//of events generated, two estimates (based on instantaneous and average
//CPU consumption) of when the run will be completed, the host on which
//the program is run and its process number.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ProgressLog, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, ProgressLog, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, NIn, maxsec=1200):
//        """
//Create an object for monitoring the progress of a run with NIn iterations.
//"""
//        this = _pythia8.new_ProgressLog(NIn, maxsec)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def __call__(self, *args):
//        return _pythia8.ProgressLog___call__(self, *args)
//
//    def tick(self, i, n):
//        """
//Intermittently write out a line of progress information giving
//the current iteration and the total number of iterations.
//"""
//        return _pythia8.ProgressLog_tick(self, i, n)
//
//    def fclock(self):
//        """
//"""
//        return _pythia8.ProgressLog_fclock(self)
//
//    def statusTime(self, i, n):
//        """
//Check if this is a good time to print out a status line.
//"""
//        return _pythia8.ProgressLog_statusTime(self, i, n)
//
//    def init(self, n):
//        """
//Initialise the basic engine.
//"""
//        return _pythia8.ProgressLog_init(self, n)
//    __swig_destroy__ = _pythia8.delete_ProgressLog
//    __del__ = lambda self: None
//ProgressLog_swigregister = _pythia8.ProgressLog_swigregister
//ProgressLog_swigregister(ProgressLog)
//
//class DummyForStreams(_object):
//    """
//Dummy to avoid harmless compiler warning that Streams.o has no symbols.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, DummyForStreams, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, DummyForStreams, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//"""
//        this = _pythia8.new_DummyForStreams()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def xtox(self, x):
//        """
//"""
//        return _pythia8.DummyForStreams_xtox(self, x)
//    __swig_destroy__ = _pythia8.delete_DummyForStreams
//    __del__ = lambda self: None
//DummyForStreams_swigregister = _pythia8.DummyForStreams_swigregister
//DummyForStreams_swigregister(DummyForStreams)
//
//class LHgenericBlock(_object):
//    """
//Derived class for generic blocks containing vectors of strings.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, LHgenericBlock, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, LHgenericBlock, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//"""
//        this = _pythia8.new_LHgenericBlock()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_LHgenericBlock
//    __del__ = lambda self: None
//LHgenericBlock_swigregister = _pythia8.LHgenericBlock_swigregister
//LHgenericBlock_swigregister(LHgenericBlock)
//
//class LHdecayChannel(_object):
//    """
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, LHdecayChannel, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, LHdecayChannel, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_LHdecayChannel(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def setChannel(self, *args):
//        """
//Functions to set decay channel information
//"""
//        return _pythia8.LHdecayChannel_setChannel(self, *args)
//
//    def setBrat(self, bratIn):
//        """
//"""
//        return _pythia8.LHdecayChannel_setBrat(self, bratIn)
//
//    def setIdDa(self, idDaIn):
//        """
//"""
//        return _pythia8.LHdecayChannel_setIdDa(self, idDaIn)
//
//    def getBrat(self):
//        """
//Functions to get decay channel information
//"""
//        return _pythia8.LHdecayChannel_getBrat(self)
//
//    def getNDa(self):
//        """
//"""
//        return _pythia8.LHdecayChannel_getNDa(self)
//
//    def getIdDa(self):
//        """
//"""
//        return _pythia8.LHdecayChannel_getIdDa(self)
//
//    def getComment(self):
//        """
//"""
//        return _pythia8.LHdecayChannel_getComment(self)
//    __swig_destroy__ = _pythia8.delete_LHdecayChannel
//    __del__ = lambda self: None
//LHdecayChannel_swigregister = _pythia8.LHdecayChannel_swigregister
//LHdecayChannel_swigregister(LHdecayChannel)
//
//class LHdecayTable(_object):
//    """
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, LHdecayTable, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, LHdecayTable, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_LHdecayTable(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def getId(self):
//        """
//Functions to get PDG code (id) and width
//"""
//        return _pythia8.LHdecayTable_getId(self)
//
//    def getWidth(self):
//        """
//"""
//        return _pythia8.LHdecayTable_getWidth(self)
//
//    def setId(self, idIn):
//        """
//Functions to set PDG code (id) and width
//"""
//        return _pythia8.LHdecayTable_setId(self, idIn)
//
//    def setWidth(self, widthIn):
//        """
//"""
//        return _pythia8.LHdecayTable_setWidth(self, widthIn)
//
//    def reset(self, widthIn=0.0):
//        """
//Function to reset size and width (width -> 0 by default)
//"""
//        return _pythia8.LHdecayTable_reset(self, widthIn)
//
//    def addChannel(self, *args):
//        """
//"""
//        return _pythia8.LHdecayTable_addChannel(self, *args)
//
//    def size(self):
//        """
//Function to return number of decay channels
//"""
//        return _pythia8.LHdecayTable_size(self)
//
//    def getBrat(self, iChannel):
//        """
//Function to return a branching ratio
//"""
//        return _pythia8.LHdecayTable_getBrat(self, iChannel)
//
//    def getIdDa(self, iChannel):
//        """
//Function to return daughter PDG codes
//"""
//        return _pythia8.LHdecayTable_getIdDa(self, iChannel)
//
//    def getChannel(self, iChannel):
//        """
//Function to return a decay channel
//"""
//        return _pythia8.LHdecayTable_getChannel(self, iChannel)
//    __swig_destroy__ = _pythia8.delete_LHdecayTable
//    __del__ = lambda self: None
//LHdecayTable_swigregister = _pythia8.LHdecayTable_swigregister
//LHdecayTable_swigregister(LHdecayTable)
//
//class SusyLesHouches(_object):
//    """
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SusyLesHouches, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, SusyLesHouches, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_SusyLesHouches(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def readFile(self, *args):
//        """
//"""
//        return _pythia8.SusyLesHouches_readFile(self, *args)
//
//    def listHeader(self):
//        return _pythia8.SusyLesHouches_listHeader(self)
//
//    def listFooter(self):
//        return _pythia8.SusyLesHouches_listFooter(self)
//
//    def listSpectrum(self, ifail=0):
//        return _pythia8.SusyLesHouches_listSpectrum(self, ifail)
//
//    def checkSpectrum(self):
//        """
//print Header
//print Footer
//print Spectrum
//Check spectrum and decays
//"""
//        return _pythia8.SusyLesHouches_checkSpectrum(self)
//    __swig_setmethods__["slhaFile"] = _pythia8.SusyLesHouches_slhaFile_set
//    __swig_getmethods__["slhaFile"] = _pythia8.SusyLesHouches_slhaFile_get
//    if _newclass:
//        slhaFile = _swig_property(_pythia8.SusyLesHouches_slhaFile_get, _pythia8.SusyLesHouches_slhaFile_set)
//    __swig_setmethods__["modsel"] = _pythia8.SusyLesHouches_modsel_set
//    __swig_getmethods__["modsel"] = _pythia8.SusyLesHouches_modsel_get
//    if _newclass:
//        modsel = _swig_property(_pythia8.SusyLesHouches_modsel_get, _pythia8.SusyLesHouches_modsel_set)
//    __swig_setmethods__["modsel21"] = _pythia8.SusyLesHouches_modsel21_set
//    __swig_getmethods__["modsel21"] = _pythia8.SusyLesHouches_modsel21_get
//    if _newclass:
//        modsel21 = _swig_property(_pythia8.SusyLesHouches_modsel21_get, _pythia8.SusyLesHouches_modsel21_set)
//    __swig_setmethods__["modsel12"] = _pythia8.SusyLesHouches_modsel12_set
//    __swig_getmethods__["modsel12"] = _pythia8.SusyLesHouches_modsel12_get
//    if _newclass:
//        modsel12 = _swig_property(_pythia8.SusyLesHouches_modsel12_get, _pythia8.SusyLesHouches_modsel12_set)
//    __swig_setmethods__["minpar"] = _pythia8.SusyLesHouches_minpar_set
//    __swig_getmethods__["minpar"] = _pythia8.SusyLesHouches_minpar_get
//    if _newclass:
//        minpar = _swig_property(_pythia8.SusyLesHouches_minpar_get, _pythia8.SusyLesHouches_minpar_set)
//    __swig_setmethods__["extpar"] = _pythia8.SusyLesHouches_extpar_set
//    __swig_getmethods__["extpar"] = _pythia8.SusyLesHouches_extpar_get
//    if _newclass:
//        extpar = _swig_property(_pythia8.SusyLesHouches_extpar_get, _pythia8.SusyLesHouches_extpar_set)
//    __swig_setmethods__["sminputs"] = _pythia8.SusyLesHouches_sminputs_set
//    __swig_getmethods__["sminputs"] = _pythia8.SusyLesHouches_sminputs_get
//    if _newclass:
//        sminputs = _swig_property(_pythia8.SusyLesHouches_sminputs_get, _pythia8.SusyLesHouches_sminputs_set)
//    __swig_setmethods__["spinfo"] = _pythia8.SusyLesHouches_spinfo_set
//    __swig_getmethods__["spinfo"] = _pythia8.SusyLesHouches_spinfo_get
//    if _newclass:
//        spinfo = _swig_property(_pythia8.SusyLesHouches_spinfo_get, _pythia8.SusyLesHouches_spinfo_set)
//    __swig_setmethods__["spinfo3"] = _pythia8.SusyLesHouches_spinfo3_set
//    __swig_getmethods__["spinfo3"] = _pythia8.SusyLesHouches_spinfo3_get
//    if _newclass:
//        spinfo3 = _swig_property(_pythia8.SusyLesHouches_spinfo3_get, _pythia8.SusyLesHouches_spinfo3_set)
//    __swig_setmethods__["spinfo4"] = _pythia8.SusyLesHouches_spinfo4_set
//    __swig_getmethods__["spinfo4"] = _pythia8.SusyLesHouches_spinfo4_get
//    if _newclass:
//        spinfo4 = _swig_property(_pythia8.SusyLesHouches_spinfo4_get, _pythia8.SusyLesHouches_spinfo4_set)
//    __swig_setmethods__["dcinfo"] = _pythia8.SusyLesHouches_dcinfo_set
//    __swig_getmethods__["dcinfo"] = _pythia8.SusyLesHouches_dcinfo_get
//    if _newclass:
//        dcinfo = _swig_property(_pythia8.SusyLesHouches_dcinfo_get, _pythia8.SusyLesHouches_dcinfo_set)
//    __swig_setmethods__["dcinfo3"] = _pythia8.SusyLesHouches_dcinfo3_set
//    __swig_getmethods__["dcinfo3"] = _pythia8.SusyLesHouches_dcinfo3_get
//    if _newclass:
//        dcinfo3 = _swig_property(_pythia8.SusyLesHouches_dcinfo3_get, _pythia8.SusyLesHouches_dcinfo3_set)
//    __swig_setmethods__["dcinfo4"] = _pythia8.SusyLesHouches_dcinfo4_set
//    __swig_getmethods__["dcinfo4"] = _pythia8.SusyLesHouches_dcinfo4_get
//    if _newclass:
//        dcinfo4 = _swig_property(_pythia8.SusyLesHouches_dcinfo4_get, _pythia8.SusyLesHouches_dcinfo4_set)
//    __swig_setmethods__["mass"] = _pythia8.SusyLesHouches_mass_set
//    __swig_getmethods__["mass"] = _pythia8.SusyLesHouches_mass_get
//    if _newclass:
//        mass = _swig_property(_pythia8.SusyLesHouches_mass_get, _pythia8.SusyLesHouches_mass_set)
//    __swig_setmethods__["nmix"] = _pythia8.SusyLesHouches_nmix_set
//    __swig_getmethods__["nmix"] = _pythia8.SusyLesHouches_nmix_get
//    if _newclass:
//        nmix = _swig_property(_pythia8.SusyLesHouches_nmix_get, _pythia8.SusyLesHouches_nmix_set)
//    __swig_setmethods__["umix"] = _pythia8.SusyLesHouches_umix_set
//    __swig_getmethods__["umix"] = _pythia8.SusyLesHouches_umix_get
//    if _newclass:
//        umix = _swig_property(_pythia8.SusyLesHouches_umix_get, _pythia8.SusyLesHouches_umix_set)
//    __swig_setmethods__["vmix"] = _pythia8.SusyLesHouches_vmix_set
//    __swig_getmethods__["vmix"] = _pythia8.SusyLesHouches_vmix_get
//    if _newclass:
//        vmix = _swig_property(_pythia8.SusyLesHouches_vmix_get, _pythia8.SusyLesHouches_vmix_set)
//    __swig_setmethods__["stopmix"] = _pythia8.SusyLesHouches_stopmix_set
//    __swig_getmethods__["stopmix"] = _pythia8.SusyLesHouches_stopmix_get
//    if _newclass:
//        stopmix = _swig_property(_pythia8.SusyLesHouches_stopmix_get, _pythia8.SusyLesHouches_stopmix_set)
//    __swig_setmethods__["sbotmix"] = _pythia8.SusyLesHouches_sbotmix_set
//    __swig_getmethods__["sbotmix"] = _pythia8.SusyLesHouches_sbotmix_get
//    if _newclass:
//        sbotmix = _swig_property(_pythia8.SusyLesHouches_sbotmix_get, _pythia8.SusyLesHouches_sbotmix_set)
//    __swig_setmethods__["staumix"] = _pythia8.SusyLesHouches_staumix_set
//    __swig_getmethods__["staumix"] = _pythia8.SusyLesHouches_staumix_get
//    if _newclass:
//        staumix = _swig_property(_pythia8.SusyLesHouches_staumix_get, _pythia8.SusyLesHouches_staumix_set)
//    __swig_setmethods__["alpha"] = _pythia8.SusyLesHouches_alpha_set
//    __swig_getmethods__["alpha"] = _pythia8.SusyLesHouches_alpha_get
//    if _newclass:
//        alpha = _swig_property(_pythia8.SusyLesHouches_alpha_get, _pythia8.SusyLesHouches_alpha_set)
//    __swig_setmethods__["hmix"] = _pythia8.SusyLesHouches_hmix_set
//    __swig_getmethods__["hmix"] = _pythia8.SusyLesHouches_hmix_get
//    if _newclass:
//        hmix = _swig_property(_pythia8.SusyLesHouches_hmix_get, _pythia8.SusyLesHouches_hmix_set)
//    __swig_setmethods__["gauge"] = _pythia8.SusyLesHouches_gauge_set
//    __swig_getmethods__["gauge"] = _pythia8.SusyLesHouches_gauge_get
//    if _newclass:
//        gauge = _swig_property(_pythia8.SusyLesHouches_gauge_get, _pythia8.SusyLesHouches_gauge_set)
//    __swig_setmethods__["msoft"] = _pythia8.SusyLesHouches_msoft_set
//    __swig_getmethods__["msoft"] = _pythia8.SusyLesHouches_msoft_get
//    if _newclass:
//        msoft = _swig_property(_pythia8.SusyLesHouches_msoft_get, _pythia8.SusyLesHouches_msoft_set)
//    __swig_setmethods__["au"] = _pythia8.SusyLesHouches_au_set
//    __swig_getmethods__["au"] = _pythia8.SusyLesHouches_au_get
//    if _newclass:
//        au = _swig_property(_pythia8.SusyLesHouches_au_get, _pythia8.SusyLesHouches_au_set)
//    __swig_setmethods__["ad"] = _pythia8.SusyLesHouches_ad_set
//    __swig_getmethods__["ad"] = _pythia8.SusyLesHouches_ad_get
//    if _newclass:
//        ad = _swig_property(_pythia8.SusyLesHouches_ad_get, _pythia8.SusyLesHouches_ad_set)
//    __swig_setmethods__["ae"] = _pythia8.SusyLesHouches_ae_set
//    __swig_getmethods__["ae"] = _pythia8.SusyLesHouches_ae_get
//    if _newclass:
//        ae = _swig_property(_pythia8.SusyLesHouches_ae_get, _pythia8.SusyLesHouches_ae_set)
//    __swig_setmethods__["yu"] = _pythia8.SusyLesHouches_yu_set
//    __swig_getmethods__["yu"] = _pythia8.SusyLesHouches_yu_get
//    if _newclass:
//        yu = _swig_property(_pythia8.SusyLesHouches_yu_get, _pythia8.SusyLesHouches_yu_set)
//    __swig_setmethods__["yd"] = _pythia8.SusyLesHouches_yd_set
//    __swig_getmethods__["yd"] = _pythia8.SusyLesHouches_yd_get
//    if _newclass:
//        yd = _swig_property(_pythia8.SusyLesHouches_yd_get, _pythia8.SusyLesHouches_yd_set)
//    __swig_setmethods__["ye"] = _pythia8.SusyLesHouches_ye_set
//    __swig_getmethods__["ye"] = _pythia8.SusyLesHouches_ye_get
//    if _newclass:
//        ye = _swig_property(_pythia8.SusyLesHouches_ye_get, _pythia8.SusyLesHouches_ye_set)
//    __swig_setmethods__["decays"] = _pythia8.SusyLesHouches_decays_set
//    __swig_getmethods__["decays"] = _pythia8.SusyLesHouches_decays_get
//    if _newclass:
//        decays = _swig_property(_pythia8.SusyLesHouches_decays_get, _pythia8.SusyLesHouches_decays_set)
//    __swig_setmethods__["decayIndices"] = _pythia8.SusyLesHouches_decayIndices_set
//    __swig_getmethods__["decayIndices"] = _pythia8.SusyLesHouches_decayIndices_get
//    if _newclass:
//        decayIndices = _swig_property(_pythia8.SusyLesHouches_decayIndices_get, _pythia8.SusyLesHouches_decayIndices_set)
//    __swig_setmethods__["qnumbers"] = _pythia8.SusyLesHouches_qnumbers_set
//    __swig_getmethods__["qnumbers"] = _pythia8.SusyLesHouches_qnumbers_get
//    if _newclass:
//        qnumbers = _swig_property(_pythia8.SusyLesHouches_qnumbers_get, _pythia8.SusyLesHouches_qnumbers_set)
//    __swig_setmethods__["qnumbersName"] = _pythia8.SusyLesHouches_qnumbersName_set
//    __swig_getmethods__["qnumbersName"] = _pythia8.SusyLesHouches_qnumbersName_get
//    if _newclass:
//        qnumbersName = _swig_property(_pythia8.SusyLesHouches_qnumbersName_get, _pythia8.SusyLesHouches_qnumbersName_set)
//    __swig_setmethods__["qnumbersAntiName"] = _pythia8.SusyLesHouches_qnumbersAntiName_set
//    __swig_getmethods__["qnumbersAntiName"] = _pythia8.SusyLesHouches_qnumbersAntiName_get
//    if _newclass:
//        qnumbersAntiName = _swig_property(_pythia8.SusyLesHouches_qnumbersAntiName_get, _pythia8.SusyLesHouches_qnumbersAntiName_set)
//    __swig_setmethods__["qextpar"] = _pythia8.SusyLesHouches_qextpar_set
//    __swig_getmethods__["qextpar"] = _pythia8.SusyLesHouches_qextpar_get
//    if _newclass:
//        qextpar = _swig_property(_pythia8.SusyLesHouches_qextpar_get, _pythia8.SusyLesHouches_qextpar_set)
//    __swig_setmethods__["vckmin"] = _pythia8.SusyLesHouches_vckmin_set
//    __swig_getmethods__["vckmin"] = _pythia8.SusyLesHouches_vckmin_get
//    if _newclass:
//        vckmin = _swig_property(_pythia8.SusyLesHouches_vckmin_get, _pythia8.SusyLesHouches_vckmin_set)
//    __swig_setmethods__["upmnsin"] = _pythia8.SusyLesHouches_upmnsin_set
//    __swig_getmethods__["upmnsin"] = _pythia8.SusyLesHouches_upmnsin_get
//    if _newclass:
//        upmnsin = _swig_property(_pythia8.SusyLesHouches_upmnsin_get, _pythia8.SusyLesHouches_upmnsin_set)
//    __swig_setmethods__["msq2in"] = _pythia8.SusyLesHouches_msq2in_set
//    __swig_getmethods__["msq2in"] = _pythia8.SusyLesHouches_msq2in_get
//    if _newclass:
//        msq2in = _swig_property(_pythia8.SusyLesHouches_msq2in_get, _pythia8.SusyLesHouches_msq2in_set)
//    __swig_setmethods__["msu2in"] = _pythia8.SusyLesHouches_msu2in_set
//    __swig_getmethods__["msu2in"] = _pythia8.SusyLesHouches_msu2in_get
//    if _newclass:
//        msu2in = _swig_property(_pythia8.SusyLesHouches_msu2in_get, _pythia8.SusyLesHouches_msu2in_set)
//    __swig_setmethods__["msd2in"] = _pythia8.SusyLesHouches_msd2in_set
//    __swig_getmethods__["msd2in"] = _pythia8.SusyLesHouches_msd2in_get
//    if _newclass:
//        msd2in = _swig_property(_pythia8.SusyLesHouches_msd2in_get, _pythia8.SusyLesHouches_msd2in_set)
//    __swig_setmethods__["msl2in"] = _pythia8.SusyLesHouches_msl2in_set
//    __swig_getmethods__["msl2in"] = _pythia8.SusyLesHouches_msl2in_get
//    if _newclass:
//        msl2in = _swig_property(_pythia8.SusyLesHouches_msl2in_get, _pythia8.SusyLesHouches_msl2in_set)
//    __swig_setmethods__["mse2in"] = _pythia8.SusyLesHouches_mse2in_set
//    __swig_getmethods__["mse2in"] = _pythia8.SusyLesHouches_mse2in_get
//    if _newclass:
//        mse2in = _swig_property(_pythia8.SusyLesHouches_mse2in_get, _pythia8.SusyLesHouches_mse2in_set)
//    __swig_setmethods__["tuin"] = _pythia8.SusyLesHouches_tuin_set
//    __swig_getmethods__["tuin"] = _pythia8.SusyLesHouches_tuin_get
//    if _newclass:
//        tuin = _swig_property(_pythia8.SusyLesHouches_tuin_get, _pythia8.SusyLesHouches_tuin_set)
//    __swig_setmethods__["tdin"] = _pythia8.SusyLesHouches_tdin_set
//    __swig_getmethods__["tdin"] = _pythia8.SusyLesHouches_tdin_get
//    if _newclass:
//        tdin = _swig_property(_pythia8.SusyLesHouches_tdin_get, _pythia8.SusyLesHouches_tdin_set)
//    __swig_setmethods__["tein"] = _pythia8.SusyLesHouches_tein_set
//    __swig_getmethods__["tein"] = _pythia8.SusyLesHouches_tein_get
//    if _newclass:
//        tein = _swig_property(_pythia8.SusyLesHouches_tein_get, _pythia8.SusyLesHouches_tein_set)
//    __swig_setmethods__["vckm"] = _pythia8.SusyLesHouches_vckm_set
//    __swig_getmethods__["vckm"] = _pythia8.SusyLesHouches_vckm_get
//    if _newclass:
//        vckm = _swig_property(_pythia8.SusyLesHouches_vckm_get, _pythia8.SusyLesHouches_vckm_set)
//    __swig_setmethods__["upmns"] = _pythia8.SusyLesHouches_upmns_set
//    __swig_getmethods__["upmns"] = _pythia8.SusyLesHouches_upmns_get
//    if _newclass:
//        upmns = _swig_property(_pythia8.SusyLesHouches_upmns_get, _pythia8.SusyLesHouches_upmns_set)
//    __swig_setmethods__["msq2"] = _pythia8.SusyLesHouches_msq2_set
//    __swig_getmethods__["msq2"] = _pythia8.SusyLesHouches_msq2_get
//    if _newclass:
//        msq2 = _swig_property(_pythia8.SusyLesHouches_msq2_get, _pythia8.SusyLesHouches_msq2_set)
//    __swig_setmethods__["msu2"] = _pythia8.SusyLesHouches_msu2_set
//    __swig_getmethods__["msu2"] = _pythia8.SusyLesHouches_msu2_get
//    if _newclass:
//        msu2 = _swig_property(_pythia8.SusyLesHouches_msu2_get, _pythia8.SusyLesHouches_msu2_set)
//    __swig_setmethods__["msd2"] = _pythia8.SusyLesHouches_msd2_set
//    __swig_getmethods__["msd2"] = _pythia8.SusyLesHouches_msd2_get
//    if _newclass:
//        msd2 = _swig_property(_pythia8.SusyLesHouches_msd2_get, _pythia8.SusyLesHouches_msd2_set)
//    __swig_setmethods__["msl2"] = _pythia8.SusyLesHouches_msl2_set
//    __swig_getmethods__["msl2"] = _pythia8.SusyLesHouches_msl2_get
//    if _newclass:
//        msl2 = _swig_property(_pythia8.SusyLesHouches_msl2_get, _pythia8.SusyLesHouches_msl2_set)
//    __swig_setmethods__["mse2"] = _pythia8.SusyLesHouches_mse2_set
//    __swig_getmethods__["mse2"] = _pythia8.SusyLesHouches_mse2_get
//    if _newclass:
//        mse2 = _swig_property(_pythia8.SusyLesHouches_mse2_get, _pythia8.SusyLesHouches_mse2_set)
//    __swig_setmethods__["tu"] = _pythia8.SusyLesHouches_tu_set
//    __swig_getmethods__["tu"] = _pythia8.SusyLesHouches_tu_get
//    if _newclass:
//        tu = _swig_property(_pythia8.SusyLesHouches_tu_get, _pythia8.SusyLesHouches_tu_set)
//    __swig_setmethods__["td"] = _pythia8.SusyLesHouches_td_set
//    __swig_getmethods__["td"] = _pythia8.SusyLesHouches_td_get
//    if _newclass:
//        td = _swig_property(_pythia8.SusyLesHouches_td_get, _pythia8.SusyLesHouches_td_set)
//    __swig_setmethods__["te"] = _pythia8.SusyLesHouches_te_set
//    __swig_getmethods__["te"] = _pythia8.SusyLesHouches_te_get
//    if _newclass:
//        te = _swig_property(_pythia8.SusyLesHouches_te_get, _pythia8.SusyLesHouches_te_set)
//    __swig_setmethods__["usqmix"] = _pythia8.SusyLesHouches_usqmix_set
//    __swig_getmethods__["usqmix"] = _pythia8.SusyLesHouches_usqmix_get
//    if _newclass:
//        usqmix = _swig_property(_pythia8.SusyLesHouches_usqmix_get, _pythia8.SusyLesHouches_usqmix_set)
//    __swig_setmethods__["dsqmix"] = _pythia8.SusyLesHouches_dsqmix_set
//    __swig_getmethods__["dsqmix"] = _pythia8.SusyLesHouches_dsqmix_get
//    if _newclass:
//        dsqmix = _swig_property(_pythia8.SusyLesHouches_dsqmix_get, _pythia8.SusyLesHouches_dsqmix_set)
//    __swig_setmethods__["selmix"] = _pythia8.SusyLesHouches_selmix_set
//    __swig_getmethods__["selmix"] = _pythia8.SusyLesHouches_selmix_get
//    if _newclass:
//        selmix = _swig_property(_pythia8.SusyLesHouches_selmix_get, _pythia8.SusyLesHouches_selmix_set)
//    __swig_setmethods__["snumix"] = _pythia8.SusyLesHouches_snumix_set
//    __swig_getmethods__["snumix"] = _pythia8.SusyLesHouches_snumix_get
//    if _newclass:
//        snumix = _swig_property(_pythia8.SusyLesHouches_snumix_get, _pythia8.SusyLesHouches_snumix_set)
//    __swig_setmethods__["snsmix"] = _pythia8.SusyLesHouches_snsmix_set
//    __swig_getmethods__["snsmix"] = _pythia8.SusyLesHouches_snsmix_get
//    if _newclass:
//        snsmix = _swig_property(_pythia8.SusyLesHouches_snsmix_get, _pythia8.SusyLesHouches_snsmix_set)
//    __swig_setmethods__["snamix"] = _pythia8.SusyLesHouches_snamix_set
//    __swig_getmethods__["snamix"] = _pythia8.SusyLesHouches_snamix_get
//    if _newclass:
//        snamix = _swig_property(_pythia8.SusyLesHouches_snamix_get, _pythia8.SusyLesHouches_snamix_set)
//    __swig_setmethods__["rvlamllein"] = _pythia8.SusyLesHouches_rvlamllein_set
//    __swig_getmethods__["rvlamllein"] = _pythia8.SusyLesHouches_rvlamllein_get
//    if _newclass:
//        rvlamllein = _swig_property(_pythia8.SusyLesHouches_rvlamllein_get, _pythia8.SusyLesHouches_rvlamllein_set)
//    __swig_setmethods__["rvlamlqdin"] = _pythia8.SusyLesHouches_rvlamlqdin_set
//    __swig_getmethods__["rvlamlqdin"] = _pythia8.SusyLesHouches_rvlamlqdin_get
//    if _newclass:
//        rvlamlqdin = _swig_property(_pythia8.SusyLesHouches_rvlamlqdin_get, _pythia8.SusyLesHouches_rvlamlqdin_set)
//    __swig_setmethods__["rvlamuddin"] = _pythia8.SusyLesHouches_rvlamuddin_set
//    __swig_getmethods__["rvlamuddin"] = _pythia8.SusyLesHouches_rvlamuddin_get
//    if _newclass:
//        rvlamuddin = _swig_property(_pythia8.SusyLesHouches_rvlamuddin_get, _pythia8.SusyLesHouches_rvlamuddin_set)
//    __swig_setmethods__["rvtllein"] = _pythia8.SusyLesHouches_rvtllein_set
//    __swig_getmethods__["rvtllein"] = _pythia8.SusyLesHouches_rvtllein_get
//    if _newclass:
//        rvtllein = _swig_property(_pythia8.SusyLesHouches_rvtllein_get, _pythia8.SusyLesHouches_rvtllein_set)
//    __swig_setmethods__["rvtlqdin"] = _pythia8.SusyLesHouches_rvtlqdin_set
//    __swig_getmethods__["rvtlqdin"] = _pythia8.SusyLesHouches_rvtlqdin_get
//    if _newclass:
//        rvtlqdin = _swig_property(_pythia8.SusyLesHouches_rvtlqdin_get, _pythia8.SusyLesHouches_rvtlqdin_set)
//    __swig_setmethods__["rvtuddin"] = _pythia8.SusyLesHouches_rvtuddin_set
//    __swig_getmethods__["rvtuddin"] = _pythia8.SusyLesHouches_rvtuddin_get
//    if _newclass:
//        rvtuddin = _swig_property(_pythia8.SusyLesHouches_rvtuddin_get, _pythia8.SusyLesHouches_rvtuddin_set)
//    __swig_setmethods__["rvkappain"] = _pythia8.SusyLesHouches_rvkappain_set
//    __swig_getmethods__["rvkappain"] = _pythia8.SusyLesHouches_rvkappain_get
//    if _newclass:
//        rvkappain = _swig_property(_pythia8.SusyLesHouches_rvkappain_get, _pythia8.SusyLesHouches_rvkappain_set)
//    __swig_setmethods__["rvdin"] = _pythia8.SusyLesHouches_rvdin_set
//    __swig_getmethods__["rvdin"] = _pythia8.SusyLesHouches_rvdin_get
//    if _newclass:
//        rvdin = _swig_property(_pythia8.SusyLesHouches_rvdin_get, _pythia8.SusyLesHouches_rvdin_set)
//    __swig_setmethods__["rvm2lh1in"] = _pythia8.SusyLesHouches_rvm2lh1in_set
//    __swig_getmethods__["rvm2lh1in"] = _pythia8.SusyLesHouches_rvm2lh1in_get
//    if _newclass:
//        rvm2lh1in = _swig_property(_pythia8.SusyLesHouches_rvm2lh1in_get, _pythia8.SusyLesHouches_rvm2lh1in_set)
//    __swig_setmethods__["rvsnvevin"] = _pythia8.SusyLesHouches_rvsnvevin_set
//    __swig_getmethods__["rvsnvevin"] = _pythia8.SusyLesHouches_rvsnvevin_get
//    if _newclass:
//        rvsnvevin = _swig_property(_pythia8.SusyLesHouches_rvsnvevin_get, _pythia8.SusyLesHouches_rvsnvevin_set)
//    __swig_setmethods__["rvlamlle"] = _pythia8.SusyLesHouches_rvlamlle_set
//    __swig_getmethods__["rvlamlle"] = _pythia8.SusyLesHouches_rvlamlle_get
//    if _newclass:
//        rvlamlle = _swig_property(_pythia8.SusyLesHouches_rvlamlle_get, _pythia8.SusyLesHouches_rvlamlle_set)
//    __swig_setmethods__["rvlamlqd"] = _pythia8.SusyLesHouches_rvlamlqd_set
//    __swig_getmethods__["rvlamlqd"] = _pythia8.SusyLesHouches_rvlamlqd_get
//    if _newclass:
//        rvlamlqd = _swig_property(_pythia8.SusyLesHouches_rvlamlqd_get, _pythia8.SusyLesHouches_rvlamlqd_set)
//    __swig_setmethods__["rvlamudd"] = _pythia8.SusyLesHouches_rvlamudd_set
//    __swig_getmethods__["rvlamudd"] = _pythia8.SusyLesHouches_rvlamudd_get
//    if _newclass:
//        rvlamudd = _swig_property(_pythia8.SusyLesHouches_rvlamudd_get, _pythia8.SusyLesHouches_rvlamudd_set)
//    __swig_setmethods__["rvtlle"] = _pythia8.SusyLesHouches_rvtlle_set
//    __swig_getmethods__["rvtlle"] = _pythia8.SusyLesHouches_rvtlle_get
//    if _newclass:
//        rvtlle = _swig_property(_pythia8.SusyLesHouches_rvtlle_get, _pythia8.SusyLesHouches_rvtlle_set)
//    __swig_setmethods__["rvtlqd"] = _pythia8.SusyLesHouches_rvtlqd_set
//    __swig_getmethods__["rvtlqd"] = _pythia8.SusyLesHouches_rvtlqd_get
//    if _newclass:
//        rvtlqd = _swig_property(_pythia8.SusyLesHouches_rvtlqd_get, _pythia8.SusyLesHouches_rvtlqd_set)
//    __swig_setmethods__["rvtudd"] = _pythia8.SusyLesHouches_rvtudd_set
//    __swig_getmethods__["rvtudd"] = _pythia8.SusyLesHouches_rvtudd_get
//    if _newclass:
//        rvtudd = _swig_property(_pythia8.SusyLesHouches_rvtudd_get, _pythia8.SusyLesHouches_rvtudd_set)
//    __swig_setmethods__["rvkappa"] = _pythia8.SusyLesHouches_rvkappa_set
//    __swig_getmethods__["rvkappa"] = _pythia8.SusyLesHouches_rvkappa_get
//    if _newclass:
//        rvkappa = _swig_property(_pythia8.SusyLesHouches_rvkappa_get, _pythia8.SusyLesHouches_rvkappa_set)
//    __swig_setmethods__["rvd"] = _pythia8.SusyLesHouches_rvd_set
//    __swig_getmethods__["rvd"] = _pythia8.SusyLesHouches_rvd_get
//    if _newclass:
//        rvd = _swig_property(_pythia8.SusyLesHouches_rvd_get, _pythia8.SusyLesHouches_rvd_set)
//    __swig_setmethods__["rvm2lh1"] = _pythia8.SusyLesHouches_rvm2lh1_set
//    __swig_getmethods__["rvm2lh1"] = _pythia8.SusyLesHouches_rvm2lh1_get
//    if _newclass:
//        rvm2lh1 = _swig_property(_pythia8.SusyLesHouches_rvm2lh1_get, _pythia8.SusyLesHouches_rvm2lh1_set)
//    __swig_setmethods__["rvsnvev"] = _pythia8.SusyLesHouches_rvsnvev_set
//    __swig_getmethods__["rvsnvev"] = _pythia8.SusyLesHouches_rvsnvev_get
//    if _newclass:
//        rvsnvev = _swig_property(_pythia8.SusyLesHouches_rvsnvev_get, _pythia8.SusyLesHouches_rvsnvev_set)
//    __swig_setmethods__["rvnmix"] = _pythia8.SusyLesHouches_rvnmix_set
//    __swig_getmethods__["rvnmix"] = _pythia8.SusyLesHouches_rvnmix_get
//    if _newclass:
//        rvnmix = _swig_property(_pythia8.SusyLesHouches_rvnmix_get, _pythia8.SusyLesHouches_rvnmix_set)
//    __swig_setmethods__["rvumix"] = _pythia8.SusyLesHouches_rvumix_set
//    __swig_getmethods__["rvumix"] = _pythia8.SusyLesHouches_rvumix_get
//    if _newclass:
//        rvumix = _swig_property(_pythia8.SusyLesHouches_rvumix_get, _pythia8.SusyLesHouches_rvumix_set)
//    __swig_setmethods__["rvvmix"] = _pythia8.SusyLesHouches_rvvmix_set
//    __swig_getmethods__["rvvmix"] = _pythia8.SusyLesHouches_rvvmix_get
//    if _newclass:
//        rvvmix = _swig_property(_pythia8.SusyLesHouches_rvvmix_get, _pythia8.SusyLesHouches_rvvmix_set)
//    __swig_setmethods__["rvhmix"] = _pythia8.SusyLesHouches_rvhmix_set
//    __swig_getmethods__["rvhmix"] = _pythia8.SusyLesHouches_rvhmix_get
//    if _newclass:
//        rvhmix = _swig_property(_pythia8.SusyLesHouches_rvhmix_get, _pythia8.SusyLesHouches_rvhmix_set)
//    __swig_setmethods__["rvamix"] = _pythia8.SusyLesHouches_rvamix_set
//    __swig_getmethods__["rvamix"] = _pythia8.SusyLesHouches_rvamix_get
//    if _newclass:
//        rvamix = _swig_property(_pythia8.SusyLesHouches_rvamix_get, _pythia8.SusyLesHouches_rvamix_set)
//    __swig_setmethods__["rvlmix"] = _pythia8.SusyLesHouches_rvlmix_set
//    __swig_getmethods__["rvlmix"] = _pythia8.SusyLesHouches_rvlmix_get
//    if _newclass:
//        rvlmix = _swig_property(_pythia8.SusyLesHouches_rvlmix_get, _pythia8.SusyLesHouches_rvlmix_set)
//    __swig_setmethods__["imminpar"] = _pythia8.SusyLesHouches_imminpar_set
//    __swig_getmethods__["imminpar"] = _pythia8.SusyLesHouches_imminpar_get
//    if _newclass:
//        imminpar = _swig_property(_pythia8.SusyLesHouches_imminpar_get, _pythia8.SusyLesHouches_imminpar_set)
//    __swig_setmethods__["imextpar"] = _pythia8.SusyLesHouches_imextpar_set
//    __swig_getmethods__["imextpar"] = _pythia8.SusyLesHouches_imextpar_get
//    if _newclass:
//        imextpar = _swig_property(_pythia8.SusyLesHouches_imextpar_get, _pythia8.SusyLesHouches_imextpar_set)
//    __swig_setmethods__["cvhmix"] = _pythia8.SusyLesHouches_cvhmix_set
//    __swig_getmethods__["cvhmix"] = _pythia8.SusyLesHouches_cvhmix_get
//    if _newclass:
//        cvhmix = _swig_property(_pythia8.SusyLesHouches_cvhmix_get, _pythia8.SusyLesHouches_cvhmix_set)
//    __swig_setmethods__["imcvhmix"] = _pythia8.SusyLesHouches_imcvhmix_set
//    __swig_getmethods__["imcvhmix"] = _pythia8.SusyLesHouches_imcvhmix_get
//    if _newclass:
//        imcvhmix = _swig_property(_pythia8.SusyLesHouches_imcvhmix_get, _pythia8.SusyLesHouches_imcvhmix_set)
//    __swig_setmethods__["imau"] = _pythia8.SusyLesHouches_imau_set
//    __swig_getmethods__["imau"] = _pythia8.SusyLesHouches_imau_get
//    if _newclass:
//        imau = _swig_property(_pythia8.SusyLesHouches_imau_get, _pythia8.SusyLesHouches_imau_set)
//    __swig_setmethods__["imad"] = _pythia8.SusyLesHouches_imad_set
//    __swig_getmethods__["imad"] = _pythia8.SusyLesHouches_imad_get
//    if _newclass:
//        imad = _swig_property(_pythia8.SusyLesHouches_imad_get, _pythia8.SusyLesHouches_imad_set)
//    __swig_setmethods__["imae"] = _pythia8.SusyLesHouches_imae_set
//    __swig_getmethods__["imae"] = _pythia8.SusyLesHouches_imae_get
//    if _newclass:
//        imae = _swig_property(_pythia8.SusyLesHouches_imae_get, _pythia8.SusyLesHouches_imae_set)
//    __swig_setmethods__["imhmix"] = _pythia8.SusyLesHouches_imhmix_set
//    __swig_getmethods__["imhmix"] = _pythia8.SusyLesHouches_imhmix_get
//    if _newclass:
//        imhmix = _swig_property(_pythia8.SusyLesHouches_imhmix_get, _pythia8.SusyLesHouches_imhmix_set)
//    __swig_setmethods__["immsoft"] = _pythia8.SusyLesHouches_immsoft_set
//    __swig_getmethods__["immsoft"] = _pythia8.SusyLesHouches_immsoft_get
//    if _newclass:
//        immsoft = _swig_property(_pythia8.SusyLesHouches_immsoft_get, _pythia8.SusyLesHouches_immsoft_set)
//    __swig_setmethods__["immsq2in"] = _pythia8.SusyLesHouches_immsq2in_set
//    __swig_getmethods__["immsq2in"] = _pythia8.SusyLesHouches_immsq2in_get
//    if _newclass:
//        immsq2in = _swig_property(_pythia8.SusyLesHouches_immsq2in_get, _pythia8.SusyLesHouches_immsq2in_set)
//    __swig_setmethods__["immsu2in"] = _pythia8.SusyLesHouches_immsu2in_set
//    __swig_getmethods__["immsu2in"] = _pythia8.SusyLesHouches_immsu2in_get
//    if _newclass:
//        immsu2in = _swig_property(_pythia8.SusyLesHouches_immsu2in_get, _pythia8.SusyLesHouches_immsu2in_set)
//    __swig_setmethods__["immsd2in"] = _pythia8.SusyLesHouches_immsd2in_set
//    __swig_getmethods__["immsd2in"] = _pythia8.SusyLesHouches_immsd2in_get
//    if _newclass:
//        immsd2in = _swig_property(_pythia8.SusyLesHouches_immsd2in_get, _pythia8.SusyLesHouches_immsd2in_set)
//    __swig_setmethods__["immsl2in"] = _pythia8.SusyLesHouches_immsl2in_set
//    __swig_getmethods__["immsl2in"] = _pythia8.SusyLesHouches_immsl2in_get
//    if _newclass:
//        immsl2in = _swig_property(_pythia8.SusyLesHouches_immsl2in_get, _pythia8.SusyLesHouches_immsl2in_set)
//    __swig_setmethods__["immse2in"] = _pythia8.SusyLesHouches_immse2in_set
//    __swig_getmethods__["immse2in"] = _pythia8.SusyLesHouches_immse2in_get
//    if _newclass:
//        immse2in = _swig_property(_pythia8.SusyLesHouches_immse2in_get, _pythia8.SusyLesHouches_immse2in_set)
//    __swig_setmethods__["imtuin"] = _pythia8.SusyLesHouches_imtuin_set
//    __swig_getmethods__["imtuin"] = _pythia8.SusyLesHouches_imtuin_get
//    if _newclass:
//        imtuin = _swig_property(_pythia8.SusyLesHouches_imtuin_get, _pythia8.SusyLesHouches_imtuin_set)
//    __swig_setmethods__["imtdin"] = _pythia8.SusyLesHouches_imtdin_set
//    __swig_getmethods__["imtdin"] = _pythia8.SusyLesHouches_imtdin_get
//    if _newclass:
//        imtdin = _swig_property(_pythia8.SusyLesHouches_imtdin_get, _pythia8.SusyLesHouches_imtdin_set)
//    __swig_setmethods__["imtein"] = _pythia8.SusyLesHouches_imtein_set
//    __swig_getmethods__["imtein"] = _pythia8.SusyLesHouches_imtein_get
//    if _newclass:
//        imtein = _swig_property(_pythia8.SusyLesHouches_imtein_get, _pythia8.SusyLesHouches_imtein_set)
//    __swig_setmethods__["imvckm"] = _pythia8.SusyLesHouches_imvckm_set
//    __swig_getmethods__["imvckm"] = _pythia8.SusyLesHouches_imvckm_get
//    if _newclass:
//        imvckm = _swig_property(_pythia8.SusyLesHouches_imvckm_get, _pythia8.SusyLesHouches_imvckm_set)
//    __swig_setmethods__["imupmns"] = _pythia8.SusyLesHouches_imupmns_set
//    __swig_getmethods__["imupmns"] = _pythia8.SusyLesHouches_imupmns_get
//    if _newclass:
//        imupmns = _swig_property(_pythia8.SusyLesHouches_imupmns_get, _pythia8.SusyLesHouches_imupmns_set)
//    __swig_setmethods__["immsq2"] = _pythia8.SusyLesHouches_immsq2_set
//    __swig_getmethods__["immsq2"] = _pythia8.SusyLesHouches_immsq2_get
//    if _newclass:
//        immsq2 = _swig_property(_pythia8.SusyLesHouches_immsq2_get, _pythia8.SusyLesHouches_immsq2_set)
//    __swig_setmethods__["immsu2"] = _pythia8.SusyLesHouches_immsu2_set
//    __swig_getmethods__["immsu2"] = _pythia8.SusyLesHouches_immsu2_get
//    if _newclass:
//        immsu2 = _swig_property(_pythia8.SusyLesHouches_immsu2_get, _pythia8.SusyLesHouches_immsu2_set)
//    __swig_setmethods__["immsd2"] = _pythia8.SusyLesHouches_immsd2_set
//    __swig_getmethods__["immsd2"] = _pythia8.SusyLesHouches_immsd2_get
//    if _newclass:
//        immsd2 = _swig_property(_pythia8.SusyLesHouches_immsd2_get, _pythia8.SusyLesHouches_immsd2_set)
//    __swig_setmethods__["immsl2"] = _pythia8.SusyLesHouches_immsl2_set
//    __swig_getmethods__["immsl2"] = _pythia8.SusyLesHouches_immsl2_get
//    if _newclass:
//        immsl2 = _swig_property(_pythia8.SusyLesHouches_immsl2_get, _pythia8.SusyLesHouches_immsl2_set)
//    __swig_setmethods__["immse2"] = _pythia8.SusyLesHouches_immse2_set
//    __swig_getmethods__["immse2"] = _pythia8.SusyLesHouches_immse2_get
//    if _newclass:
//        immse2 = _swig_property(_pythia8.SusyLesHouches_immse2_get, _pythia8.SusyLesHouches_immse2_set)
//    __swig_setmethods__["imtu"] = _pythia8.SusyLesHouches_imtu_set
//    __swig_getmethods__["imtu"] = _pythia8.SusyLesHouches_imtu_get
//    if _newclass:
//        imtu = _swig_property(_pythia8.SusyLesHouches_imtu_get, _pythia8.SusyLesHouches_imtu_set)
//    __swig_setmethods__["imtd"] = _pythia8.SusyLesHouches_imtd_set
//    __swig_getmethods__["imtd"] = _pythia8.SusyLesHouches_imtd_get
//    if _newclass:
//        imtd = _swig_property(_pythia8.SusyLesHouches_imtd_get, _pythia8.SusyLesHouches_imtd_set)
//    __swig_setmethods__["imte"] = _pythia8.SusyLesHouches_imte_set
//    __swig_getmethods__["imte"] = _pythia8.SusyLesHouches_imte_get
//    if _newclass:
//        imte = _swig_property(_pythia8.SusyLesHouches_imte_get, _pythia8.SusyLesHouches_imte_set)
//    __swig_setmethods__["imusqmix"] = _pythia8.SusyLesHouches_imusqmix_set
//    __swig_getmethods__["imusqmix"] = _pythia8.SusyLesHouches_imusqmix_get
//    if _newclass:
//        imusqmix = _swig_property(_pythia8.SusyLesHouches_imusqmix_get, _pythia8.SusyLesHouches_imusqmix_set)
//    __swig_setmethods__["imdsqmix"] = _pythia8.SusyLesHouches_imdsqmix_set
//    __swig_getmethods__["imdsqmix"] = _pythia8.SusyLesHouches_imdsqmix_get
//    if _newclass:
//        imdsqmix = _swig_property(_pythia8.SusyLesHouches_imdsqmix_get, _pythia8.SusyLesHouches_imdsqmix_set)
//    __swig_setmethods__["imselmix"] = _pythia8.SusyLesHouches_imselmix_set
//    __swig_getmethods__["imselmix"] = _pythia8.SusyLesHouches_imselmix_get
//    if _newclass:
//        imselmix = _swig_property(_pythia8.SusyLesHouches_imselmix_get, _pythia8.SusyLesHouches_imselmix_set)
//    __swig_setmethods__["imsnumix"] = _pythia8.SusyLesHouches_imsnumix_set
//    __swig_getmethods__["imsnumix"] = _pythia8.SusyLesHouches_imsnumix_get
//    if _newclass:
//        imsnumix = _swig_property(_pythia8.SusyLesHouches_imsnumix_get, _pythia8.SusyLesHouches_imsnumix_set)
//    __swig_setmethods__["imnmix"] = _pythia8.SusyLesHouches_imnmix_set
//    __swig_getmethods__["imnmix"] = _pythia8.SusyLesHouches_imnmix_get
//    if _newclass:
//        imnmix = _swig_property(_pythia8.SusyLesHouches_imnmix_get, _pythia8.SusyLesHouches_imnmix_set)
//    __swig_setmethods__["imumix"] = _pythia8.SusyLesHouches_imumix_set
//    __swig_getmethods__["imumix"] = _pythia8.SusyLesHouches_imumix_get
//    if _newclass:
//        imumix = _swig_property(_pythia8.SusyLesHouches_imumix_get, _pythia8.SusyLesHouches_imumix_set)
//    __swig_setmethods__["imvmix"] = _pythia8.SusyLesHouches_imvmix_set
//    __swig_getmethods__["imvmix"] = _pythia8.SusyLesHouches_imvmix_get
//    if _newclass:
//        imvmix = _swig_property(_pythia8.SusyLesHouches_imvmix_get, _pythia8.SusyLesHouches_imvmix_set)
//    __swig_setmethods__["nmssmrun"] = _pythia8.SusyLesHouches_nmssmrun_set
//    __swig_getmethods__["nmssmrun"] = _pythia8.SusyLesHouches_nmssmrun_get
//    if _newclass:
//        nmssmrun = _swig_property(_pythia8.SusyLesHouches_nmssmrun_get, _pythia8.SusyLesHouches_nmssmrun_set)
//    __swig_setmethods__["nmhmix"] = _pythia8.SusyLesHouches_nmhmix_set
//    __swig_getmethods__["nmhmix"] = _pythia8.SusyLesHouches_nmhmix_get
//    if _newclass:
//        nmhmix = _swig_property(_pythia8.SusyLesHouches_nmhmix_get, _pythia8.SusyLesHouches_nmhmix_set)
//    __swig_setmethods__["nmamix"] = _pythia8.SusyLesHouches_nmamix_set
//    __swig_getmethods__["nmamix"] = _pythia8.SusyLesHouches_nmamix_get
//    if _newclass:
//        nmamix = _swig_property(_pythia8.SusyLesHouches_nmamix_get, _pythia8.SusyLesHouches_nmamix_set)
//    __swig_setmethods__["nmnmix"] = _pythia8.SusyLesHouches_nmnmix_set
//    __swig_getmethods__["nmnmix"] = _pythia8.SusyLesHouches_nmnmix_get
//    if _newclass:
//        nmnmix = _swig_property(_pythia8.SusyLesHouches_nmnmix_get, _pythia8.SusyLesHouches_nmnmix_set)
//    __swig_setmethods__["imnmnmix"] = _pythia8.SusyLesHouches_imnmnmix_set
//    __swig_getmethods__["imnmnmix"] = _pythia8.SusyLesHouches_imnmnmix_get
//    if _newclass:
//        imnmnmix = _swig_property(_pythia8.SusyLesHouches_imnmnmix_get, _pythia8.SusyLesHouches_imnmnmix_set)
//    __swig_setmethods__["genericBlocks"] = _pythia8.SusyLesHouches_genericBlocks_set
//    __swig_getmethods__["genericBlocks"] = _pythia8.SusyLesHouches_genericBlocks_get
//    if _newclass:
//        genericBlocks = _swig_property(_pythia8.SusyLesHouches_genericBlocks_get, _pythia8.SusyLesHouches_genericBlocks_set)
//
//    def verbose(self, *args):
//        return _pythia8.SusyLesHouches_verbose(self, *args)
//
//    def message(self, arg2, arg3, arg4, line=0):
//        return _pythia8.SusyLesHouches_message(self, arg2, arg3, arg4, line)
//    __swig_destroy__ = _pythia8.delete_SusyLesHouches
//    __del__ = lambda self: None
//SusyLesHouches_swigregister = _pythia8.SusyLesHouches_swigregister
//SusyLesHouches_swigregister(SusyLesHouches)
//
//class WeakShowerMEs(_object):
//    """
//The WeakShowerMEs provides ME's needed for W/Z emission in ISR or FSR.
//The 2 -> 2 MEs contain the correct kinematics, but for some of
//the 2 -> 3 MEs some couplings have been switched off.
//This class is used for ME corrections in the weak shower and for merging
//whenever weak reclusterings are allowed.
//Also be aware that no phase-space factors are included.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, WeakShowerMEs, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, WeakShowerMEs, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_WeakShowerMEs()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def getMEqg2qg(self, sH, tH, uH):
//        """
//Calculate the 2 to 2 ME qg -> qg, up to a known overall factor.
//"""
//        return _pythia8.WeakShowerMEs_getMEqg2qg(self, sH, tH, uH)
//
//    def getMEqq2qq(self, sH, tH, uH, sameID):
//        """
//Calculate the 2 to 2 ME qq -> qq, up to a known overall factor.
//"""
//        return _pythia8.WeakShowerMEs_getMEqq2qq(self, sH, tH, uH, sameID)
//
//    def getMEgg2gg(self, sH, tH, uH):
//        """
//Calculate the 2 to 2 ME gg -> gg, up to a known overall factor.
//"""
//        return _pythia8.WeakShowerMEs_getMEgg2gg(self, sH, tH, uH)
//
//    def getMEgg2qqbar(self, sH, tH, uH):
//        """
//Calculate the 2 to 2 ME gg -> qqbar, up to a known overall factor.
//"""
//        return _pythia8.WeakShowerMEs_getMEgg2qqbar(self, sH, tH, uH)
//
//    def getMEqqbar2gg(self, sH, tH, uH):
//        """
//Calculate the 2 to 2 ME qqbar -> gg, up to a known overall factor.
//"""
//        return _pythia8.WeakShowerMEs_getMEqqbar2gg(self, sH, tH, uH)
//
//    def getMEqqbar2qqbar(self, sH, tH, uH, sameID):
//        """
//Calculate the 2 to 2 ME qqbar -> qqbar, up to a known overall factor.
//"""
//        return _pythia8.WeakShowerMEs_getMEqqbar2qqbar(self, sH, tH, uH, sameID)
//
//    def getMEqg2qgZ(self, p1, p2, p3, p4, p5):
//        """
//Calculate the 2 to 3 ME uG -> uGZ, up to a known overall factor.
//"""
//        return _pythia8.WeakShowerMEs_getMEqg2qgZ(self, p1, p2, p3, p4, p5)
//
//    def getMEqq2qqZ(self, p1, p2, p3, p4, p5):
//        """
//Calculate the 2 to 3 ME ud -> udZ, up to a known overall factor,
//and with the coupling between Z and d set to zero.
//"""
//        return _pythia8.WeakShowerMEs_getMEqq2qqZ(self, p1, p2, p3, p4, p5)
//    __swig_destroy__ = _pythia8.delete_WeakShowerMEs
//    __del__ = lambda self: None
//WeakShowerMEs_swigregister = _pythia8.WeakShowerMEs_swigregister
//WeakShowerMEs_swigregister(WeakShowerMEs)
//
//class Info(_object):
//    """
//The Info class contains a mixed bag of information on the event
//generation activity, especially on the current subprocess properties,
//and on the number of errors encountered. This is used by the
//generation machinery, but can also be read by the user.
//Note: some methods that maybe should not be accessible to the user
//are still public, to work also for user-written FSR/ISR classes.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Info, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, Info, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Info()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def idA(self):
//        """
//Beam particles (in rest frame). CM energy of event.
//"""
//        return _pythia8.Info_idA(self)
//
//    def idB(self):
//        """
//"""
//        return _pythia8.Info_idB(self)
//
//    def pzA(self):
//        """
//"""
//        return _pythia8.Info_pzA(self)
//
//    def pzB(self):
//        """
//"""
//        return _pythia8.Info_pzB(self)
//
//    def eA(self):
//        """
//"""
//        return _pythia8.Info_eA(self)
//
//    def eB(self):
//        """
//"""
//        return _pythia8.Info_eB(self)
//
//    def mA(self):
//        """
//"""
//        return _pythia8.Info_mA(self)
//
//    def mB(self):
//        """
//"""
//        return _pythia8.Info_mB(self)
//
//    def eCM(self):
//        """
//"""
//        return _pythia8.Info_eCM(self)
//
//    def s(self):
//        """
//"""
//        return _pythia8.Info_s(self)
//
//    def tooLowPTmin(self):
//        """
//Warnings from initialization.
//"""
//        return _pythia8.Info_tooLowPTmin(self)
//
//    def name(self):
//        """
//Process name and code, and the number of final-state particles.
//"""
//        return _pythia8.Info_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Info_code(self)
//
//    def nFinal(self):
//        """
//"""
//        return _pythia8.Info_nFinal(self)
//
//    def isResolved(self):
//        """
//Are beam particles resolved, with pdf's? Are they diffractive?
//"""
//        return _pythia8.Info_isResolved(self)
//
//    def isDiffractiveA(self):
//        """
//"""
//        return _pythia8.Info_isDiffractiveA(self)
//
//    def isDiffractiveB(self):
//        """
//"""
//        return _pythia8.Info_isDiffractiveB(self)
//
//    def isDiffractiveC(self):
//        """
//"""
//        return _pythia8.Info_isDiffractiveC(self)
//
//    def isNonDiffractive(self):
//        """
//"""
//        return _pythia8.Info_isNonDiffractive(self)
//
//    def isMinBias(self):
//        """
//Retained for backwards compatibility.
//"""
//        return _pythia8.Info_isMinBias(self)
//
//    def isLHA(self):
//        """
//Information for Les Houches Accord and reading files.
//"""
//        return _pythia8.Info_isLHA(self)
//
//    def atEndOfFile(self):
//        """
//"""
//        return _pythia8.Info_atEndOfFile(self)
//
//    def hasSub(self, i=0):
//        """
//For nondiffractive and Les Houches Accord identify hardest subprocess.
//"""
//        return _pythia8.Info_hasSub(self, i)
//
//    def nameSub(self, i=0):
//        """
//"""
//        return _pythia8.Info_nameSub(self, i)
//
//    def codeSub(self, i=0):
//        """
//"""
//        return _pythia8.Info_codeSub(self, i)
//
//    def nFinalSub(self, i=0):
//        """
//"""
//        return _pythia8.Info_nFinalSub(self, i)
//
//    def id1(self, i=0):
//        """
//Incoming parton flavours and x values.
//"""
//        return _pythia8.Info_id1(self, i)
//
//    def id2(self, i=0):
//        """
//"""
//        return _pythia8.Info_id2(self, i)
//
//    def x1(self, i=0):
//        """
//"""
//        return _pythia8.Info_x1(self, i)
//
//    def x2(self, i=0):
//        """
//"""
//        return _pythia8.Info_x2(self, i)
//
//    def y(self, i=0):
//        """
//"""
//        return _pythia8.Info_y(self, i)
//
//    def tau(self, i=0):
//        """
//"""
//        return _pythia8.Info_tau(self, i)
//
//    def id1pdf(self, i=0):
//        """
//Hard process flavours, x values, parton densities, couplings, Q2 scales.
//"""
//        return _pythia8.Info_id1pdf(self, i)
//
//    def id2pdf(self, i=0):
//        """
//"""
//        return _pythia8.Info_id2pdf(self, i)
//
//    def x1pdf(self, i=0):
//        """
//"""
//        return _pythia8.Info_x1pdf(self, i)
//
//    def x2pdf(self, i=0):
//        """
//"""
//        return _pythia8.Info_x2pdf(self, i)
//
//    def pdf1(self, i=0):
//        """
//"""
//        return _pythia8.Info_pdf1(self, i)
//
//    def pdf2(self, i=0):
//        """
//"""
//        return _pythia8.Info_pdf2(self, i)
//
//    def QFac(self, i=0):
//        """
//"""
//        return _pythia8.Info_QFac(self, i)
//
//    def Q2Fac(self, i=0):
//        """
//"""
//        return _pythia8.Info_Q2Fac(self, i)
//
//    def isValence1(self):
//        """
//"""
//        return _pythia8.Info_isValence1(self)
//
//    def isValence2(self):
//        """
//"""
//        return _pythia8.Info_isValence2(self)
//
//    def alphaS(self, i=0):
//        """
//"""
//        return _pythia8.Info_alphaS(self, i)
//
//    def alphaEM(self, i=0):
//        """
//"""
//        return _pythia8.Info_alphaEM(self, i)
//
//    def QRen(self, i=0):
//        """
//"""
//        return _pythia8.Info_QRen(self, i)
//
//    def Q2Ren(self, i=0):
//        """
//"""
//        return _pythia8.Info_Q2Ren(self, i)
//
//    def scalup(self, i=0):
//        """
//"""
//        return _pythia8.Info_scalup(self, i)
//
//    def xGammaA(self):
//        """
//Kinematics of photons from lepton beams.
//"""
//        return _pythia8.Info_xGammaA(self)
//
//    def xGammaB(self):
//        """
//"""
//        return _pythia8.Info_xGammaB(self)
//
//    def Q2GammaA(self):
//        """
//"""
//        return _pythia8.Info_Q2GammaA(self)
//
//    def Q2GammaB(self):
//        """
//"""
//        return _pythia8.Info_Q2GammaB(self)
//
//    def eCMsub(self):
//        """
//"""
//        return _pythia8.Info_eCMsub(self)
//
//    def thetaScatLepA(self):
//        """
//"""
//        return _pythia8.Info_thetaScatLepA(self)
//
//    def thetaScatLepB(self):
//        """
//"""
//        return _pythia8.Info_thetaScatLepB(self)
//
//    def sHatNew(self):
//        """
//"""
//        return _pythia8.Info_sHatNew(self)
//
//    def photonMode(self):
//        """
//"""
//        return _pythia8.Info_photonMode(self)
//
//    def isVMDstateA(self):
//        """
//Information on VMD state inside a photon.
//"""
//        return _pythia8.Info_isVMDstateA(self)
//
//    def isVMDstateB(self):
//        """
//"""
//        return _pythia8.Info_isVMDstateB(self)
//
//    def idVMDA(self):
//        """
//"""
//        return _pythia8.Info_idVMDA(self)
//
//    def idVMDB(self):
//        """
//"""
//        return _pythia8.Info_idVMDB(self)
//
//    def mVMDA(self):
//        """
//"""
//        return _pythia8.Info_mVMDA(self)
//
//    def mVMDB(self):
//        """
//"""
//        return _pythia8.Info_mVMDB(self)
//
//    def scaleVMDA(self):
//        """
//"""
//        return _pythia8.Info_scaleVMDA(self)
//
//    def scaleVMDB(self):
//        """
//"""
//        return _pythia8.Info_scaleVMDB(self)
//
//    def mHat(self, i=0):
//        """
//Mandelstam variables (notation as if subcollision).
//"""
//        return _pythia8.Info_mHat(self, i)
//
//    def sHat(self, i=0):
//        """
//"""
//        return _pythia8.Info_sHat(self, i)
//
//    def tHat(self, i=0):
//        """
//"""
//        return _pythia8.Info_tHat(self, i)
//
//    def uHat(self, i=0):
//        """
//"""
//        return _pythia8.Info_uHat(self, i)
//
//    def pTHat(self, i=0):
//        """
//"""
//        return _pythia8.Info_pTHat(self, i)
//
//    def pT2Hat(self, i=0):
//        """
//"""
//        return _pythia8.Info_pT2Hat(self, i)
//
//    def m3Hat(self, i=0):
//        """
//"""
//        return _pythia8.Info_m3Hat(self, i)
//
//    def m4Hat(self, i=0):
//        """
//"""
//        return _pythia8.Info_m4Hat(self, i)
//
//    def thetaHat(self, i=0):
//        """
//"""
//        return _pythia8.Info_thetaHat(self, i)
//
//    def phiHat(self, i=0):
//        """
//"""
//        return _pythia8.Info_phiHat(self, i)
//
//    def weight(self, i=0):
//        """
//Weight of current event; normally 1, but used for Les Houches events
//or when reweighting phase space selection. Conversion from mb to pb
//for LHA strategy +-4. Uncertainty variations can be accessed by
//providing an index >= 1 (0 = no variations). Also cumulative sum.
//"""
//        return _pythia8.Info_weight(self, i)
//
//    def weightSum(self):
//        """
//"""
//        return _pythia8.Info_weightSum(self)
//
//    def lhaStrategy(self):
//        """
//"""
//        return _pythia8.Info_lhaStrategy(self)
//
//    def nWeights(self):
//        """
//Further access to uncertainty weights: number and labels
//"""
//        return _pythia8.Info_nWeights(self)
//
//    def weightLabel(self, iWeight):
//        """
//"""
//        return _pythia8.Info_weightLabel(self, iWeight)
//
//    def initUncertainties(self, arg2, arg3=False):
//        """
//"""
//        return _pythia8.Info_initUncertainties(self, arg2, arg3)
//
//    def nVariationGroups(self):
//        """
//"""
//        return _pythia8.Info_nVariationGroups(self)
//
//    def getGroupName(self, iGN):
//        """
//"""
//        return _pythia8.Info_getGroupName(self, iGN)
//
//    def getGroupWeight(self, iGW):
//        """
//"""
//        return _pythia8.Info_getGroupWeight(self, iGW)
//
//    def getInitialName(self, iG):
//        """
//"""
//        return _pythia8.Info_getInitialName(self, iG)
//    __swig_setmethods__["varPDFplus"] = _pythia8.Info_varPDFplus_set
//    __swig_getmethods__["varPDFplus"] = _pythia8.Info_varPDFplus_get
//    if _newclass:
//        varPDFplus = _swig_property(_pythia8.Info_varPDFplus_get, _pythia8.Info_varPDFplus_set)
//    __swig_setmethods__["varPDFminus"] = _pythia8.Info_varPDFminus_set
//    __swig_getmethods__["varPDFminus"] = _pythia8.Info_varPDFminus_get
//    if _newclass:
//        varPDFminus = _swig_property(_pythia8.Info_varPDFminus_get, _pythia8.Info_varPDFminus_set)
//    __swig_setmethods__["varPDFmember"] = _pythia8.Info_varPDFmember_set
//    __swig_getmethods__["varPDFmember"] = _pythia8.Info_varPDFmember_get
//    if _newclass:
//        varPDFmember = _swig_property(_pythia8.Info_varPDFmember_get, _pythia8.Info_varPDFmember_set)
//
//    def nISR(self):
//        """
//Variations that must be known by TimeShower and Spaceshower
//Number of times other steps have been carried out.
//"""
//        return _pythia8.Info_nISR(self)
//
//    def nFSRinProc(self):
//        """
//"""
//        return _pythia8.Info_nFSRinProc(self)
//
//    def nFSRinRes(self):
//        """
//"""
//        return _pythia8.Info_nFSRinRes(self)
//
//    def pTmaxMPI(self):
//        """
//Maximum pT scales for MPI, ISR and FSR (in hard process).
//"""
//        return _pythia8.Info_pTmaxMPI(self)
//
//    def pTmaxISR(self):
//        """
//"""
//        return _pythia8.Info_pTmaxISR(self)
//
//    def pTmaxFSR(self):
//        """
//"""
//        return _pythia8.Info_pTmaxFSR(self)
//
//    def pTnow(self):
//        """
//Current evolution scale (for UserHooks).
//"""
//        return _pythia8.Info_pTnow(self)
//
//    def a0MPI(self):
//        """
//Impact parameter picture, global information
//"""
//        return _pythia8.Info_a0MPI(self)
//
//    def bMPI(self):
//        """
//Impact parameter picture, as set by hardest interaction.
//"""
//        return _pythia8.Info_bMPI(self)
//
//    def enhanceMPI(self):
//        """
//"""
//        return _pythia8.Info_enhanceMPI(self)
//
//    def enhanceMPIavg(self):
//        """
//"""
//        return _pythia8.Info_enhanceMPIavg(self)
//
//    def eMPI(self, i):
//        """
//"""
//        return _pythia8.Info_eMPI(self, i)
//
//    def bMPIold(self):
//        """
//"""
//        return _pythia8.Info_bMPIold(self)
//
//    def enhanceMPIold(self):
//        """
//"""
//        return _pythia8.Info_enhanceMPIold(self)
//
//    def enhanceMPIoldavg(self):
//        """
//"""
//        return _pythia8.Info_enhanceMPIoldavg(self)
//
//    def nMPI(self):
//        """
//Number of multiparton interactions, with code and pT for them.
//"""
//        return _pythia8.Info_nMPI(self)
//
//    def codeMPI(self, i):
//        """
//"""
//        return _pythia8.Info_codeMPI(self, i)
//
//    def pTMPI(self, i):
//        """
//"""
//        return _pythia8.Info_pTMPI(self, i)
//
//    def iAMPI(self, i):
//        """
//"""
//        return _pythia8.Info_iAMPI(self, i)
//
//    def iBMPI(self, i):
//        """
//"""
//        return _pythia8.Info_iBMPI(self, i)
//
//    def codesHard(self):
//        """
//Cross section estimate, optionally process by process.
//"""
//        return _pythia8.Info_codesHard(self)
//
//    def nameProc(self, i=0):
//        """
//"""
//        return _pythia8.Info_nameProc(self, i)
//
//    def nTried(self, i=0):
//        """
//"""
//        return _pythia8.Info_nTried(self, i)
//
//    def nSelected(self, i=0):
//        """
//"""
//        return _pythia8.Info_nSelected(self, i)
//
//    def nAccepted(self, i=0):
//        """
//"""
//        return _pythia8.Info_nAccepted(self, i)
//
//    def sigmaGen(self, i=0):
//        """
//"""
//        return _pythia8.Info_sigmaGen(self, i)
//
//    def sigmaErr(self, i=0):
//        """
//"""
//        return _pythia8.Info_sigmaErr(self, i)
//
//    def getCounter(self, i):
//        """
//Counters for number of loops in various places.
//"""
//        return _pythia8.Info_getCounter(self, i)
//
//    def setCounter(self, i, value=0):
//        """
//Set or increase the value stored in a counter.
//"""
//        return _pythia8.Info_setCounter(self, i, value)
//
//    def addCounter(self, i, value=1):
//        """
//"""
//        return _pythia8.Info_addCounter(self, i, value)
//
//    def errorReset(self):
//        """
//Reset to empty map of error messages.
//"""
//        return _pythia8.Info_errorReset(self)
//
//    def errorMsg(self, *args):
//        """
//Print a message the first few times. Insert in database.
//"""
//        return _pythia8.Info_errorMsg(self, *args)
//
//    def errorTotalNumber(self):
//        """
//Provide total number of errors/aborts/warnings experienced to date.
//"""
//        return _pythia8.Info_errorTotalNumber(self)
//
//    def errorStatistics(self):
//        """
//Print statistics on errors/aborts/warnings.
//"""
//        return _pythia8.Info_errorStatistics(self)
//
//    def setTooLowPTmin(self, lowPTminIn):
//        """
//Set initialization warning flag when too low pTmin in ISR/FSR/MPI.
//"""
//        return _pythia8.Info_setTooLowPTmin(self, lowPTminIn)
//
//    def setValence(self, isVal1In, isVal2In):
//        """
//Set info on valence character of hard collision partons.
//"""
//        return _pythia8.Info_setValence(self, isVal1In, isVal2In)
//
//    def hasHistory(self, *args):
//        """
//"""
//        return _pythia8.Info_hasHistory(self, *args)
//
//    def zNowISR(self, *args):
//        """
//"""
//        return _pythia8.Info_zNowISR(self, *args)
//
//    def pT2NowISR(self, *args):
//        """
//"""
//        return _pythia8.Info_pT2NowISR(self, *args)
//
//    def updateWeight(self, weightIn, i=0):
//        """
//Update a particular event weight, first entry by default.
//"""
//        return _pythia8.Info_updateWeight(self, weightIn, i)
//
//    def getWeightCKKWL(self):
//        """
//Return CKKW-L weight.
//"""
//        return _pythia8.Info_getWeightCKKWL(self)
//
//    def setWeightCKKWL(self, weightIn):
//        """
//Set CKKW-L weight.
//"""
//        return _pythia8.Info_setWeightCKKWL(self, weightIn)
//
//    def mergingWeight(self):
//        """
//Return merging weight.
//"""
//        return _pythia8.Info_mergingWeight(self)
//
//    def mergingWeightNLO(self):
//        """
//Return the complete NLO weight.
//"""
//        return _pythia8.Info_mergingWeightNLO(self)
//
//    def getWeightFIRST(self):
//        """
//Return the O(\alpha_s)-term of the CKKW-L weight.
//"""
//        return _pythia8.Info_getWeightFIRST(self)
//
//    def setWeightFIRST(self, weightIn):
//        """
//Set the O(\alpha_s)-term of the CKKW-L weight.
//"""
//        return _pythia8.Info_setWeightFIRST(self, weightIn)
//
//    def header(self, key):
//        """
//Return an LHEF header
//"""
//        return _pythia8.Info_header(self, key)
//
//    def headerKeys(self):
//        """
//Return a list of all header key names
//"""
//        return _pythia8.Info_headerKeys(self)
//
//    def nProcessesLHEF(self):
//        """
//Return the number of processes in the LHEF.
//"""
//        return _pythia8.Info_nProcessesLHEF(self)
//
//    def sigmaLHEF(self, iProcess):
//        """
//Return the cross section information read from LHEF.
//"""
//        return _pythia8.Info_sigmaLHEF(self, iProcess)
//    __swig_setmethods__["LHEFversionSave"] = _pythia8.Info_LHEFversionSave_set
//    __swig_getmethods__["LHEFversionSave"] = _pythia8.Info_LHEFversionSave_get
//    if _newclass:
//        LHEFversionSave = _swig_property(_pythia8.Info_LHEFversionSave_get, _pythia8.Info_LHEFversionSave_set)
//    __swig_setmethods__["sigmaLHEFSave"] = _pythia8.Info_sigmaLHEFSave_set
//    __swig_getmethods__["sigmaLHEFSave"] = _pythia8.Info_sigmaLHEFSave_get
//    if _newclass:
//        sigmaLHEFSave = _swig_property(_pythia8.Info_sigmaLHEFSave_get, _pythia8.Info_sigmaLHEFSave_set)
//    __swig_setmethods__["initrwgt"] = _pythia8.Info_initrwgt_set
//    __swig_getmethods__["initrwgt"] = _pythia8.Info_initrwgt_get
//    if _newclass:
//        initrwgt = _swig_property(_pythia8.Info_initrwgt_get, _pythia8.Info_initrwgt_set)
//    __swig_setmethods__["generators"] = _pythia8.Info_generators_set
//    __swig_getmethods__["generators"] = _pythia8.Info_generators_get
//    if _newclass:
//        generators = _swig_property(_pythia8.Info_generators_get, _pythia8.Info_generators_set)
//    __swig_setmethods__["weightgroups"] = _pythia8.Info_weightgroups_set
//    __swig_getmethods__["weightgroups"] = _pythia8.Info_weightgroups_get
//    if _newclass:
//        weightgroups = _swig_property(_pythia8.Info_weightgroups_get, _pythia8.Info_weightgroups_set)
//    __swig_setmethods__["init_weights"] = _pythia8.Info_init_weights_set
//    __swig_getmethods__["init_weights"] = _pythia8.Info_init_weights_get
//    if _newclass:
//        init_weights = _swig_property(_pythia8.Info_init_weights_get, _pythia8.Info_init_weights_set)
//    __swig_setmethods__["eventAttributes"] = _pythia8.Info_eventAttributes_set
//    __swig_getmethods__["eventAttributes"] = _pythia8.Info_eventAttributes_get
//    if _newclass:
//        eventAttributes = _swig_property(_pythia8.Info_eventAttributes_get, _pythia8.Info_eventAttributes_set)
//    __swig_setmethods__["weights_detailed"] = _pythia8.Info_weights_detailed_set
//    __swig_getmethods__["weights_detailed"] = _pythia8.Info_weights_detailed_get
//    if _newclass:
//        weights_detailed = _swig_property(_pythia8.Info_weights_detailed_get, _pythia8.Info_weights_detailed_set)
//    __swig_setmethods__["weights_compressed"] = _pythia8.Info_weights_compressed_set
//    __swig_getmethods__["weights_compressed"] = _pythia8.Info_weights_compressed_get
//    if _newclass:
//        weights_compressed = _swig_property(_pythia8.Info_weights_compressed_get, _pythia8.Info_weights_compressed_set)
//    __swig_setmethods__["scales"] = _pythia8.Info_scales_set
//    __swig_getmethods__["scales"] = _pythia8.Info_scales_get
//    if _newclass:
//        scales = _swig_property(_pythia8.Info_scales_get, _pythia8.Info_scales_set)
//    __swig_setmethods__["weights"] = _pythia8.Info_weights_set
//    __swig_getmethods__["weights"] = _pythia8.Info_weights_get
//    if _newclass:
//        weights = _swig_property(_pythia8.Info_weights_get, _pythia8.Info_weights_set)
//    __swig_setmethods__["rwgt"] = _pythia8.Info_rwgt_set
//    __swig_getmethods__["rwgt"] = _pythia8.Info_rwgt_get
//    if _newclass:
//        rwgt = _swig_property(_pythia8.Info_rwgt_get, _pythia8.Info_rwgt_set)
//    __swig_setmethods__["eventWeightLHEF"] = _pythia8.Info_eventWeightLHEF_set
//    __swig_getmethods__["eventWeightLHEF"] = _pythia8.Info_eventWeightLHEF_get
//    if _newclass:
//        eventWeightLHEF = _swig_property(_pythia8.Info_eventWeightLHEF_get, _pythia8.Info_eventWeightLHEF_set)
//
//    def setLHEF3InitInfo(self, *args):
//        """
//"""
//        return _pythia8.Info_setLHEF3InitInfo(self, *args)
//
//    def setLHEF3EventInfo(self, *args):
//        """
//"""
//        return _pythia8.Info_setLHEF3EventInfo(self, *args)
//
//    def getEventAttribute(self, key, doRemoveWhitespace=False):
//        """
//Retrieve events tag information.
//"""
//        return _pythia8.Info_getEventAttribute(self, key, doRemoveWhitespace)
//
//    def LHEFversion(self):
//        """
//Retrieve LHEF version
//"""
//        return _pythia8.Info_LHEFversion(self)
//
//    def getInitrwgtSize(self):
//        """
//Retrieve initrwgt tag information.
//"""
//        return _pythia8.Info_getInitrwgtSize(self)
//
//    def getGeneratorSize(self):
//        """
//Retrieve generator tag information.
//"""
//        return _pythia8.Info_getGeneratorSize(self)
//
//    def getGeneratorValue(self, n=0):
//        """
//"""
//        return _pythia8.Info_getGeneratorValue(self, n)
//
//    def getGeneratorAttribute(self, n, key, doRemoveWhitespace=False):
//        """
//"""
//        return _pythia8.Info_getGeneratorAttribute(self, n, key, doRemoveWhitespace)
//
//    def getWeightsDetailedSize(self):
//        """
//Retrieve rwgt tag information.
//"""
//        return _pythia8.Info_getWeightsDetailedSize(self)
//
//    def getWeightsDetailedValue(self, n):
//        """
//"""
//        return _pythia8.Info_getWeightsDetailedValue(self, n)
//
//    def getWeightsDetailedAttribute(self, n, key, doRemoveWhitespace=False):
//        """
//"""
//        return _pythia8.Info_getWeightsDetailedAttribute(self, n, key, doRemoveWhitespace)
//
//    def getWeightsCompressedSize(self):
//        """
//Retrieve weights tag information.
//"""
//        return _pythia8.Info_getWeightsCompressedSize(self)
//
//    def getWeightsCompressedValue(self, n):
//        """
//"""
//        return _pythia8.Info_getWeightsCompressedValue(self, n)
//
//    def getWeightsCompressedAttribute(self, key, doRemoveWhitespace=False):
//        """
//"""
//        return _pythia8.Info_getWeightsCompressedAttribute(self, key, doRemoveWhitespace)
//
//    def getScalesValue(self, doRemoveWhitespace=False):
//        """
//Retrieve scales tag information.
//"""
//        return _pythia8.Info_getScalesValue(self, doRemoveWhitespace)
//
//    def getScalesAttribute(self, key):
//        """
//"""
//        return _pythia8.Info_getScalesAttribute(self, key)
//
//    def getHeaderBlock(self):
//        """
//Retrieve complete header block and event comments
//Retrieve scales tag information.
//"""
//        return _pythia8.Info_getHeaderBlock(self)
//
//    def getEventComments(self):
//        """
//"""
//        return _pythia8.Info_getEventComments(self)
//
//    def setHeader(self, key, val):
//        """
//Set LHEF headers
//"""
//        return _pythia8.Info_setHeader(self, key, val)
//
//    def setAbortPartonLevel(self, abortIn):
//        """
//Set abort in parton level.
//"""
//        return _pythia8.Info_setAbortPartonLevel(self, abortIn)
//
//    def getAbortPartonLevel(self):
//        """
//"""
//        return _pythia8.Info_getAbortPartonLevel(self)
//
//    def hasUnresolvedBeams(self):
//        """
//Get information on hard diffractive events.
//"""
//        return _pythia8.Info_hasUnresolvedBeams(self)
//
//    def hasPomPsystem(self):
//        """
//"""
//        return _pythia8.Info_hasPomPsystem(self)
//
//    def isHardDiffractive(self):
//        """
//"""
//        return _pythia8.Info_isHardDiffractive(self)
//
//    def isHardDiffractiveA(self):
//        """
//"""
//        return _pythia8.Info_isHardDiffractiveA(self)
//
//    def isHardDiffractiveB(self):
//        """
//"""
//        return _pythia8.Info_isHardDiffractiveB(self)
//
//    def xPomeronA(self):
//        """
//"""
//        return _pythia8.Info_xPomeronA(self)
//
//    def xPomeronB(self):
//        """
//"""
//        return _pythia8.Info_xPomeronB(self)
//
//    def tPomeronA(self):
//        """
//"""
//        return _pythia8.Info_tPomeronA(self)
//
//    def tPomeronB(self):
//        """
//"""
//        return _pythia8.Info_tPomeronB(self)
//
//    def getWeakModes(self):
//        """
//History information needed to setup the weak shower for 2 -> n.
//"""
//        return _pythia8.Info_getWeakModes(self)
//
//    def getWeakDipoles(self):
//        """
//"""
//        return _pythia8.Info_getWeakDipoles(self)
//
//    def getWeakMomenta(self):
//        """
//"""
//        return _pythia8.Info_getWeakMomenta(self)
//
//    def getWeak2to2lines(self):
//        """
//"""
//        return _pythia8.Info_getWeak2to2lines(self)
//
//    def setWeakModes(self, weakModesIn):
//        """
//"""
//        return _pythia8.Info_setWeakModes(self, weakModesIn)
//
//    def setWeakDipoles(self, weakDipolesIn):
//        """
//"""
//        return _pythia8.Info_setWeakDipoles(self, weakDipolesIn)
//
//    def setWeakMomenta(self, weakMomentaIn):
//        """
//"""
//        return _pythia8.Info_setWeakMomenta(self, weakMomentaIn)
//
//    def setWeak2to2lines(self, weak2to2linesIn):
//        """
//"""
//        return _pythia8.Info_setWeak2to2lines(self, weak2to2linesIn)
//    __swig_setmethods__["hiinfo"] = _pythia8.Info_hiinfo_set
//    __swig_getmethods__["hiinfo"] = _pythia8.Info_hiinfo_get
//    if _newclass:
//        hiinfo = _swig_property(_pythia8.Info_hiinfo_get, _pythia8.Info_hiinfo_set)
//
//    def __str__(self):
//        return _pythia8.Info___str__(self)
//    __swig_destroy__ = _pythia8.delete_Info
//    __del__ = lambda self: None
//Info_swigregister = _pythia8.Info_swigregister
//Info_swigregister(Info)
//
//class Flag(_object):
//    """
//Class for bool flags.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Flag, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, Flag, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor
//"""
//        this = _pythia8.new_Flag(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["name"] = _pythia8.Flag_name_set
//    __swig_getmethods__["name"] = _pythia8.Flag_name_get
//    if _newclass:
//        name = _swig_property(_pythia8.Flag_name_get, _pythia8.Flag_name_set)
//    __swig_setmethods__["valNow"] = _pythia8.Flag_valNow_set
//    __swig_getmethods__["valNow"] = _pythia8.Flag_valNow_get
//    if _newclass:
//        valNow = _swig_property(_pythia8.Flag_valNow_get, _pythia8.Flag_valNow_set)
//    __swig_setmethods__["valDefault"] = _pythia8.Flag_valDefault_set
//    __swig_getmethods__["valDefault"] = _pythia8.Flag_valDefault_get
//    if _newclass:
//        valDefault = _swig_property(_pythia8.Flag_valDefault_get, _pythia8.Flag_valDefault_set)
//    __swig_destroy__ = _pythia8.delete_Flag
//    __del__ = lambda self: None
//Flag_swigregister = _pythia8.Flag_swigregister
//Flag_swigregister(Flag)
//
//class Mode(_object):
//    """
//Class for integer modes.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Mode, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, Mode, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor
//"""
//        this = _pythia8.new_Mode(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["name"] = _pythia8.Mode_name_set
//    __swig_getmethods__["name"] = _pythia8.Mode_name_get
//    if _newclass:
//        name = _swig_property(_pythia8.Mode_name_get, _pythia8.Mode_name_set)
//    __swig_setmethods__["valNow"] = _pythia8.Mode_valNow_set
//    __swig_getmethods__["valNow"] = _pythia8.Mode_valNow_get
//    if _newclass:
//        valNow = _swig_property(_pythia8.Mode_valNow_get, _pythia8.Mode_valNow_set)
//    __swig_setmethods__["valDefault"] = _pythia8.Mode_valDefault_set
//    __swig_getmethods__["valDefault"] = _pythia8.Mode_valDefault_get
//    if _newclass:
//        valDefault = _swig_property(_pythia8.Mode_valDefault_get, _pythia8.Mode_valDefault_set)
//    __swig_setmethods__["hasMin"] = _pythia8.Mode_hasMin_set
//    __swig_getmethods__["hasMin"] = _pythia8.Mode_hasMin_get
//    if _newclass:
//        hasMin = _swig_property(_pythia8.Mode_hasMin_get, _pythia8.Mode_hasMin_set)
//    __swig_setmethods__["hasMax"] = _pythia8.Mode_hasMax_set
//    __swig_getmethods__["hasMax"] = _pythia8.Mode_hasMax_get
//    if _newclass:
//        hasMax = _swig_property(_pythia8.Mode_hasMax_get, _pythia8.Mode_hasMax_set)
//    __swig_setmethods__["valMin"] = _pythia8.Mode_valMin_set
//    __swig_getmethods__["valMin"] = _pythia8.Mode_valMin_get
//    if _newclass:
//        valMin = _swig_property(_pythia8.Mode_valMin_get, _pythia8.Mode_valMin_set)
//    __swig_setmethods__["valMax"] = _pythia8.Mode_valMax_set
//    __swig_getmethods__["valMax"] = _pythia8.Mode_valMax_get
//    if _newclass:
//        valMax = _swig_property(_pythia8.Mode_valMax_get, _pythia8.Mode_valMax_set)
//    __swig_setmethods__["optOnly"] = _pythia8.Mode_optOnly_set
//    __swig_getmethods__["optOnly"] = _pythia8.Mode_optOnly_get
//    if _newclass:
//        optOnly = _swig_property(_pythia8.Mode_optOnly_get, _pythia8.Mode_optOnly_set)
//    __swig_destroy__ = _pythia8.delete_Mode
//    __del__ = lambda self: None
//Mode_swigregister = _pythia8.Mode_swigregister
//Mode_swigregister(Mode)
//
//class Parm(_object):
//    """
//Class for double parms (where parm is shorthand for parameter).
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Parm, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, Parm, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor
//"""
//        this = _pythia8.new_Parm(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["name"] = _pythia8.Parm_name_set
//    __swig_getmethods__["name"] = _pythia8.Parm_name_get
//    if _newclass:
//        name = _swig_property(_pythia8.Parm_name_get, _pythia8.Parm_name_set)
//    __swig_setmethods__["valNow"] = _pythia8.Parm_valNow_set
//    __swig_getmethods__["valNow"] = _pythia8.Parm_valNow_get
//    if _newclass:
//        valNow = _swig_property(_pythia8.Parm_valNow_get, _pythia8.Parm_valNow_set)
//    __swig_setmethods__["valDefault"] = _pythia8.Parm_valDefault_set
//    __swig_getmethods__["valDefault"] = _pythia8.Parm_valDefault_get
//    if _newclass:
//        valDefault = _swig_property(_pythia8.Parm_valDefault_get, _pythia8.Parm_valDefault_set)
//    __swig_setmethods__["hasMin"] = _pythia8.Parm_hasMin_set
//    __swig_getmethods__["hasMin"] = _pythia8.Parm_hasMin_get
//    if _newclass:
//        hasMin = _swig_property(_pythia8.Parm_hasMin_get, _pythia8.Parm_hasMin_set)
//    __swig_setmethods__["hasMax"] = _pythia8.Parm_hasMax_set
//    __swig_getmethods__["hasMax"] = _pythia8.Parm_hasMax_get
//    if _newclass:
//        hasMax = _swig_property(_pythia8.Parm_hasMax_get, _pythia8.Parm_hasMax_set)
//    __swig_setmethods__["valMin"] = _pythia8.Parm_valMin_set
//    __swig_getmethods__["valMin"] = _pythia8.Parm_valMin_get
//    if _newclass:
//        valMin = _swig_property(_pythia8.Parm_valMin_get, _pythia8.Parm_valMin_set)
//    __swig_setmethods__["valMax"] = _pythia8.Parm_valMax_set
//    __swig_getmethods__["valMax"] = _pythia8.Parm_valMax_get
//    if _newclass:
//        valMax = _swig_property(_pythia8.Parm_valMax_get, _pythia8.Parm_valMax_set)
//    __swig_destroy__ = _pythia8.delete_Parm
//    __del__ = lambda self: None
//Parm_swigregister = _pythia8.Parm_swigregister
//Parm_swigregister(Parm)
//
//class Word(_object):
//    """
//Class for string words.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Word, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, Word, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor
//"""
//        this = _pythia8.new_Word(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["name"] = _pythia8.Word_name_set
//    __swig_getmethods__["name"] = _pythia8.Word_name_get
//    if _newclass:
//        name = _swig_property(_pythia8.Word_name_get, _pythia8.Word_name_set)
//    __swig_setmethods__["valNow"] = _pythia8.Word_valNow_set
//    __swig_getmethods__["valNow"] = _pythia8.Word_valNow_get
//    if _newclass:
//        valNow = _swig_property(_pythia8.Word_valNow_get, _pythia8.Word_valNow_set)
//    __swig_setmethods__["valDefault"] = _pythia8.Word_valDefault_set
//    __swig_getmethods__["valDefault"] = _pythia8.Word_valDefault_get
//    if _newclass:
//        valDefault = _swig_property(_pythia8.Word_valDefault_get, _pythia8.Word_valDefault_set)
//    __swig_destroy__ = _pythia8.delete_Word
//    __del__ = lambda self: None
//Word_swigregister = _pythia8.Word_swigregister
//Word_swigregister(Word)
//
//class FVec(_object):
//    """
//Class for vector of bool flags.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, FVec, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, FVec, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor
//"""
//        this = _pythia8.new_FVec(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["name"] = _pythia8.FVec_name_set
//    __swig_getmethods__["name"] = _pythia8.FVec_name_get
//    if _newclass:
//        name = _swig_property(_pythia8.FVec_name_get, _pythia8.FVec_name_set)
//    __swig_setmethods__["valNow"] = _pythia8.FVec_valNow_set
//    __swig_getmethods__["valNow"] = _pythia8.FVec_valNow_get
//    if _newclass:
//        valNow = _swig_property(_pythia8.FVec_valNow_get, _pythia8.FVec_valNow_set)
//    __swig_setmethods__["valDefault"] = _pythia8.FVec_valDefault_set
//    __swig_getmethods__["valDefault"] = _pythia8.FVec_valDefault_get
//    if _newclass:
//        valDefault = _swig_property(_pythia8.FVec_valDefault_get, _pythia8.FVec_valDefault_set)
//    __swig_destroy__ = _pythia8.delete_FVec
//    __del__ = lambda self: None
//FVec_swigregister = _pythia8.FVec_swigregister
//FVec_swigregister(FVec)
//
//class MVec(_object):
//    """
//Class for vector of integers.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, MVec, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, MVec, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor
//"""
//        this = _pythia8.new_MVec(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["name"] = _pythia8.MVec_name_set
//    __swig_getmethods__["name"] = _pythia8.MVec_name_get
//    if _newclass:
//        name = _swig_property(_pythia8.MVec_name_get, _pythia8.MVec_name_set)
//    __swig_setmethods__["valNow"] = _pythia8.MVec_valNow_set
//    __swig_getmethods__["valNow"] = _pythia8.MVec_valNow_get
//    if _newclass:
//        valNow = _swig_property(_pythia8.MVec_valNow_get, _pythia8.MVec_valNow_set)
//    __swig_setmethods__["valDefault"] = _pythia8.MVec_valDefault_set
//    __swig_getmethods__["valDefault"] = _pythia8.MVec_valDefault_get
//    if _newclass:
//        valDefault = _swig_property(_pythia8.MVec_valDefault_get, _pythia8.MVec_valDefault_set)
//    __swig_setmethods__["hasMin"] = _pythia8.MVec_hasMin_set
//    __swig_getmethods__["hasMin"] = _pythia8.MVec_hasMin_get
//    if _newclass:
//        hasMin = _swig_property(_pythia8.MVec_hasMin_get, _pythia8.MVec_hasMin_set)
//    __swig_setmethods__["hasMax"] = _pythia8.MVec_hasMax_set
//    __swig_getmethods__["hasMax"] = _pythia8.MVec_hasMax_get
//    if _newclass:
//        hasMax = _swig_property(_pythia8.MVec_hasMax_get, _pythia8.MVec_hasMax_set)
//    __swig_setmethods__["valMin"] = _pythia8.MVec_valMin_set
//    __swig_getmethods__["valMin"] = _pythia8.MVec_valMin_get
//    if _newclass:
//        valMin = _swig_property(_pythia8.MVec_valMin_get, _pythia8.MVec_valMin_set)
//    __swig_setmethods__["valMax"] = _pythia8.MVec_valMax_set
//    __swig_getmethods__["valMax"] = _pythia8.MVec_valMax_get
//    if _newclass:
//        valMax = _swig_property(_pythia8.MVec_valMax_get, _pythia8.MVec_valMax_set)
//    __swig_destroy__ = _pythia8.delete_MVec
//    __del__ = lambda self: None
//MVec_swigregister = _pythia8.MVec_swigregister
//MVec_swigregister(MVec)
//
//class PVec(_object):
//    """
//Class for vector of doubles.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, PVec, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, PVec, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor
//"""
//        this = _pythia8.new_PVec(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["name"] = _pythia8.PVec_name_set
//    __swig_getmethods__["name"] = _pythia8.PVec_name_get
//    if _newclass:
//        name = _swig_property(_pythia8.PVec_name_get, _pythia8.PVec_name_set)
//    __swig_setmethods__["valNow"] = _pythia8.PVec_valNow_set
//    __swig_getmethods__["valNow"] = _pythia8.PVec_valNow_get
//    if _newclass:
//        valNow = _swig_property(_pythia8.PVec_valNow_get, _pythia8.PVec_valNow_set)
//    __swig_setmethods__["valDefault"] = _pythia8.PVec_valDefault_set
//    __swig_getmethods__["valDefault"] = _pythia8.PVec_valDefault_get
//    if _newclass:
//        valDefault = _swig_property(_pythia8.PVec_valDefault_get, _pythia8.PVec_valDefault_set)
//    __swig_setmethods__["hasMin"] = _pythia8.PVec_hasMin_set
//    __swig_getmethods__["hasMin"] = _pythia8.PVec_hasMin_get
//    if _newclass:
//        hasMin = _swig_property(_pythia8.PVec_hasMin_get, _pythia8.PVec_hasMin_set)
//    __swig_setmethods__["hasMax"] = _pythia8.PVec_hasMax_set
//    __swig_getmethods__["hasMax"] = _pythia8.PVec_hasMax_get
//    if _newclass:
//        hasMax = _swig_property(_pythia8.PVec_hasMax_get, _pythia8.PVec_hasMax_set)
//    __swig_setmethods__["valMin"] = _pythia8.PVec_valMin_set
//    __swig_getmethods__["valMin"] = _pythia8.PVec_valMin_get
//    if _newclass:
//        valMin = _swig_property(_pythia8.PVec_valMin_get, _pythia8.PVec_valMin_set)
//    __swig_setmethods__["valMax"] = _pythia8.PVec_valMax_set
//    __swig_getmethods__["valMax"] = _pythia8.PVec_valMax_get
//    if _newclass:
//        valMax = _swig_property(_pythia8.PVec_valMax_get, _pythia8.PVec_valMax_set)
//    __swig_destroy__ = _pythia8.delete_PVec
//    __del__ = lambda self: None
//PVec_swigregister = _pythia8.PVec_swigregister
//PVec_swigregister(PVec)
//
//class WVec(_object):
//    """
//Class for vector of strings.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, WVec, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, WVec, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor
//"""
//        this = _pythia8.new_WVec(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["name"] = _pythia8.WVec_name_set
//    __swig_getmethods__["name"] = _pythia8.WVec_name_get
//    if _newclass:
//        name = _swig_property(_pythia8.WVec_name_get, _pythia8.WVec_name_set)
//    __swig_setmethods__["valNow"] = _pythia8.WVec_valNow_set
//    __swig_getmethods__["valNow"] = _pythia8.WVec_valNow_get
//    if _newclass:
//        valNow = _swig_property(_pythia8.WVec_valNow_get, _pythia8.WVec_valNow_set)
//    __swig_setmethods__["valDefault"] = _pythia8.WVec_valDefault_set
//    __swig_getmethods__["valDefault"] = _pythia8.WVec_valDefault_get
//    if _newclass:
//        valDefault = _swig_property(_pythia8.WVec_valDefault_get, _pythia8.WVec_valDefault_set)
//    __swig_destroy__ = _pythia8.delete_WVec
//    __del__ = lambda self: None
//WVec_swigregister = _pythia8.WVec_swigregister
//WVec_swigregister(WVec)
//
//class Settings(_object):
//    """
//This class holds info on flags (bool), modes (int), parms (double),
//words (string), fvecs (vector of bool), mvecs (vector of int),
//pvecs (vector of double) and wvecs (vector of string).
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Settings, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, Settings, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Settings()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initPtr(self, infoPtrIn):
//        """
//Initialize Info pointer.
//"""
//        return _pythia8.Settings_initPtr(self, infoPtrIn)
//
//    def init(self, *args):
//        """
//Read in database from stream.
//"""
//        return _pythia8.Settings_init(self, *args)
//
//    def reInit(self, *args):
//        """
//Overwrite existing database by reading from specific file.
//"""
//        return _pythia8.Settings_reInit(self, *args)
//
//    def readString(self, line, warn=True):
//        """
//Read in one update from a single line.
//"""
//        return _pythia8.Settings_readString(self, line, warn)
//
//    def writeFile(self, *args):
//        """
//"""
//        return _pythia8.Settings_writeFile(self, *args)
//
//    def writeFileXML(self, *args):
//        """
//"""
//        return _pythia8.Settings_writeFileXML(self, *args)
//
//    def listAll(self):
//        """
//Print out table of database, either all or only changed ones,
//or ones containing a given string.
//"""
//        return _pythia8.Settings_listAll(self)
//
//    def listChanged(self):
//        """
//"""
//        return _pythia8.Settings_listChanged(self)
//
//    def output(self, keyIn, fullLine=True):
//        """
//Give back current value(s) as a string, whatever the type.
//"""
//        return _pythia8.Settings_output(self, keyIn, fullLine)
//
//    def getReadHistory(self, subrun=-999):
//        """
//Retrieve readString history (e.g., for inspection). Everything
//(subrun=-999), up to first subrun (=-1), or subrun-specific (>=0).
//"""
//        return _pythia8.Settings_getReadHistory(self, subrun)
//
//    def resetAll(self):
//        """
//Reset all values to their defaults.
//"""
//        return _pythia8.Settings_resetAll(self)
//
//    def isFlag(self, keyIn):
//        """
//Query existence of an entry.
//"""
//        return _pythia8.Settings_isFlag(self, keyIn)
//
//    def isMode(self, keyIn):
//        """
//"""
//        return _pythia8.Settings_isMode(self, keyIn)
//
//    def isParm(self, keyIn):
//        """
//"""
//        return _pythia8.Settings_isParm(self, keyIn)
//
//    def isWord(self, keyIn):
//        """
//"""
//        return _pythia8.Settings_isWord(self, keyIn)
//
//    def isFVec(self, keyIn):
//        """
//"""
//        return _pythia8.Settings_isFVec(self, keyIn)
//
//    def isMVec(self, keyIn):
//        """
//"""
//        return _pythia8.Settings_isMVec(self, keyIn)
//
//    def isPVec(self, keyIn):
//        """
//"""
//        return _pythia8.Settings_isPVec(self, keyIn)
//
//    def isWVec(self, keyIn):
//        """
//"""
//        return _pythia8.Settings_isWVec(self, keyIn)
//
//    def addFlag(self, keyIn, defaultIn):
//        """
//Add new entry.
//"""
//        return _pythia8.Settings_addFlag(self, keyIn, defaultIn)
//
//    def addMode(self, keyIn, defaultIn, hasMinIn, hasMaxIn, minIn, maxIn, optOnlyIn=False):
//        """
//"""
//        return _pythia8.Settings_addMode(self, keyIn, defaultIn, hasMinIn, hasMaxIn, minIn, maxIn, optOnlyIn)
//
//    def addParm(self, keyIn, defaultIn, hasMinIn, hasMaxIn, minIn, maxIn):
//        """
//"""
//        return _pythia8.Settings_addParm(self, keyIn, defaultIn, hasMinIn, hasMaxIn, minIn, maxIn)
//
//    def addWord(self, keyIn, defaultIn):
//        """
//"""
//        return _pythia8.Settings_addWord(self, keyIn, defaultIn)
//
//    def addFVec(self, keyIn, defaultIn):
//        """
//"""
//        return _pythia8.Settings_addFVec(self, keyIn, defaultIn)
//
//    def addMVec(self, keyIn, defaultIn, hasMinIn, hasMaxIn, minIn, maxIn):
//        """
//"""
//        return _pythia8.Settings_addMVec(self, keyIn, defaultIn, hasMinIn, hasMaxIn, minIn, maxIn)
//
//    def addPVec(self, keyIn, defaultIn, hasMinIn, hasMaxIn, minIn, maxIn):
//        """
//"""
//        return _pythia8.Settings_addPVec(self, keyIn, defaultIn, hasMinIn, hasMaxIn, minIn, maxIn)
//
//    def addWVec(self, keyIn, defaultIn):
//        """
//"""
//        return _pythia8.Settings_addWVec(self, keyIn, defaultIn)
//
//    def flagDefault(self, keyIn):
//        """
//Give back default value, with check that key exists.
//"""
//        return _pythia8.Settings_flagDefault(self, keyIn)
//
//    def modeDefault(self, keyIn):
//        """
//"""
//        return _pythia8.Settings_modeDefault(self, keyIn)
//
//    def parmDefault(self, keyIn):
//        """
//"""
//        return _pythia8.Settings_parmDefault(self, keyIn)
//
//    def wordDefault(self, keyIn):
//        """
//"""
//        return _pythia8.Settings_wordDefault(self, keyIn)
//
//    def fvecDefault(self, keyIn):
//        """
//"""
//        return _pythia8.Settings_fvecDefault(self, keyIn)
//
//    def mvecDefault(self, keyIn):
//        """
//"""
//        return _pythia8.Settings_mvecDefault(self, keyIn)
//
//    def pvecDefault(self, keyIn):
//        """
//"""
//        return _pythia8.Settings_pvecDefault(self, keyIn)
//
//    def wvecDefault(self, keyIn):
//        """
//"""
//        return _pythia8.Settings_wvecDefault(self, keyIn)
//
//    def getFlagMap(self, match):
//        """
//Give back a map of all entries whose names match the string "match".
//"""
//        return _pythia8.Settings_getFlagMap(self, match)
//
//    def getModeMap(self, match):
//        """
//"""
//        return _pythia8.Settings_getModeMap(self, match)
//
//    def getParmMap(self, match):
//        """
//"""
//        return _pythia8.Settings_getParmMap(self, match)
//
//    def getWordMap(self, match):
//        """
//"""
//        return _pythia8.Settings_getWordMap(self, match)
//
//    def getFVecMap(self, match):
//        """
//"""
//        return _pythia8.Settings_getFVecMap(self, match)
//
//    def getMVecMap(self, match):
//        """
//"""
//        return _pythia8.Settings_getMVecMap(self, match)
//
//    def getPVecMap(self, match):
//        """
//"""
//        return _pythia8.Settings_getPVecMap(self, match)
//
//    def getWVecMap(self, match):
//        """
//"""
//        return _pythia8.Settings_getWVecMap(self, match)
//
//    def flag(self, *args):
//        """
//Change current value, respecting limits.
//"""
//        return _pythia8.Settings_flag(self, *args)
//
//    def mode(self, *args):
//        """
//"""
//        return _pythia8.Settings_mode(self, *args)
//
//    def parm(self, *args):
//        """
//"""
//        return _pythia8.Settings_parm(self, *args)
//
//    def word(self, *args):
//        """
//"""
//        return _pythia8.Settings_word(self, *args)
//
//    def fvec(self, *args):
//        """
//"""
//        return _pythia8.Settings_fvec(self, *args)
//
//    def mvec(self, *args):
//        """
//"""
//        return _pythia8.Settings_mvec(self, *args)
//
//    def pvec(self, *args):
//        """
//"""
//        return _pythia8.Settings_pvec(self, *args)
//
//    def wvec(self, *args):
//        """
//"""
//        return _pythia8.Settings_wvec(self, *args)
//
//    def forceMode(self, keyIn, nowIn):
//        """
//Methods kept for backwards compatability with 8.223 and earlier.
//(To be removed in next major release.)
//"""
//        return _pythia8.Settings_forceMode(self, keyIn, nowIn)
//
//    def forceParm(self, keyIn, nowIn):
//        """
//"""
//        return _pythia8.Settings_forceParm(self, keyIn, nowIn)
//
//    def forceMVec(self, keyIn, nowIn):
//        """
//"""
//        return _pythia8.Settings_forceMVec(self, keyIn, nowIn)
//
//    def forcePVec(self, keyIn, nowIn):
//        """
//"""
//        return _pythia8.Settings_forcePVec(self, keyIn, nowIn)
//
//    def resetFlag(self, keyIn):
//        """
//Restore current value to default.
//"""
//        return _pythia8.Settings_resetFlag(self, keyIn)
//
//    def resetMode(self, keyIn):
//        """
//"""
//        return _pythia8.Settings_resetMode(self, keyIn)
//
//    def resetParm(self, keyIn):
//        """
//"""
//        return _pythia8.Settings_resetParm(self, keyIn)
//
//    def resetWord(self, keyIn):
//        """
//"""
//        return _pythia8.Settings_resetWord(self, keyIn)
//
//    def resetFVec(self, keyIn):
//        """
//"""
//        return _pythia8.Settings_resetFVec(self, keyIn)
//
//    def resetMVec(self, keyIn):
//        """
//"""
//        return _pythia8.Settings_resetMVec(self, keyIn)
//
//    def resetPVec(self, keyIn):
//        """
//"""
//        return _pythia8.Settings_resetPVec(self, keyIn)
//
//    def resetWVec(self, keyIn):
//        """
//"""
//        return _pythia8.Settings_resetWVec(self, keyIn)
//
//    def getIsInit(self):
//        """
//Check initialisation status.
//"""
//        return _pythia8.Settings_getIsInit(self)
//
//    def readingFailed(self):
//        """
//Keep track whether any readings have failed, invalidating run setup.
//"""
//        return _pythia8.Settings_readingFailed(self)
//
//    def unfinishedInput(self):
//        """
//Check whether input openend with { not yet closed with }.
//"""
//        return _pythia8.Settings_unfinishedInput(self)
//    __swig_destroy__ = _pythia8.delete_Settings
//    __del__ = lambda self: None
//Settings_swigregister = _pythia8.Settings_swigregister
//Settings_swigregister(Settings)
//
//class AlphaStrong(_object):
//    """
//The AlphaStrong class calculates the alpha_strong value at an arbitrary
//scale, given the value at m_Z, to zeroth, first or second order.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, AlphaStrong, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, AlphaStrong, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructors.
//"""
//        this = _pythia8.new_AlphaStrong()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_AlphaStrong
//    __del__ = lambda self: None
//
//    def init(self, valueIn=0.12, orderIn=1, nfmaxIn=6, useCMWIn=False):
//        """
//Initialization for given value at M_Z and given order.
//"""
//        return _pythia8.AlphaStrong_init(self, valueIn, orderIn, nfmaxIn, useCMWIn)
//
//    def setThresholds(self, mcIn, mbIn, mtIn):
//        """
//Set flavour threshold values: m_c, m_b, m_t.
//"""
//        return _pythia8.AlphaStrong_setThresholds(self, mcIn, mbIn, mtIn)
//
//    def alphaS(self, scale2):
//        """
//alpha_S value and Lambda values.
//"""
//        return _pythia8.AlphaStrong_alphaS(self, scale2)
//
//    def alphaS1Ord(self, scale2):
//        """
//"""
//        return _pythia8.AlphaStrong_alphaS1Ord(self, scale2)
//
//    def alphaS2OrdCorr(self, scale2):
//        """
//"""
//        return _pythia8.AlphaStrong_alphaS2OrdCorr(self, scale2)
//
//    def Lambda3(self):
//        """
//"""
//        return _pythia8.AlphaStrong_Lambda3(self)
//
//    def Lambda4(self):
//        """
//"""
//        return _pythia8.AlphaStrong_Lambda4(self)
//
//    def Lambda5(self):
//        """
//"""
//        return _pythia8.AlphaStrong_Lambda5(self)
//
//    def Lambda6(self):
//        """
//"""
//        return _pythia8.AlphaStrong_Lambda6(self)
//
//    def muThres(self, idQ):
//        """
//Info: tell which scales we use for flavour thresholds.
//"""
//        return _pythia8.AlphaStrong_muThres(self, idQ)
//
//    def muThres2(self, idQ):
//        """
//"""
//        return _pythia8.AlphaStrong_muThres2(self, idQ)
//
//    def facCMW(self, nFin):
//        """
//Return the CMW factor (for nF between 3 and 6).
//"""
//        return _pythia8.AlphaStrong_facCMW(self, nFin)
//AlphaStrong_swigregister = _pythia8.AlphaStrong_swigregister
//AlphaStrong_swigregister(AlphaStrong)
//
//class AlphaEM(_object):
//    """
//The AlphaEM class calculates the alpha_electromagnetic value at an
//arbitrary scale, given the value at 0 and m_Z, to zeroth or first order.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, AlphaEM, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, AlphaEM, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructors.
//"""
//        this = _pythia8.new_AlphaEM()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, orderIn, settingsPtr):
//        """
//Initialization for a given order.
//"""
//        return _pythia8.AlphaEM_init(self, orderIn, settingsPtr)
//
//    def alphaEM(self, scale2):
//        """
//alpha_EM value.
//"""
//        return _pythia8.AlphaEM_alphaEM(self, scale2)
//    __swig_destroy__ = _pythia8.delete_AlphaEM
//    __del__ = lambda self: None
//AlphaEM_swigregister = _pythia8.AlphaEM_swigregister
//AlphaEM_swigregister(AlphaEM)
//
//class CoupSM(_object):
//    """
//The CoupSM class stores and returns electroweak couplings,
//including Cabibbo-Kobayashi-Maskawa mass mixing matrix elements.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, CoupSM, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, CoupSM, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_CoupSM()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, settings, rndmPtrIn):
//        """
//Initialize, normally from Pythia::init().
//"""
//        return _pythia8.CoupSM_init(self, settings, rndmPtrIn)
//
//    def alphaS(self, scale2):
//        """
//alpha_S value and Lambda values.
//"""
//        return _pythia8.CoupSM_alphaS(self, scale2)
//
//    def alphaS1Ord(self, scale2):
//        """
//"""
//        return _pythia8.CoupSM_alphaS1Ord(self, scale2)
//
//    def alphaS2OrdCorr(self, scale2):
//        """
//"""
//        return _pythia8.CoupSM_alphaS2OrdCorr(self, scale2)
//
//    def Lambda3(self):
//        """
//"""
//        return _pythia8.CoupSM_Lambda3(self)
//
//    def Lambda4(self):
//        """
//"""
//        return _pythia8.CoupSM_Lambda4(self)
//
//    def Lambda5(self):
//        """
//"""
//        return _pythia8.CoupSM_Lambda5(self)
//
//    def alphaEM(self, scale2):
//        """
//Return alpha_EM value.
//"""
//        return _pythia8.CoupSM_alphaEM(self, scale2)
//
//    def sin2thetaW(self):
//        """
//Return electroweak mixing angle and Fermi constant.
//"""
//        return _pythia8.CoupSM_sin2thetaW(self)
//
//    def cos2thetaW(self):
//        """
//"""
//        return _pythia8.CoupSM_cos2thetaW(self)
//
//    def sin2thetaWbar(self):
//        """
//"""
//        return _pythia8.CoupSM_sin2thetaWbar(self)
//
//    def GF(self):
//        """
//"""
//        return _pythia8.CoupSM_GF(self)
//
//    def ef(self, idAbs):
//        """
//Return electroweak couplings of quarks and leptons.
//"""
//        return _pythia8.CoupSM_ef(self, idAbs)
//
//    def vf(self, idAbs):
//        """
//"""
//        return _pythia8.CoupSM_vf(self, idAbs)
//
//    def af(self, idAbs):
//        """
//"""
//        return _pythia8.CoupSM_af(self, idAbs)
//
//    def t3f(self, idAbs):
//        """
//"""
//        return _pythia8.CoupSM_t3f(self, idAbs)
//
//    def lf(self, idAbs):
//        """
//"""
//        return _pythia8.CoupSM_lf(self, idAbs)
//
//    def rf(self, idAbs):
//        """
//"""
//        return _pythia8.CoupSM_rf(self, idAbs)
//
//    def ef2(self, idAbs):
//        """
//Return some squared couplings and other combinations.
//"""
//        return _pythia8.CoupSM_ef2(self, idAbs)
//
//    def vf2(self, idAbs):
//        """
//"""
//        return _pythia8.CoupSM_vf2(self, idAbs)
//
//    def af2(self, idAbs):
//        """
//"""
//        return _pythia8.CoupSM_af2(self, idAbs)
//
//    def efvf(self, idAbs):
//        """
//"""
//        return _pythia8.CoupSM_efvf(self, idAbs)
//
//    def vf2af2(self, idAbs):
//        """
//"""
//        return _pythia8.CoupSM_vf2af2(self, idAbs)
//
//    def VCKMgen(self, genU, genD):
//        """
//Return CKM value or square:
//first index 1/2/3/4 = u/c/t/t', second 1/2/3/4 = d/s/b/b'.
//"""
//        return _pythia8.CoupSM_VCKMgen(self, genU, genD)
//
//    def V2CKMgen(self, genU, genD):
//        """
//"""
//        return _pythia8.CoupSM_V2CKMgen(self, genU, genD)
//
//    def VCKMid(self, id1, id2):
//        """
//Return CKM value or square for incoming flavours (sign irrelevant).
//"""
//        return _pythia8.CoupSM_VCKMid(self, id1, id2)
//
//    def V2CKMid(self, id1, id2):
//        """
//"""
//        return _pythia8.CoupSM_V2CKMid(self, id1, id2)
//
//    def V2CKMsum(self, id):
//        """
//Return CKM sum of squares for given inflavour, or random outflavour.
//"""
//        return _pythia8.CoupSM_V2CKMsum(self, id)
//
//    def V2CKMpick(self, id):
//        """
//"""
//        return _pythia8.CoupSM_V2CKMpick(self, id)
//    __swig_destroy__ = _pythia8.delete_CoupSM
//    __del__ = lambda self: None
//CoupSM_swigregister = _pythia8.CoupSM_swigregister
//CoupSM_swigregister(CoupSM)
//
//class Couplings(CoupSM):
//    """
//Generic couplings class
//"""
//    __swig_setmethods__ = {}
//    for _s in [CoupSM]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Couplings, name, value)
//    __swig_getmethods__ = {}
//    for _s in [CoupSM]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Couplings, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, isSUSYin=False):
//        """
//"""
//        this = _pythia8.new_Couplings(isSUSYin)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["isSUSY"] = _pythia8.Couplings_isSUSY_set
//    __swig_getmethods__["isSUSY"] = _pythia8.Couplings_isSUSY_get
//    if _newclass:
//        isSUSY = _swig_property(_pythia8.Couplings_isSUSY_get, _pythia8.Couplings_isSUSY_set)
//    __swig_destroy__ = _pythia8.delete_Couplings
//    __del__ = lambda self: None
//Couplings_swigregister = _pythia8.Couplings_swigregister
//Couplings_swigregister(Couplings)
//
//class CoupSUSY(Couplings):
//    """
//CoupSUSY
//Auxiliary class to compute and store various SM and SUSY couplings.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Couplings]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, CoupSUSY, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Couplings]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, CoupSUSY, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor
//"""
//        this = _pythia8.new_CoupSUSY()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initSUSY(self, slhaPtrIn, infoPtrIn, particleDataPtrIn, settingsPtrIn):
//        """
//Initialize
//"""
//        return _pythia8.CoupSUSY_initSUSY(self, slhaPtrIn, infoPtrIn, particleDataPtrIn, settingsPtrIn)
//    __swig_setmethods__["isInit"] = _pythia8.CoupSUSY_isInit_set
//    __swig_getmethods__["isInit"] = _pythia8.CoupSUSY_isInit_get
//    if _newclass:
//        isInit = _swig_property(_pythia8.CoupSUSY_isInit_get, _pythia8.CoupSUSY_isInit_set)
//    __swig_setmethods__["isNMSSM"] = _pythia8.CoupSUSY_isNMSSM_set
//    __swig_getmethods__["isNMSSM"] = _pythia8.CoupSUSY_isNMSSM_get
//    if _newclass:
//        isNMSSM = _swig_property(_pythia8.CoupSUSY_isNMSSM_get, _pythia8.CoupSUSY_isNMSSM_set)
//    __swig_setmethods__["isLLE"] = _pythia8.CoupSUSY_isLLE_set
//    __swig_getmethods__["isLLE"] = _pythia8.CoupSUSY_isLLE_get
//    if _newclass:
//        isLLE = _swig_property(_pythia8.CoupSUSY_isLLE_get, _pythia8.CoupSUSY_isLLE_set)
//    __swig_setmethods__["isLQD"] = _pythia8.CoupSUSY_isLQD_set
//    __swig_getmethods__["isLQD"] = _pythia8.CoupSUSY_isLQD_get
//    if _newclass:
//        isLQD = _swig_property(_pythia8.CoupSUSY_isLQD_get, _pythia8.CoupSUSY_isLQD_set)
//    __swig_setmethods__["isUDD"] = _pythia8.CoupSUSY_isUDD_set
//    __swig_getmethods__["isUDD"] = _pythia8.CoupSUSY_isUDD_get
//    if _newclass:
//        isUDD = _swig_property(_pythia8.CoupSUSY_isUDD_get, _pythia8.CoupSUSY_isUDD_set)
//    __swig_setmethods__["mWpole"] = _pythia8.CoupSUSY_mWpole_set
//    __swig_getmethods__["mWpole"] = _pythia8.CoupSUSY_mWpole_get
//    if _newclass:
//        mWpole = _swig_property(_pythia8.CoupSUSY_mWpole_get, _pythia8.CoupSUSY_mWpole_set)
//    __swig_setmethods__["wWpole"] = _pythia8.CoupSUSY_wWpole_set
//    __swig_getmethods__["wWpole"] = _pythia8.CoupSUSY_wWpole_get
//    if _newclass:
//        wWpole = _swig_property(_pythia8.CoupSUSY_wWpole_get, _pythia8.CoupSUSY_wWpole_set)
//    __swig_setmethods__["mZpole"] = _pythia8.CoupSUSY_mZpole_set
//    __swig_getmethods__["mZpole"] = _pythia8.CoupSUSY_mZpole_get
//    if _newclass:
//        mZpole = _swig_property(_pythia8.CoupSUSY_mZpole_get, _pythia8.CoupSUSY_mZpole_set)
//    __swig_setmethods__["wZpole"] = _pythia8.CoupSUSY_wZpole_set
//    __swig_getmethods__["wZpole"] = _pythia8.CoupSUSY_wZpole_get
//    if _newclass:
//        wZpole = _swig_property(_pythia8.CoupSUSY_wZpole_get, _pythia8.CoupSUSY_wZpole_set)
//    __swig_setmethods__["mW"] = _pythia8.CoupSUSY_mW_set
//    __swig_getmethods__["mW"] = _pythia8.CoupSUSY_mW_get
//    if _newclass:
//        mW = _swig_property(_pythia8.CoupSUSY_mW_get, _pythia8.CoupSUSY_mW_set)
//    __swig_setmethods__["mZ"] = _pythia8.CoupSUSY_mZ_set
//    __swig_getmethods__["mZ"] = _pythia8.CoupSUSY_mZ_get
//    if _newclass:
//        mZ = _swig_property(_pythia8.CoupSUSY_mZ_get, _pythia8.CoupSUSY_mZ_set)
//    __swig_setmethods__["sin2W"] = _pythia8.CoupSUSY_sin2W_set
//    __swig_getmethods__["sin2W"] = _pythia8.CoupSUSY_sin2W_get
//    if _newclass:
//        sin2W = _swig_property(_pythia8.CoupSUSY_sin2W_get, _pythia8.CoupSUSY_sin2W_set)
//    __swig_setmethods__["sinW"] = _pythia8.CoupSUSY_sinW_set
//    __swig_getmethods__["sinW"] = _pythia8.CoupSUSY_sinW_get
//    if _newclass:
//        sinW = _swig_property(_pythia8.CoupSUSY_sinW_get, _pythia8.CoupSUSY_sinW_set)
//    __swig_setmethods__["cosW"] = _pythia8.CoupSUSY_cosW_set
//    __swig_getmethods__["cosW"] = _pythia8.CoupSUSY_cosW_get
//    if _newclass:
//        cosW = _swig_property(_pythia8.CoupSUSY_cosW_get, _pythia8.CoupSUSY_cosW_set)
//    __swig_setmethods__["tanb"] = _pythia8.CoupSUSY_tanb_set
//    __swig_getmethods__["tanb"] = _pythia8.CoupSUSY_tanb_get
//    if _newclass:
//        tanb = _swig_property(_pythia8.CoupSUSY_tanb_get, _pythia8.CoupSUSY_tanb_set)
//    __swig_setmethods__["cosb"] = _pythia8.CoupSUSY_cosb_set
//    __swig_getmethods__["cosb"] = _pythia8.CoupSUSY_cosb_get
//    if _newclass:
//        cosb = _swig_property(_pythia8.CoupSUSY_cosb_get, _pythia8.CoupSUSY_cosb_set)
//    __swig_setmethods__["sinb"] = _pythia8.CoupSUSY_sinb_set
//    __swig_getmethods__["sinb"] = _pythia8.CoupSUSY_sinb_get
//    if _newclass:
//        sinb = _swig_property(_pythia8.CoupSUSY_sinb_get, _pythia8.CoupSUSY_sinb_set)
//    __swig_setmethods__["muHiggs"] = _pythia8.CoupSUSY_muHiggs_set
//    __swig_getmethods__["muHiggs"] = _pythia8.CoupSUSY_muHiggs_get
//    if _newclass:
//        muHiggs = _swig_property(_pythia8.CoupSUSY_muHiggs_get, _pythia8.CoupSUSY_muHiggs_set)
//    __swig_setmethods__["alphaHiggs"] = _pythia8.CoupSUSY_alphaHiggs_set
//    __swig_getmethods__["alphaHiggs"] = _pythia8.CoupSUSY_alphaHiggs_get
//    if _newclass:
//        alphaHiggs = _swig_property(_pythia8.CoupSUSY_alphaHiggs_get, _pythia8.CoupSUSY_alphaHiggs_set)
//    __swig_setmethods__["mAHiggs"] = _pythia8.CoupSUSY_mAHiggs_set
//    __swig_getmethods__["mAHiggs"] = _pythia8.CoupSUSY_mAHiggs_get
//    if _newclass:
//        mAHiggs = _swig_property(_pythia8.CoupSUSY_mAHiggs_get, _pythia8.CoupSUSY_mAHiggs_set)
//    __swig_setmethods__["LsddG"] = _pythia8.CoupSUSY_LsddG_set
//    __swig_getmethods__["LsddG"] = _pythia8.CoupSUSY_LsddG_get
//    if _newclass:
//        LsddG = _swig_property(_pythia8.CoupSUSY_LsddG_get, _pythia8.CoupSUSY_LsddG_set)
//    __swig_setmethods__["RsddG"] = _pythia8.CoupSUSY_RsddG_set
//    __swig_getmethods__["RsddG"] = _pythia8.CoupSUSY_RsddG_get
//    if _newclass:
//        RsddG = _swig_property(_pythia8.CoupSUSY_RsddG_get, _pythia8.CoupSUSY_RsddG_set)
//    __swig_setmethods__["LsuuG"] = _pythia8.CoupSUSY_LsuuG_set
//    __swig_getmethods__["LsuuG"] = _pythia8.CoupSUSY_LsuuG_get
//    if _newclass:
//        LsuuG = _swig_property(_pythia8.CoupSUSY_LsuuG_get, _pythia8.CoupSUSY_LsuuG_set)
//    __swig_setmethods__["RsuuG"] = _pythia8.CoupSUSY_RsuuG_set
//    __swig_getmethods__["RsuuG"] = _pythia8.CoupSUSY_RsuuG_get
//    if _newclass:
//        RsuuG = _swig_property(_pythia8.CoupSUSY_RsuuG_get, _pythia8.CoupSUSY_RsuuG_set)
//
//    def getLsqqG(self, iGenSq, idQ):
//        """
//Status flag. Flags for NMSSM and RPV couplings.
//Z and W pole masses and widths
//Running masses and weak mixing angle
//(default to pole values if no running available)
//Tanbeta
//~qq~g couplings
//Assume generation index for Squark. Translate if PDG code instead.
//"""
//        return _pythia8.CoupSUSY_getLsqqG(self, iGenSq, idQ)
//
//    def getRsqqG(self, iGenSq, idQ):
//        """
//"""
//        return _pythia8.CoupSUSY_getRsqqG(self, iGenSq, idQ)
//    __swig_setmethods__["OLpp"] = _pythia8.CoupSUSY_OLpp_set
//    __swig_getmethods__["OLpp"] = _pythia8.CoupSUSY_OLpp_get
//    if _newclass:
//        OLpp = _swig_property(_pythia8.CoupSUSY_OLpp_get, _pythia8.CoupSUSY_OLpp_set)
//    __swig_setmethods__["ORpp"] = _pythia8.CoupSUSY_ORpp_set
//    __swig_getmethods__["ORpp"] = _pythia8.CoupSUSY_ORpp_get
//    if _newclass:
//        ORpp = _swig_property(_pythia8.CoupSUSY_ORpp_get, _pythia8.CoupSUSY_ORpp_set)
//    __swig_setmethods__["OLp"] = _pythia8.CoupSUSY_OLp_set
//    __swig_getmethods__["OLp"] = _pythia8.CoupSUSY_OLp_get
//    if _newclass:
//        OLp = _swig_property(_pythia8.CoupSUSY_OLp_get, _pythia8.CoupSUSY_OLp_set)
//    __swig_setmethods__["ORp"] = _pythia8.CoupSUSY_ORp_set
//    __swig_getmethods__["ORp"] = _pythia8.CoupSUSY_ORp_get
//    if _newclass:
//        ORp = _swig_property(_pythia8.CoupSUSY_ORp_get, _pythia8.CoupSUSY_ORp_set)
//    __swig_setmethods__["OL"] = _pythia8.CoupSUSY_OL_set
//    __swig_getmethods__["OL"] = _pythia8.CoupSUSY_OL_get
//    if _newclass:
//        OL = _swig_property(_pythia8.CoupSUSY_OL_get, _pythia8.CoupSUSY_OL_set)
//    __swig_setmethods__["OR"] = _pythia8.CoupSUSY_OR_set
//    __swig_getmethods__["OR"] = _pythia8.CoupSUSY_OR_get
//    if _newclass:
//        OR = _swig_property(_pythia8.CoupSUSY_OR_get, _pythia8.CoupSUSY_OR_set)
//    __swig_setmethods__["LqqZ"] = _pythia8.CoupSUSY_LqqZ_set
//    __swig_getmethods__["LqqZ"] = _pythia8.CoupSUSY_LqqZ_get
//    if _newclass:
//        LqqZ = _swig_property(_pythia8.CoupSUSY_LqqZ_get, _pythia8.CoupSUSY_LqqZ_set)
//    __swig_setmethods__["RqqZ"] = _pythia8.CoupSUSY_RqqZ_set
//    __swig_getmethods__["RqqZ"] = _pythia8.CoupSUSY_RqqZ_get
//    if _newclass:
//        RqqZ = _swig_property(_pythia8.CoupSUSY_RqqZ_get, _pythia8.CoupSUSY_RqqZ_set)
//    __swig_setmethods__["LsdsdZ"] = _pythia8.CoupSUSY_LsdsdZ_set
//    __swig_getmethods__["LsdsdZ"] = _pythia8.CoupSUSY_LsdsdZ_get
//    if _newclass:
//        LsdsdZ = _swig_property(_pythia8.CoupSUSY_LsdsdZ_get, _pythia8.CoupSUSY_LsdsdZ_set)
//    __swig_setmethods__["RsdsdZ"] = _pythia8.CoupSUSY_RsdsdZ_set
//    __swig_getmethods__["RsdsdZ"] = _pythia8.CoupSUSY_RsdsdZ_get
//    if _newclass:
//        RsdsdZ = _swig_property(_pythia8.CoupSUSY_RsdsdZ_get, _pythia8.CoupSUSY_RsdsdZ_set)
//    __swig_setmethods__["LsusuZ"] = _pythia8.CoupSUSY_LsusuZ_set
//    __swig_getmethods__["LsusuZ"] = _pythia8.CoupSUSY_LsusuZ_get
//    if _newclass:
//        LsusuZ = _swig_property(_pythia8.CoupSUSY_LsusuZ_get, _pythia8.CoupSUSY_LsusuZ_set)
//    __swig_setmethods__["RsusuZ"] = _pythia8.CoupSUSY_RsusuZ_set
//    __swig_getmethods__["RsusuZ"] = _pythia8.CoupSUSY_RsusuZ_get
//    if _newclass:
//        RsusuZ = _swig_property(_pythia8.CoupSUSY_RsusuZ_get, _pythia8.CoupSUSY_RsusuZ_set)
//
//    def getLsqsqZ(self, idSq1, idSq2):
//        """
//~chi0~chi0Z couplings
//~chi+~chi-Z couplings
//~chi0~chi+W couplings
//qqZ couplings
//~q~qZ couplings
//"""
//        return _pythia8.CoupSUSY_getLsqsqZ(self, idSq1, idSq2)
//
//    def getRsqsqZ(self, idSq1, idSq2):
//        """
//"""
//        return _pythia8.CoupSUSY_getRsqsqZ(self, idSq1, idSq2)
//    __swig_setmethods__["LudW"] = _pythia8.CoupSUSY_LudW_set
//    __swig_getmethods__["LudW"] = _pythia8.CoupSUSY_LudW_get
//    if _newclass:
//        LudW = _swig_property(_pythia8.CoupSUSY_LudW_get, _pythia8.CoupSUSY_LudW_set)
//    __swig_setmethods__["RudW"] = _pythia8.CoupSUSY_RudW_set
//    __swig_getmethods__["RudW"] = _pythia8.CoupSUSY_RudW_get
//    if _newclass:
//        RudW = _swig_property(_pythia8.CoupSUSY_RudW_get, _pythia8.CoupSUSY_RudW_set)
//    __swig_setmethods__["LsusdW"] = _pythia8.CoupSUSY_LsusdW_set
//    __swig_getmethods__["LsusdW"] = _pythia8.CoupSUSY_LsusdW_get
//    if _newclass:
//        LsusdW = _swig_property(_pythia8.CoupSUSY_LsusdW_get, _pythia8.CoupSUSY_LsusdW_set)
//    __swig_setmethods__["RsusdW"] = _pythia8.CoupSUSY_RsusdW_set
//    __swig_getmethods__["RsusdW"] = _pythia8.CoupSUSY_RsusdW_get
//    if _newclass:
//        RsusdW = _swig_property(_pythia8.CoupSUSY_RsusdW_get, _pythia8.CoupSUSY_RsusdW_set)
//
//    def getLsqqX(self, iSq, idQ, iNeut):
//        """
//udW couplings
//~u~dW couplings
//~qq~chi0 couplings
//"""
//        return _pythia8.CoupSUSY_getLsqqX(self, iSq, idQ, iNeut)
//
//    def getRsqqX(self, iSq, idQ, iNeut):
//        """
//"""
//        return _pythia8.CoupSUSY_getRsqqX(self, iSq, idQ, iNeut)
//    __swig_setmethods__["LllZ"] = _pythia8.CoupSUSY_LllZ_set
//    __swig_getmethods__["LllZ"] = _pythia8.CoupSUSY_LllZ_get
//    if _newclass:
//        LllZ = _swig_property(_pythia8.CoupSUSY_LllZ_get, _pythia8.CoupSUSY_LllZ_set)
//    __swig_setmethods__["RllZ"] = _pythia8.CoupSUSY_RllZ_set
//    __swig_getmethods__["RllZ"] = _pythia8.CoupSUSY_RllZ_get
//    if _newclass:
//        RllZ = _swig_property(_pythia8.CoupSUSY_RllZ_get, _pythia8.CoupSUSY_RllZ_set)
//    __swig_setmethods__["LlvW"] = _pythia8.CoupSUSY_LlvW_set
//    __swig_getmethods__["LlvW"] = _pythia8.CoupSUSY_LlvW_get
//    if _newclass:
//        LlvW = _swig_property(_pythia8.CoupSUSY_LlvW_get, _pythia8.CoupSUSY_LlvW_set)
//    __swig_setmethods__["RlvW"] = _pythia8.CoupSUSY_RlvW_set
//    __swig_getmethods__["RlvW"] = _pythia8.CoupSUSY_RlvW_get
//    if _newclass:
//        RlvW = _swig_property(_pythia8.CoupSUSY_RlvW_get, _pythia8.CoupSUSY_RlvW_set)
//    __swig_setmethods__["LslslZ"] = _pythia8.CoupSUSY_LslslZ_set
//    __swig_getmethods__["LslslZ"] = _pythia8.CoupSUSY_LslslZ_get
//    if _newclass:
//        LslslZ = _swig_property(_pythia8.CoupSUSY_LslslZ_get, _pythia8.CoupSUSY_LslslZ_set)
//    __swig_setmethods__["RslslZ"] = _pythia8.CoupSUSY_RslslZ_set
//    __swig_getmethods__["RslslZ"] = _pythia8.CoupSUSY_RslslZ_get
//    if _newclass:
//        RslslZ = _swig_property(_pythia8.CoupSUSY_RslslZ_get, _pythia8.CoupSUSY_RslslZ_set)
//    __swig_setmethods__["LsvsvZ"] = _pythia8.CoupSUSY_LsvsvZ_set
//    __swig_getmethods__["LsvsvZ"] = _pythia8.CoupSUSY_LsvsvZ_get
//    if _newclass:
//        LsvsvZ = _swig_property(_pythia8.CoupSUSY_LsvsvZ_get, _pythia8.CoupSUSY_LsvsvZ_set)
//    __swig_setmethods__["RsvsvZ"] = _pythia8.CoupSUSY_RsvsvZ_set
//    __swig_getmethods__["RsvsvZ"] = _pythia8.CoupSUSY_RsvsvZ_get
//    if _newclass:
//        RsvsvZ = _swig_property(_pythia8.CoupSUSY_RsvsvZ_get, _pythia8.CoupSUSY_RsvsvZ_set)
//    __swig_setmethods__["LslsvW"] = _pythia8.CoupSUSY_LslsvW_set
//    __swig_getmethods__["LslsvW"] = _pythia8.CoupSUSY_LslsvW_get
//    if _newclass:
//        LslsvW = _swig_property(_pythia8.CoupSUSY_LslsvW_get, _pythia8.CoupSUSY_LslsvW_set)
//    __swig_setmethods__["RslsvW"] = _pythia8.CoupSUSY_RslsvW_set
//    __swig_getmethods__["RslsvW"] = _pythia8.CoupSUSY_RslsvW_get
//    if _newclass:
//        RslsvW = _swig_property(_pythia8.CoupSUSY_RslsvW_get, _pythia8.CoupSUSY_RslsvW_set)
//    __swig_setmethods__["Rusq"] = _pythia8.CoupSUSY_Rusq_set
//    __swig_getmethods__["Rusq"] = _pythia8.CoupSUSY_Rusq_get
//    if _newclass:
//        Rusq = _swig_property(_pythia8.CoupSUSY_Rusq_get, _pythia8.CoupSUSY_Rusq_set)
//    __swig_setmethods__["Rdsq"] = _pythia8.CoupSUSY_Rdsq_set
//    __swig_getmethods__["Rdsq"] = _pythia8.CoupSUSY_Rdsq_get
//    if _newclass:
//        Rdsq = _swig_property(_pythia8.CoupSUSY_Rdsq_get, _pythia8.CoupSUSY_Rdsq_set)
//    __swig_setmethods__["Rsl"] = _pythia8.CoupSUSY_Rsl_set
//    __swig_getmethods__["Rsl"] = _pythia8.CoupSUSY_Rsl_get
//    if _newclass:
//        Rsl = _swig_property(_pythia8.CoupSUSY_Rsl_get, _pythia8.CoupSUSY_Rsl_set)
//    __swig_setmethods__["Rsv"] = _pythia8.CoupSUSY_Rsv_set
//    __swig_getmethods__["Rsv"] = _pythia8.CoupSUSY_Rsv_get
//    if _newclass:
//        Rsv = _swig_property(_pythia8.CoupSUSY_Rsv_get, _pythia8.CoupSUSY_Rsv_set)
//
//    def idNeut(self, idChi):
//        """
//~du~chi+ couplings
//~ud~chi+ couplings
//~l~lZ couplings
//~l~vW couplings
//~ll~chi0 couplings
//~vl~chi+ couplings
//~lv~chi+ couplings
//RPV couplings
//Return neutralino, chargino, sup, sdown and slepton flavour codes.
//"""
//        return _pythia8.CoupSUSY_idNeut(self, idChi)
//
//    def idChar(self, idChi):
//        """
//"""
//        return _pythia8.CoupSUSY_idChar(self, idChi)
//
//    def idSup(self, iSup):
//        """
//"""
//        return _pythia8.CoupSUSY_idSup(self, iSup)
//
//    def idSdown(self, iSdown):
//        """
//"""
//        return _pythia8.CoupSUSY_idSdown(self, iSdown)
//
//    def idSlep(self, iSlep):
//        """
//"""
//        return _pythia8.CoupSUSY_idSlep(self, iSlep)
//
//    def typeNeut(self, idPDG):
//        """
//"""
//        return _pythia8.CoupSUSY_typeNeut(self, idPDG)
//
//    def typeChar(self, idPDG):
//        """
//"""
//        return _pythia8.CoupSUSY_typeChar(self, idPDG)
//    __swig_setmethods__["slhaPtr"] = _pythia8.CoupSUSY_slhaPtr_set
//    __swig_getmethods__["slhaPtr"] = _pythia8.CoupSUSY_slhaPtr_get
//    if _newclass:
//        slhaPtr = _swig_property(_pythia8.CoupSUSY_slhaPtr_get, _pythia8.CoupSUSY_slhaPtr_set)
//    __swig_destroy__ = _pythia8.delete_CoupSUSY
//    __del__ = lambda self: None
//CoupSUSY_swigregister = _pythia8.CoupSUSY_swigregister
//CoupSUSY_swigregister(CoupSUSY)
//
//class BeamShape(_object):
//    """
//Base class to set beam momentum and interaction spot spread.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, BeamShape, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, BeamShape, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        if self.__class__ == BeamShape:
//            _self = None
//        else:
//            _self = self
//        this = _pythia8.new_BeamShape(_self, )
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_BeamShape
//    __del__ = lambda self: None
//
//    def init(self, settings, rndmPtrIn):
//        """
//Initialize beam parameters.
//"""
//        return _pythia8.BeamShape_init(self, settings, rndmPtrIn)
//
//    def pick(self):
//        """
//Set the two beam momentum deviations and the beam vertex.
//"""
//        return _pythia8.BeamShape_pick(self)
//
//    def deltaPA(self):
//        """
//Methods to read out the choice made with the above method.
//"""
//        return _pythia8.BeamShape_deltaPA(self)
//
//    def deltaPB(self):
//        """
//"""
//        return _pythia8.BeamShape_deltaPB(self)
//
//    def vertex(self):
//        """
//"""
//        return _pythia8.BeamShape_vertex(self)
//    __swig_setmethods__["deltaPxA"] = _pythia8.BeamShape_deltaPxA_set
//    __swig_getmethods__["deltaPxA"] = _pythia8.BeamShape_deltaPxA_get
//    if _newclass:
//        deltaPxA = _swig_property(_pythia8.BeamShape_deltaPxA_get, _pythia8.BeamShape_deltaPxA_set)
//    __swig_setmethods__["deltaPyA"] = _pythia8.BeamShape_deltaPyA_set
//    __swig_getmethods__["deltaPyA"] = _pythia8.BeamShape_deltaPyA_get
//    if _newclass:
//        deltaPyA = _swig_property(_pythia8.BeamShape_deltaPyA_get, _pythia8.BeamShape_deltaPyA_set)
//    __swig_setmethods__["deltaPzA"] = _pythia8.BeamShape_deltaPzA_set
//    __swig_getmethods__["deltaPzA"] = _pythia8.BeamShape_deltaPzA_get
//    if _newclass:
//        deltaPzA = _swig_property(_pythia8.BeamShape_deltaPzA_get, _pythia8.BeamShape_deltaPzA_set)
//    __swig_setmethods__["deltaPxB"] = _pythia8.BeamShape_deltaPxB_set
//    __swig_getmethods__["deltaPxB"] = _pythia8.BeamShape_deltaPxB_get
//    if _newclass:
//        deltaPxB = _swig_property(_pythia8.BeamShape_deltaPxB_get, _pythia8.BeamShape_deltaPxB_set)
//    __swig_setmethods__["deltaPyB"] = _pythia8.BeamShape_deltaPyB_set
//    __swig_getmethods__["deltaPyB"] = _pythia8.BeamShape_deltaPyB_get
//    if _newclass:
//        deltaPyB = _swig_property(_pythia8.BeamShape_deltaPyB_get, _pythia8.BeamShape_deltaPyB_set)
//    __swig_setmethods__["deltaPzB"] = _pythia8.BeamShape_deltaPzB_set
//    __swig_getmethods__["deltaPzB"] = _pythia8.BeamShape_deltaPzB_get
//    if _newclass:
//        deltaPzB = _swig_property(_pythia8.BeamShape_deltaPzB_get, _pythia8.BeamShape_deltaPzB_set)
//    __swig_setmethods__["vertexX"] = _pythia8.BeamShape_vertexX_set
//    __swig_getmethods__["vertexX"] = _pythia8.BeamShape_vertexX_get
//    if _newclass:
//        vertexX = _swig_property(_pythia8.BeamShape_vertexX_get, _pythia8.BeamShape_vertexX_set)
//    __swig_setmethods__["vertexY"] = _pythia8.BeamShape_vertexY_set
//    __swig_getmethods__["vertexY"] = _pythia8.BeamShape_vertexY_get
//    if _newclass:
//        vertexY = _swig_property(_pythia8.BeamShape_vertexY_get, _pythia8.BeamShape_vertexY_set)
//    __swig_setmethods__["vertexZ"] = _pythia8.BeamShape_vertexZ_set
//    __swig_getmethods__["vertexZ"] = _pythia8.BeamShape_vertexZ_get
//    if _newclass:
//        vertexZ = _swig_property(_pythia8.BeamShape_vertexZ_get, _pythia8.BeamShape_vertexZ_set)
//    __swig_setmethods__["vertexT"] = _pythia8.BeamShape_vertexT_set
//    __swig_getmethods__["vertexT"] = _pythia8.BeamShape_vertexT_get
//    if _newclass:
//        vertexT = _swig_property(_pythia8.BeamShape_vertexT_get, _pythia8.BeamShape_vertexT_set)
//    __swig_setmethods__["allowMomentumSpread"] = _pythia8.BeamShape_allowMomentumSpread_set
//    __swig_getmethods__["allowMomentumSpread"] = _pythia8.BeamShape_allowMomentumSpread_get
//    if _newclass:
//        allowMomentumSpread = _swig_property(_pythia8.BeamShape_allowMomentumSpread_get, _pythia8.BeamShape_allowMomentumSpread_set)
//    __swig_setmethods__["allowVertexSpread"] = _pythia8.BeamShape_allowVertexSpread_set
//    __swig_getmethods__["allowVertexSpread"] = _pythia8.BeamShape_allowVertexSpread_get
//    if _newclass:
//        allowVertexSpread = _swig_property(_pythia8.BeamShape_allowVertexSpread_get, _pythia8.BeamShape_allowVertexSpread_set)
//    __swig_setmethods__["sigmaPxA"] = _pythia8.BeamShape_sigmaPxA_set
//    __swig_getmethods__["sigmaPxA"] = _pythia8.BeamShape_sigmaPxA_get
//    if _newclass:
//        sigmaPxA = _swig_property(_pythia8.BeamShape_sigmaPxA_get, _pythia8.BeamShape_sigmaPxA_set)
//    __swig_setmethods__["sigmaPyA"] = _pythia8.BeamShape_sigmaPyA_set
//    __swig_getmethods__["sigmaPyA"] = _pythia8.BeamShape_sigmaPyA_get
//    if _newclass:
//        sigmaPyA = _swig_property(_pythia8.BeamShape_sigmaPyA_get, _pythia8.BeamShape_sigmaPyA_set)
//    __swig_setmethods__["sigmaPzA"] = _pythia8.BeamShape_sigmaPzA_set
//    __swig_getmethods__["sigmaPzA"] = _pythia8.BeamShape_sigmaPzA_get
//    if _newclass:
//        sigmaPzA = _swig_property(_pythia8.BeamShape_sigmaPzA_get, _pythia8.BeamShape_sigmaPzA_set)
//    __swig_setmethods__["maxDevA"] = _pythia8.BeamShape_maxDevA_set
//    __swig_getmethods__["maxDevA"] = _pythia8.BeamShape_maxDevA_get
//    if _newclass:
//        maxDevA = _swig_property(_pythia8.BeamShape_maxDevA_get, _pythia8.BeamShape_maxDevA_set)
//    __swig_setmethods__["sigmaPxB"] = _pythia8.BeamShape_sigmaPxB_set
//    __swig_getmethods__["sigmaPxB"] = _pythia8.BeamShape_sigmaPxB_get
//    if _newclass:
//        sigmaPxB = _swig_property(_pythia8.BeamShape_sigmaPxB_get, _pythia8.BeamShape_sigmaPxB_set)
//    __swig_setmethods__["sigmaPyB"] = _pythia8.BeamShape_sigmaPyB_set
//    __swig_getmethods__["sigmaPyB"] = _pythia8.BeamShape_sigmaPyB_get
//    if _newclass:
//        sigmaPyB = _swig_property(_pythia8.BeamShape_sigmaPyB_get, _pythia8.BeamShape_sigmaPyB_set)
//    __swig_setmethods__["sigmaPzB"] = _pythia8.BeamShape_sigmaPzB_set
//    __swig_getmethods__["sigmaPzB"] = _pythia8.BeamShape_sigmaPzB_get
//    if _newclass:
//        sigmaPzB = _swig_property(_pythia8.BeamShape_sigmaPzB_get, _pythia8.BeamShape_sigmaPzB_set)
//    __swig_setmethods__["maxDevB"] = _pythia8.BeamShape_maxDevB_set
//    __swig_getmethods__["maxDevB"] = _pythia8.BeamShape_maxDevB_get
//    if _newclass:
//        maxDevB = _swig_property(_pythia8.BeamShape_maxDevB_get, _pythia8.BeamShape_maxDevB_set)
//    __swig_setmethods__["sigmaVertexX"] = _pythia8.BeamShape_sigmaVertexX_set
//    __swig_getmethods__["sigmaVertexX"] = _pythia8.BeamShape_sigmaVertexX_get
//    if _newclass:
//        sigmaVertexX = _swig_property(_pythia8.BeamShape_sigmaVertexX_get, _pythia8.BeamShape_sigmaVertexX_set)
//    __swig_setmethods__["sigmaVertexY"] = _pythia8.BeamShape_sigmaVertexY_set
//    __swig_getmethods__["sigmaVertexY"] = _pythia8.BeamShape_sigmaVertexY_get
//    if _newclass:
//        sigmaVertexY = _swig_property(_pythia8.BeamShape_sigmaVertexY_get, _pythia8.BeamShape_sigmaVertexY_set)
//    __swig_setmethods__["sigmaVertexZ"] = _pythia8.BeamShape_sigmaVertexZ_set
//    __swig_getmethods__["sigmaVertexZ"] = _pythia8.BeamShape_sigmaVertexZ_get
//    if _newclass:
//        sigmaVertexZ = _swig_property(_pythia8.BeamShape_sigmaVertexZ_get, _pythia8.BeamShape_sigmaVertexZ_set)
//    __swig_setmethods__["maxDevVertex"] = _pythia8.BeamShape_maxDevVertex_set
//    __swig_getmethods__["maxDevVertex"] = _pythia8.BeamShape_maxDevVertex_get
//    if _newclass:
//        maxDevVertex = _swig_property(_pythia8.BeamShape_maxDevVertex_get, _pythia8.BeamShape_maxDevVertex_set)
//    __swig_setmethods__["sigmaTime"] = _pythia8.BeamShape_sigmaTime_set
//    __swig_getmethods__["sigmaTime"] = _pythia8.BeamShape_sigmaTime_get
//    if _newclass:
//        sigmaTime = _swig_property(_pythia8.BeamShape_sigmaTime_get, _pythia8.BeamShape_sigmaTime_set)
//    __swig_setmethods__["maxDevTime"] = _pythia8.BeamShape_maxDevTime_set
//    __swig_getmethods__["maxDevTime"] = _pythia8.BeamShape_maxDevTime_get
//    if _newclass:
//        maxDevTime = _swig_property(_pythia8.BeamShape_maxDevTime_get, _pythia8.BeamShape_maxDevTime_set)
//    __swig_setmethods__["offsetX"] = _pythia8.BeamShape_offsetX_set
//    __swig_getmethods__["offsetX"] = _pythia8.BeamShape_offsetX_get
//    if _newclass:
//        offsetX = _swig_property(_pythia8.BeamShape_offsetX_get, _pythia8.BeamShape_offsetX_set)
//    __swig_setmethods__["offsetY"] = _pythia8.BeamShape_offsetY_set
//    __swig_getmethods__["offsetY"] = _pythia8.BeamShape_offsetY_get
//    if _newclass:
//        offsetY = _swig_property(_pythia8.BeamShape_offsetY_get, _pythia8.BeamShape_offsetY_set)
//    __swig_setmethods__["offsetZ"] = _pythia8.BeamShape_offsetZ_set
//    __swig_getmethods__["offsetZ"] = _pythia8.BeamShape_offsetZ_get
//    if _newclass:
//        offsetZ = _swig_property(_pythia8.BeamShape_offsetZ_get, _pythia8.BeamShape_offsetZ_set)
//    __swig_setmethods__["offsetT"] = _pythia8.BeamShape_offsetT_set
//    __swig_getmethods__["offsetT"] = _pythia8.BeamShape_offsetT_get
//    if _newclass:
//        offsetT = _swig_property(_pythia8.BeamShape_offsetT_get, _pythia8.BeamShape_offsetT_set)
//    __swig_setmethods__["rndmPtr"] = _pythia8.BeamShape_rndmPtr_set
//    __swig_getmethods__["rndmPtr"] = _pythia8.BeamShape_rndmPtr_get
//    if _newclass:
//        rndmPtr = _swig_property(_pythia8.BeamShape_rndmPtr_get, _pythia8.BeamShape_rndmPtr_set)
//    def __disown__(self):
//        self.this.disown()
//        _pythia8.disown_BeamShape(self)
//        return weakref_proxy(self)
//BeamShape_swigregister = _pythia8.BeamShape_swigregister
//BeamShape_swigregister(BeamShape)
//
//class DecayChannel(_object):
//    """
//This class holds info on a single decay channel.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, DecayChannel, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, DecayChannel, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, onModeIn=0, bRatioIn=0., meModeIn=0, prod0=0, prod1=0, prod2=0, prod3=0, prod4=0, prod5=0, prod6=0, prod7=0):
//        """
//Constructor.
//"""
//        this = _pythia8.new_DecayChannel(onModeIn, bRatioIn, meModeIn, prod0, prod1, prod2, prod3, prod4, prod5, prod6, prod7)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def rescaleBR(self, fac):
//        """
//"""
//        return _pythia8.DecayChannel_rescaleBR(self, fac)
//
//    def setHasChanged(self, hasChangedIn):
//        """
//"""
//        return _pythia8.DecayChannel_setHasChanged(self, hasChangedIn)
//
//    def onMode(self, *args):
//        """
//Member functions for output.
//"""
//        return _pythia8.DecayChannel_onMode(self, *args)
//
//    def bRatio(self, *args):
//        """
//"""
//        return _pythia8.DecayChannel_bRatio(self, *args)
//
//    def meMode(self, *args):
//        """
//"""
//        return _pythia8.DecayChannel_meMode(self, *args)
//
//    def multiplicity(self, *args):
//        """
//"""
//        return _pythia8.DecayChannel_multiplicity(self, *args)
//
//    def product(self, *args):
//        """
//"""
//        return _pythia8.DecayChannel_product(self, *args)
//
//    def hasChanged(self):
//        """
//"""
//        return _pythia8.DecayChannel_hasChanged(self)
//
//    def contains(self, *args):
//        """
//"""
//        return _pythia8.DecayChannel_contains(self, *args)
//
//    def currentBR(self, *args):
//        """
//"""
//        return _pythia8.DecayChannel_currentBR(self, *args)
//
//    def onShellWidth(self, *args):
//        """
//"""
//        return _pythia8.DecayChannel_onShellWidth(self, *args)
//
//    def onShellWidthFactor(self, factor):
//        """
//"""
//        return _pythia8.DecayChannel_onShellWidthFactor(self, factor)
//
//    def openSec(self, *args):
//        """
//"""
//        return _pythia8.DecayChannel_openSec(self, *args)
//    __swig_destroy__ = _pythia8.delete_DecayChannel
//    __del__ = lambda self: None
//DecayChannel_swigregister = _pythia8.DecayChannel_swigregister
//DecayChannel_swigregister(DecayChannel)
//
//class ParticleDataEntry(_object):
//    """
//This class holds info on a single particle species.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ParticleDataEntry, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, ParticleDataEntry, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_ParticleDataEntry(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ParticleDataEntry
//    __del__ = lambda self: None
//
//    def setDefaults(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_setDefaults(self)
//
//    def initPtr(self, particleDataPtrIn):
//        """
//Store pointer to whole particle data table/database.
//"""
//        return _pythia8.ParticleDataEntry_initPtr(self, particleDataPtrIn)
//
//    def setAll(self, nameIn, antiNameIn, spinTypeIn=0, chargeTypeIn=0, colTypeIn=0, m0In=0., mWidthIn=0., mMinIn=0., mMaxIn=0., tau0In=0.):
//        """
//Reset all the properties of an existing particle.
//"""
//        return _pythia8.ParticleDataEntry_setAll(self, nameIn, antiNameIn, spinTypeIn, chargeTypeIn, colTypeIn, m0In, mWidthIn, mMinIn, mMaxIn, tau0In)
//
//    def setName(self, nameIn):
//        """
//Change current values one at a time (or set if not set before).
//(Must use set here since else name+signature clash with get methods.)
//"""
//        return _pythia8.ParticleDataEntry_setName(self, nameIn)
//
//    def setAntiName(self, antiNameIn):
//        """
//"""
//        return _pythia8.ParticleDataEntry_setAntiName(self, antiNameIn)
//
//    def setNames(self, nameIn, antiNameIn):
//        """
//"""
//        return _pythia8.ParticleDataEntry_setNames(self, nameIn, antiNameIn)
//
//    def setSpinType(self, spinTypeIn):
//        """
//"""
//        return _pythia8.ParticleDataEntry_setSpinType(self, spinTypeIn)
//
//    def setChargeType(self, chargeTypeIn):
//        """
//"""
//        return _pythia8.ParticleDataEntry_setChargeType(self, chargeTypeIn)
//
//    def setColType(self, colTypeIn):
//        """
//"""
//        return _pythia8.ParticleDataEntry_setColType(self, colTypeIn)
//
//    def setM0(self, m0In):
//        """
//"""
//        return _pythia8.ParticleDataEntry_setM0(self, m0In)
//
//    def setMWidth(self, mWidthIn, countAsChanged=True):
//        """
//"""
//        return _pythia8.ParticleDataEntry_setMWidth(self, mWidthIn, countAsChanged)
//
//    def setMMin(self, mMinIn):
//        """
//"""
//        return _pythia8.ParticleDataEntry_setMMin(self, mMinIn)
//
//    def setMMax(self, mMaxIn):
//        """
//"""
//        return _pythia8.ParticleDataEntry_setMMax(self, mMaxIn)
//
//    def setMMinNoChange(self, mMinIn):
//        """
//Special options specifically when cutting wings of Breit-Wigners.
//"""
//        return _pythia8.ParticleDataEntry_setMMinNoChange(self, mMinIn)
//
//    def setMMaxNoChange(self, mMaxIn):
//        """
//"""
//        return _pythia8.ParticleDataEntry_setMMaxNoChange(self, mMaxIn)
//
//    def setTau0(self, tau0In):
//        """
//"""
//        return _pythia8.ParticleDataEntry_setTau0(self, tau0In)
//
//    def setIsResonance(self, isResonanceIn):
//        """
//"""
//        return _pythia8.ParticleDataEntry_setIsResonance(self, isResonanceIn)
//
//    def setMayDecay(self, mayDecayIn, countAsChanged=True):
//        """
//"""
//        return _pythia8.ParticleDataEntry_setMayDecay(self, mayDecayIn, countAsChanged)
//
//    def setDoExternalDecay(self, doExternalDecayIn):
//        """
//"""
//        return _pythia8.ParticleDataEntry_setDoExternalDecay(self, doExternalDecayIn)
//
//    def setIsVisible(self, isVisibleIn):
//        """
//"""
//        return _pythia8.ParticleDataEntry_setIsVisible(self, isVisibleIn)
//
//    def setDoForceWidth(self, doForceWidthIn):
//        """
//"""
//        return _pythia8.ParticleDataEntry_setDoForceWidth(self, doForceWidthIn)
//
//    def setHasChanged(self, hasChangedIn):
//        """
//"""
//        return _pythia8.ParticleDataEntry_setHasChanged(self, hasChangedIn)
//
//    def id(self):
//        """
//Give back current values.
//"""
//        return _pythia8.ParticleDataEntry_id(self)
//
//    def hasAnti(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_hasAnti(self)
//
//    def name(self, idIn=1):
//        """
//"""
//        return _pythia8.ParticleDataEntry_name(self, idIn)
//
//    def spinType(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_spinType(self)
//
//    def chargeType(self, idIn=1):
//        """
//"""
//        return _pythia8.ParticleDataEntry_chargeType(self, idIn)
//
//    def charge(self, idIn=1):
//        """
//"""
//        return _pythia8.ParticleDataEntry_charge(self, idIn)
//
//    def colType(self, idIn=1):
//        """
//"""
//        return _pythia8.ParticleDataEntry_colType(self, idIn)
//
//    def m0(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_m0(self)
//
//    def mWidth(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_mWidth(self)
//
//    def mMin(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_mMin(self)
//
//    def mMax(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_mMax(self)
//
//    def m0Min(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_m0Min(self)
//
//    def m0Max(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_m0Max(self)
//
//    def tau0(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_tau0(self)
//
//    def isResonance(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_isResonance(self)
//
//    def mayDecay(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_mayDecay(self)
//
//    def doExternalDecay(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_doExternalDecay(self)
//
//    def isVisible(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_isVisible(self)
//
//    def doForceWidth(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_doForceWidth(self)
//
//    def hasChanged(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_hasChanged(self)
//
//    def hasChangedMMin(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_hasChangedMMin(self)
//
//    def hasChangedMMax(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_hasChangedMMax(self)
//
//    def initBWmass(self):
//        """
//Set and give back several mass-related quantities.
//"""
//        return _pythia8.ParticleDataEntry_initBWmass(self)
//
//    def constituentMass(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_constituentMass(self)
//
//    def mSel(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_mSel(self)
//
//    def mRun(self, mH):
//        """
//"""
//        return _pythia8.ParticleDataEntry_mRun(self, mH)
//
//    def useBreitWigner(self):
//        """
//Give back other quantities.
//"""
//        return _pythia8.ParticleDataEntry_useBreitWigner(self)
//
//    def canDecay(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_canDecay(self)
//
//    def isLepton(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_isLepton(self)
//
//    def isQuark(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_isQuark(self)
//
//    def isGluon(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_isGluon(self)
//
//    def isDiquark(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_isDiquark(self)
//
//    def isParton(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_isParton(self)
//
//    def isHadron(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_isHadron(self)
//
//    def isMeson(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_isMeson(self)
//
//    def isBaryon(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_isBaryon(self)
//
//    def isOctetHadron(self):
//        """
//Intermediate octet ccbar or bbar states in colour-octet model.
//"""
//        return _pythia8.ParticleDataEntry_isOctetHadron(self)
//
//    def heaviestQuark(self, idIn=1):
//        """
//"""
//        return _pythia8.ParticleDataEntry_heaviestQuark(self, idIn)
//
//    def baryonNumberType(self, idIn=1):
//        """
//"""
//        return _pythia8.ParticleDataEntry_baryonNumberType(self, idIn)
//
//    def nQuarksInCode(self, idQIn):
//        """
//"""
//        return _pythia8.ParticleDataEntry_nQuarksInCode(self, idQIn)
//
//    def clearChannels(self):
//        """
//Reset to empty decay table.
//"""
//        return _pythia8.ParticleDataEntry_clearChannels(self)
//
//    def addChannel(self, onMode=0, bRatio=0., meMode=0, prod0=0, prod1=0, prod2=0, prod3=0, prod4=0, prod5=0, prod6=0, prod7=0):
//        """
//Add a decay channel to the decay table.
//"""
//        return _pythia8.ParticleDataEntry_addChannel(self, onMode, bRatio, meMode, prod0, prod1, prod2, prod3, prod4, prod5, prod6, prod7)
//
//    def sizeChannels(self):
//        """
//Decay table size.
//"""
//        return _pythia8.ParticleDataEntry_sizeChannels(self)
//
//    def channel(self, *args):
//        """
//"""
//        return _pythia8.ParticleDataEntry_channel(self, *args)
//
//    def rescaleBR(self, newSumBR=1.):
//        """
//Rescale sum of branching ratios to unity.
//"""
//        return _pythia8.ParticleDataEntry_rescaleBR(self, newSumBR)
//
//    def preparePick(self, idSgn, mHat=0., idInFlav=0):
//        """
//Random choice of decay channel according to branching ratios.
//"""
//        return _pythia8.ParticleDataEntry_preparePick(self, idSgn, mHat, idInFlav)
//
//    def pickChannel(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_pickChannel(self)
//
//    def setResonancePtr(self, resonancePtrIn):
//        """
//Access methods stored in ResonanceWidths.
//"""
//        return _pythia8.ParticleDataEntry_setResonancePtr(self, resonancePtrIn)
//
//    def getResonancePtr(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_getResonancePtr(self)
//
//    def resInit(self, infoPtrIn, settingsPtrIn, particleDataPtrIn, couplingsPtrIn):
//        """
//"""
//        return _pythia8.ParticleDataEntry_resInit(self, infoPtrIn, settingsPtrIn, particleDataPtrIn, couplingsPtrIn)
//
//    def resWidth(self, idSgn, mHat, idIn=0, openOnly=False, setBR=False):
//        """
//"""
//        return _pythia8.ParticleDataEntry_resWidth(self, idSgn, mHat, idIn, openOnly, setBR)
//
//    def resWidthOpen(self, idSgn, mHat, idIn=0):
//        """
//"""
//        return _pythia8.ParticleDataEntry_resWidthOpen(self, idSgn, mHat, idIn)
//
//    def resWidthStore(self, idSgn, mHat, idIn=0):
//        """
//"""
//        return _pythia8.ParticleDataEntry_resWidthStore(self, idSgn, mHat, idIn)
//
//    def resOpenFrac(self, idSgn):
//        """
//"""
//        return _pythia8.ParticleDataEntry_resOpenFrac(self, idSgn)
//
//    def resWidthRescaleFactor(self):
//        """
//"""
//        return _pythia8.ParticleDataEntry_resWidthRescaleFactor(self)
//
//    def resWidthChan(self, mHat, idAbs1=0, idAbs2=0):
//        """
//"""
//        return _pythia8.ParticleDataEntry_resWidthChan(self, mHat, idAbs1, idAbs2)
//ParticleDataEntry_swigregister = _pythia8.ParticleDataEntry_swigregister
//ParticleDataEntry_swigregister(ParticleDataEntry)
//
//class ParticleData(_object):
//    """
//This class holds a map of all ParticleDataEntries.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ParticleData, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, ParticleData, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ParticleData()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initPtr(self, infoPtrIn, settingsPtrIn, rndmPtrIn, couplingsPtrIn):
//        """
//Initialize pointers.
//"""
//        return _pythia8.ParticleData_initPtr(self, infoPtrIn, settingsPtrIn, rndmPtrIn, couplingsPtrIn)
//
//    def init(self, *args):
//        """
//Read in database from an istream.
//"""
//        return _pythia8.ParticleData_init(self, *args)
//
//    def reInit(self, startFile, xmlFormat=True):
//        """
//Overwrite existing database by reading from specific file.
//"""
//        return _pythia8.ParticleData_reInit(self, startFile, xmlFormat)
//
//    def initWidths(self, resonancePtrs):
//        """
//Initialize pointers, normal Breit-Wigners and special resonances.
//"""
//        return _pythia8.ParticleData_initWidths(self, resonancePtrs)
//
//    def listXML(self, outFile):
//        """
//"""
//        return _pythia8.ParticleData_listXML(self, outFile)
//
//    def readXML(self, *args):
//        """
//"""
//        return _pythia8.ParticleData_readXML(self, *args)
//
//    def copyXML(self, particleDataIn):
//        """
//Copy and process XML information from another particleData object.
//"""
//        return _pythia8.ParticleData_copyXML(self, particleDataIn)
//
//    def loadXML(self, *args):
//        """
//"""
//        return _pythia8.ParticleData_loadXML(self, *args)
//
//    def processXML(self, reset=True):
//        """
//"""
//        return _pythia8.ParticleData_processXML(self, reset)
//
//    def readFF(self, *args):
//        """
//"""
//        return _pythia8.ParticleData_readFF(self, *args)
//
//    def listFF(self, outFile):
//        """
//"""
//        return _pythia8.ParticleData_listFF(self, outFile)
//
//    def readString(self, lineIn, warn=True):
//        """
//Read in one update from a single line.
//"""
//        return _pythia8.ParticleData_readString(self, lineIn, warn)
//
//    def readingFailed(self):
//        """
//Keep track whether any readings have failed, invalidating run setup.
//"""
//        return _pythia8.ParticleData_readingFailed(self)
//
//    def listAll(self):
//        """
//Print out table of whole database, or of only part of it.
//"""
//        return _pythia8.ParticleData_listAll(self)
//
//    def listChanged(self, changedRes=False):
//        """
//"""
//        return _pythia8.ParticleData_listChanged(self, changedRes)
//
//    def getReadHistory(self, subrun=-999):
//        """
//Retrieve readString history (e.g., for inspection). Everything
//(subrun=-999), up to first subrun (=-1), or subrun-specific (>=0).
//"""
//        return _pythia8.ParticleData_getReadHistory(self, subrun)
//
//    def checkTable(self, verbosity=1):
//        """
//Check that table makes sense, especially for decays.
//"""
//        return _pythia8.ParticleData_checkTable(self, verbosity)
//
//    def addParticle(self, *args):
//        """
//"""
//        return _pythia8.ParticleData_addParticle(self, *args)
//
//    def setAll(self, idIn, nameIn, antiNameIn, spinTypeIn=0, chargeTypeIn=0, colTypeIn=0, m0In=0., mWidthIn=0., mMinIn=0., mMaxIn=0., tau0In=0.):
//        """
//Reset all the properties of an entry in one go.
//"""
//        return _pythia8.ParticleData_setAll(self, idIn, nameIn, antiNameIn, spinTypeIn, chargeTypeIn, colTypeIn, m0In, mWidthIn, mMinIn, mMaxIn, tau0In)
//
//    def isParticle(self, idIn):
//        """
//Query existence of an entry.
//"""
//        return _pythia8.ParticleData_isParticle(self, idIn)
//
//    def findParticle(self, *args):
//        """
//"""
//        return _pythia8.ParticleData_findParticle(self, *args)
//
//    def nextId(self, idIn):
//        """
//Return the id of the sequentially next particle stored in table.
//"""
//        return _pythia8.ParticleData_nextId(self, idIn)
//
//    def antiName(self, idIn, antiNameIn):
//        """
//"""
//        return _pythia8.ParticleData_antiName(self, idIn, antiNameIn)
//
//    def names(self, idIn, nameIn, antiNameIn):
//        """
//"""
//        return _pythia8.ParticleData_names(self, idIn, nameIn, antiNameIn)
//
//    def hasAnti(self, idIn):
//        """
//Give back current values.
//"""
//        return _pythia8.ParticleData_hasAnti(self, idIn)
//
//    def name(self, *args):
//        """
//"""
//        return _pythia8.ParticleData_name(self, *args)
//
//    def spinType(self, *args):
//        """
//"""
//        return _pythia8.ParticleData_spinType(self, *args)
//
//    def chargeType(self, *args):
//        """
//"""
//        return _pythia8.ParticleData_chargeType(self, *args)
//
//    def charge(self, idIn):
//        """
//"""
//        return _pythia8.ParticleData_charge(self, idIn)
//
//    def colType(self, *args):
//        """
//"""
//        return _pythia8.ParticleData_colType(self, *args)
//
//    def m0(self, *args):
//        """
//"""
//        return _pythia8.ParticleData_m0(self, *args)
//
//    def mWidth(self, *args):
//        """
//"""
//        return _pythia8.ParticleData_mWidth(self, *args)
//
//    def mMin(self, *args):
//        """
//"""
//        return _pythia8.ParticleData_mMin(self, *args)
//
//    def m0Min(self, idIn):
//        """
//"""
//        return _pythia8.ParticleData_m0Min(self, idIn)
//
//    def mMax(self, *args):
//        """
//"""
//        return _pythia8.ParticleData_mMax(self, *args)
//
//    def m0Max(self, idIn):
//        """
//"""
//        return _pythia8.ParticleData_m0Max(self, idIn)
//
//    def tau0(self, *args):
//        """
//"""
//        return _pythia8.ParticleData_tau0(self, *args)
//
//    def isResonance(self, *args):
//        """
//"""
//        return _pythia8.ParticleData_isResonance(self, *args)
//
//    def mayDecay(self, *args):
//        """
//"""
//        return _pythia8.ParticleData_mayDecay(self, *args)
//
//    def doExternalDecay(self, *args):
//        """
//"""
//        return _pythia8.ParticleData_doExternalDecay(self, *args)
//
//    def isVisible(self, *args):
//        """
//"""
//        return _pythia8.ParticleData_isVisible(self, *args)
//
//    def doForceWidth(self, *args):
//        """
//"""
//        return _pythia8.ParticleData_doForceWidth(self, *args)
//
//    def hasChanged(self, *args):
//        """
//"""
//        return _pythia8.ParticleData_hasChanged(self, *args)
//
//    def hasChangedMMin(self, idIn):
//        """
//"""
//        return _pythia8.ParticleData_hasChangedMMin(self, idIn)
//
//    def hasChangedMMax(self, idIn):
//        """
//"""
//        return _pythia8.ParticleData_hasChangedMMax(self, idIn)
//
//    def useBreitWigner(self, idIn):
//        """
//Give back special mass-related quantities.
//"""
//        return _pythia8.ParticleData_useBreitWigner(self, idIn)
//
//    def constituentMass(self, idIn):
//        """
//"""
//        return _pythia8.ParticleData_constituentMass(self, idIn)
//
//    def mSel(self, idIn):
//        """
//"""
//        return _pythia8.ParticleData_mSel(self, idIn)
//
//    def mRun(self, idIn, mH):
//        """
//"""
//        return _pythia8.ParticleData_mRun(self, idIn, mH)
//
//    def canDecay(self, idIn):
//        """
//Give back other quantities.
//"""
//        return _pythia8.ParticleData_canDecay(self, idIn)
//
//    def isLepton(self, idIn):
//        """
//"""
//        return _pythia8.ParticleData_isLepton(self, idIn)
//
//    def isQuark(self, idIn):
//        """
//"""
//        return _pythia8.ParticleData_isQuark(self, idIn)
//
//    def isGluon(self, idIn):
//        """
//"""
//        return _pythia8.ParticleData_isGluon(self, idIn)
//
//    def isDiquark(self, idIn):
//        """
//"""
//        return _pythia8.ParticleData_isDiquark(self, idIn)
//
//    def isParton(self, idIn):
//        """
//"""
//        return _pythia8.ParticleData_isParton(self, idIn)
//
//    def isHadron(self, idIn):
//        """
//"""
//        return _pythia8.ParticleData_isHadron(self, idIn)
//
//    def isMeson(self, idIn):
//        """
//"""
//        return _pythia8.ParticleData_isMeson(self, idIn)
//
//    def isBaryon(self, idIn):
//        """
//"""
//        return _pythia8.ParticleData_isBaryon(self, idIn)
//
//    def isOctetHadron(self, idIn):
//        """
//"""
//        return _pythia8.ParticleData_isOctetHadron(self, idIn)
//
//    def heaviestQuark(self, idIn):
//        """
//"""
//        return _pythia8.ParticleData_heaviestQuark(self, idIn)
//
//    def baryonNumberType(self, idIn):
//        """
//"""
//        return _pythia8.ParticleData_baryonNumberType(self, idIn)
//
//    def nQuarksInCode(self, idIn, idQIn):
//        """
//"""
//        return _pythia8.ParticleData_nQuarksInCode(self, idIn, idQIn)
//
//    def rescaleBR(self, idIn, newSumBR=1.):
//        """
//Change branching ratios.
//"""
//        return _pythia8.ParticleData_rescaleBR(self, idIn, newSumBR)
//
//    def setResonancePtr(self, idIn, resonancePtrIn):
//        """
//Access methods stored in ResonanceWidths.
//"""
//        return _pythia8.ParticleData_setResonancePtr(self, idIn, resonancePtrIn)
//
//    def resInit(self, idIn):
//        """
//"""
//        return _pythia8.ParticleData_resInit(self, idIn)
//
//    def resWidth(self, idIn, mHat, idInFlav=0, openOnly=False, setBR=False):
//        """
//"""
//        return _pythia8.ParticleData_resWidth(self, idIn, mHat, idInFlav, openOnly, setBR)
//
//    def resWidthOpen(self, idIn, mHat, idInFlav=0):
//        """
//"""
//        return _pythia8.ParticleData_resWidthOpen(self, idIn, mHat, idInFlav)
//
//    def resWidthStore(self, idIn, mHat, idInFlav=0):
//        """
//"""
//        return _pythia8.ParticleData_resWidthStore(self, idIn, mHat, idInFlav)
//
//    def resOpenFrac(self, id1In, id2In=0, id3In=0):
//        """
//"""
//        return _pythia8.ParticleData_resOpenFrac(self, id1In, id2In, id3In)
//
//    def resWidthRescaleFactor(self, idIn):
//        """
//"""
//        return _pythia8.ParticleData_resWidthRescaleFactor(self, idIn)
//
//    def resWidthChan(self, idIn, mHat, idAbs1=0, idAbs2=0):
//        """
//"""
//        return _pythia8.ParticleData_resWidthChan(self, idIn, mHat, idAbs1, idAbs2)
//
//    def particleDataEntryPtr(self, idIn):
//        """
//Return pointer to entry.
//"""
//        return _pythia8.ParticleData_particleDataEntryPtr(self, idIn)
//
//    def getIsInit(self):
//        """
//Check initialisation status.
//"""
//        return _pythia8.ParticleData_getIsInit(self)
//
//    def __str__(self):
//        return _pythia8.ParticleData___str__(self)
//    __swig_destroy__ = _pythia8.delete_ParticleData
//    __del__ = lambda self: None
//ParticleData_swigregister = _pythia8.ParticleData_swigregister
//ParticleData_swigregister(ParticleData)
//
//class PDF(_object):
//    """
//Base class for parton distribution functions.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, PDF, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, PDF, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idBeamIn=2212):
//        """
//Constructor.
//"""
//        if self.__class__ == PDF:
//            _self = None
//        else:
//            _self = self
//        this = _pythia8.new_PDF(_self, idBeamIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_PDF
//    __del__ = lambda self: None
//
//    def isSetup(self):
//        """
//Confirm that PDF has been set up (important for LHAPDF and H1 Pomeron).
//"""
//        return _pythia8.PDF_isSetup(self)
//
//    def newValenceContent(self, idVal1In, idVal2In):
//        """
//Dynamic choice of meson valence flavours for pi0, K0S, K0L, Pomeron.
//"""
//        return _pythia8.PDF_newValenceContent(self, idVal1In, idVal2In)
//
//    def setExtrapolate(self, arg0):
//        """
//Allow extrapolation beyond boundaries. This is optional.
//"""
//        return _pythia8.PDF_setExtrapolate(self, arg0)
//
//    def xf(self, id, x, Q2):
//        """
//Read out parton density.
//"""
//        return _pythia8.PDF_xf(self, id, x, Q2)
//
//    def xfVal(self, id, x, Q2):
//        """
//Read out valence and sea part of parton densities.
//"""
//        return _pythia8.PDF_xfVal(self, id, x, Q2)
//
//    def xfSea(self, id, x, Q2):
//        """
//"""
//        return _pythia8.PDF_xfSea(self, id, x, Q2)
//
//    def insideBounds(self, arg0, arg1):
//        """
//Check whether x and Q2 values fall inside the fit bounds (LHAPDF6 only).
//"""
//        return _pythia8.PDF_insideBounds(self, arg0, arg1)
//
//    def alphaS(self, arg0):
//        """
//Access the running alpha_s of a PDF set (LHAPDF6 only).
//"""
//        return _pythia8.PDF_alphaS(self, arg0)
//
//    def mQuarkPDF(self, arg0):
//        """
//Return quark masses used in the PDF fit (LHAPDF6 only).
//"""
//        return _pythia8.PDF_mQuarkPDF(self, arg0)
//
//    def nMembers(self):
//        """
//Return number of members of this PDF family (LHAPDF6 only).
//"""
//        return _pythia8.PDF_nMembers(self)
//
//    def calcPDFEnvelope(self, *args):
//        """
//"""
//        return _pythia8.PDF_calcPDFEnvelope(self, *args)
//
//    def getPDFEnvelope(self):
//        """
//"""
//        return _pythia8.PDF_getPDFEnvelope(self)
//
//    def gammaPDFxDependence(self, arg0, arg1):
//        """
//Approximate photon PDFs by decoupling the scale and x-dependence.
//"""
//        return _pythia8.PDF_gammaPDFxDependence(self, arg0, arg1)
//
//    def gammaPDFRefScale(self, arg0):
//        """
//Provide the reference scale for logarithmic Q^2 evolution for photons.
//"""
//        return _pythia8.PDF_gammaPDFRefScale(self, arg0)
//
//    def sampleGammaValFlavor(self, arg0):
//        """
//Sample the valence content for photons.
//"""
//        return _pythia8.PDF_sampleGammaValFlavor(self, arg0)
//
//    def xfIntegratedTotal(self, arg0):
//        """
//The total x-integrated PDFs. Relevant for MPIs with photon beams.
//"""
//        return _pythia8.PDF_xfIntegratedTotal(self, arg0)
//
//    def xGamma(self):
//        """
//Return the sampled value for x_gamma.
//"""
//        return _pythia8.PDF_xGamma(self)
//
//    def xPom(self, arg0=-1.0):
//        """
//Keep track of pomeron momentum fraction.
//"""
//        return _pythia8.PDF_xPom(self, arg0)
//
//    def xfFlux(self, arg0, arg1, arg2):
//        """
//Return accurate and approximated photon fluxes and PDFs.
//"""
//        return _pythia8.PDF_xfFlux(self, arg0, arg1, arg2)
//
//    def xfApprox(self, arg0, arg1, arg2):
//        """
//"""
//        return _pythia8.PDF_xfApprox(self, arg0, arg1, arg2)
//
//    def xfGamma(self, arg0, arg1, arg2):
//        """
//"""
//        return _pythia8.PDF_xfGamma(self, arg0, arg1, arg2)
//
//    def getQ2min(self):
//        """
//Return the kinematical limits and sample Q2 and x.
//"""
//        return _pythia8.PDF_getQ2min(self)
//
//    def getXmin(self):
//        """
//"""
//        return _pythia8.PDF_getXmin(self)
//
//    def getXhadr(self):
//        """
//"""
//        return _pythia8.PDF_getXhadr(self)
//
//    def getGammaFluxNorm(self):
//        """
//"""
//        return _pythia8.PDF_getGammaFluxNorm(self)
//
//    def sampleXgamma(self, arg0):
//        """
//"""
//        return _pythia8.PDF_sampleXgamma(self, arg0)
//
//    def sampleQ2gamma(self, arg0):
//        """
//"""
//        return _pythia8.PDF_sampleQ2gamma(self, arg0)
//
//    def xfMax(self, id, x, Q2):
//        """
//Normal PDFs unless gamma inside lepton -> an overestimate for sampling.
//"""
//        return _pythia8.PDF_xfMax(self, id, x, Q2)
//
//    def xfSame(self, id, x, Q2):
//        """
//Normal PDFs unless gamma inside lepton -> Do not sample x_gamma.
//"""
//        return _pythia8.PDF_xfSame(self, id, x, Q2)
//
//    def setVMDscale(self, arg0=1.):
//        """
//Allow for new scaling factor for VMD PDFs.
//"""
//        return _pythia8.PDF_setVMDscale(self, arg0)
//    __swig_setmethods__["idBeam"] = _pythia8.PDF_idBeam_set
//    __swig_getmethods__["idBeam"] = _pythia8.PDF_idBeam_get
//    if _newclass:
//        idBeam = _swig_property(_pythia8.PDF_idBeam_get, _pythia8.PDF_idBeam_set)
//    __swig_setmethods__["idBeamAbs"] = _pythia8.PDF_idBeamAbs_set
//    __swig_getmethods__["idBeamAbs"] = _pythia8.PDF_idBeamAbs_get
//    if _newclass:
//        idBeamAbs = _swig_property(_pythia8.PDF_idBeamAbs_get, _pythia8.PDF_idBeamAbs_set)
//    __swig_setmethods__["idSav"] = _pythia8.PDF_idSav_set
//    __swig_getmethods__["idSav"] = _pythia8.PDF_idSav_get
//    if _newclass:
//        idSav = _swig_property(_pythia8.PDF_idSav_get, _pythia8.PDF_idSav_set)
//    __swig_setmethods__["idVal1"] = _pythia8.PDF_idVal1_set
//    __swig_getmethods__["idVal1"] = _pythia8.PDF_idVal1_get
//    if _newclass:
//        idVal1 = _swig_property(_pythia8.PDF_idVal1_get, _pythia8.PDF_idVal1_set)
//    __swig_setmethods__["idVal2"] = _pythia8.PDF_idVal2_set
//    __swig_getmethods__["idVal2"] = _pythia8.PDF_idVal2_get
//    if _newclass:
//        idVal2 = _swig_property(_pythia8.PDF_idVal2_get, _pythia8.PDF_idVal2_set)
//    __swig_setmethods__["xSav"] = _pythia8.PDF_xSav_set
//    __swig_getmethods__["xSav"] = _pythia8.PDF_xSav_get
//    if _newclass:
//        xSav = _swig_property(_pythia8.PDF_xSav_get, _pythia8.PDF_xSav_set)
//    __swig_setmethods__["Q2Sav"] = _pythia8.PDF_Q2Sav_set
//    __swig_getmethods__["Q2Sav"] = _pythia8.PDF_Q2Sav_get
//    if _newclass:
//        Q2Sav = _swig_property(_pythia8.PDF_Q2Sav_get, _pythia8.PDF_Q2Sav_set)
//    __swig_setmethods__["xu"] = _pythia8.PDF_xu_set
//    __swig_getmethods__["xu"] = _pythia8.PDF_xu_get
//    if _newclass:
//        xu = _swig_property(_pythia8.PDF_xu_get, _pythia8.PDF_xu_set)
//    __swig_setmethods__["xd"] = _pythia8.PDF_xd_set
//    __swig_getmethods__["xd"] = _pythia8.PDF_xd_get
//    if _newclass:
//        xd = _swig_property(_pythia8.PDF_xd_get, _pythia8.PDF_xd_set)
//    __swig_setmethods__["xs"] = _pythia8.PDF_xs_set
//    __swig_getmethods__["xs"] = _pythia8.PDF_xs_get
//    if _newclass:
//        xs = _swig_property(_pythia8.PDF_xs_get, _pythia8.PDF_xs_set)
//    __swig_setmethods__["xubar"] = _pythia8.PDF_xubar_set
//    __swig_getmethods__["xubar"] = _pythia8.PDF_xubar_get
//    if _newclass:
//        xubar = _swig_property(_pythia8.PDF_xubar_get, _pythia8.PDF_xubar_set)
//    __swig_setmethods__["xdbar"] = _pythia8.PDF_xdbar_set
//    __swig_getmethods__["xdbar"] = _pythia8.PDF_xdbar_get
//    if _newclass:
//        xdbar = _swig_property(_pythia8.PDF_xdbar_get, _pythia8.PDF_xdbar_set)
//    __swig_setmethods__["xsbar"] = _pythia8.PDF_xsbar_set
//    __swig_getmethods__["xsbar"] = _pythia8.PDF_xsbar_get
//    if _newclass:
//        xsbar = _swig_property(_pythia8.PDF_xsbar_get, _pythia8.PDF_xsbar_set)
//    __swig_setmethods__["xc"] = _pythia8.PDF_xc_set
//    __swig_getmethods__["xc"] = _pythia8.PDF_xc_get
//    if _newclass:
//        xc = _swig_property(_pythia8.PDF_xc_get, _pythia8.PDF_xc_set)
//    __swig_setmethods__["xb"] = _pythia8.PDF_xb_set
//    __swig_getmethods__["xb"] = _pythia8.PDF_xb_get
//    if _newclass:
//        xb = _swig_property(_pythia8.PDF_xb_get, _pythia8.PDF_xb_set)
//    __swig_setmethods__["xg"] = _pythia8.PDF_xg_set
//    __swig_getmethods__["xg"] = _pythia8.PDF_xg_get
//    if _newclass:
//        xg = _swig_property(_pythia8.PDF_xg_get, _pythia8.PDF_xg_set)
//    __swig_setmethods__["xlepton"] = _pythia8.PDF_xlepton_set
//    __swig_getmethods__["xlepton"] = _pythia8.PDF_xlepton_get
//    if _newclass:
//        xlepton = _swig_property(_pythia8.PDF_xlepton_get, _pythia8.PDF_xlepton_set)
//    __swig_setmethods__["xgamma"] = _pythia8.PDF_xgamma_set
//    __swig_getmethods__["xgamma"] = _pythia8.PDF_xgamma_get
//    if _newclass:
//        xgamma = _swig_property(_pythia8.PDF_xgamma_get, _pythia8.PDF_xgamma_set)
//    __swig_setmethods__["xuVal"] = _pythia8.PDF_xuVal_set
//    __swig_getmethods__["xuVal"] = _pythia8.PDF_xuVal_get
//    if _newclass:
//        xuVal = _swig_property(_pythia8.PDF_xuVal_get, _pythia8.PDF_xuVal_set)
//    __swig_setmethods__["xuSea"] = _pythia8.PDF_xuSea_set
//    __swig_getmethods__["xuSea"] = _pythia8.PDF_xuSea_get
//    if _newclass:
//        xuSea = _swig_property(_pythia8.PDF_xuSea_get, _pythia8.PDF_xuSea_set)
//    __swig_setmethods__["xdVal"] = _pythia8.PDF_xdVal_set
//    __swig_getmethods__["xdVal"] = _pythia8.PDF_xdVal_get
//    if _newclass:
//        xdVal = _swig_property(_pythia8.PDF_xdVal_get, _pythia8.PDF_xdVal_set)
//    __swig_setmethods__["xdSea"] = _pythia8.PDF_xdSea_set
//    __swig_getmethods__["xdSea"] = _pythia8.PDF_xdSea_get
//    if _newclass:
//        xdSea = _swig_property(_pythia8.PDF_xdSea_get, _pythia8.PDF_xdSea_set)
//    __swig_setmethods__["isSet"] = _pythia8.PDF_isSet_set
//    __swig_getmethods__["isSet"] = _pythia8.PDF_isSet_get
//    if _newclass:
//        isSet = _swig_property(_pythia8.PDF_isSet_get, _pythia8.PDF_isSet_set)
//    __swig_setmethods__["isInit"] = _pythia8.PDF_isInit_set
//    __swig_getmethods__["isInit"] = _pythia8.PDF_isInit_get
//    if _newclass:
//        isInit = _swig_property(_pythia8.PDF_isInit_get, _pythia8.PDF_isInit_set)
//    __swig_setmethods__["xsVal"] = _pythia8.PDF_xsVal_set
//    __swig_getmethods__["xsVal"] = _pythia8.PDF_xsVal_get
//    if _newclass:
//        xsVal = _swig_property(_pythia8.PDF_xsVal_get, _pythia8.PDF_xsVal_set)
//    __swig_setmethods__["xcVal"] = _pythia8.PDF_xcVal_set
//    __swig_getmethods__["xcVal"] = _pythia8.PDF_xcVal_get
//    if _newclass:
//        xcVal = _swig_property(_pythia8.PDF_xcVal_get, _pythia8.PDF_xcVal_set)
//    __swig_setmethods__["xbVal"] = _pythia8.PDF_xbVal_set
//    __swig_getmethods__["xbVal"] = _pythia8.PDF_xbVal_get
//    if _newclass:
//        xbVal = _swig_property(_pythia8.PDF_xbVal_get, _pythia8.PDF_xbVal_set)
//    __swig_setmethods__["xsSea"] = _pythia8.PDF_xsSea_set
//    __swig_getmethods__["xsSea"] = _pythia8.PDF_xsSea_get
//    if _newclass:
//        xsSea = _swig_property(_pythia8.PDF_xsSea_get, _pythia8.PDF_xsSea_set)
//    __swig_setmethods__["xcSea"] = _pythia8.PDF_xcSea_set
//    __swig_getmethods__["xcSea"] = _pythia8.PDF_xcSea_get
//    if _newclass:
//        xcSea = _swig_property(_pythia8.PDF_xcSea_get, _pythia8.PDF_xcSea_set)
//    __swig_setmethods__["xbSea"] = _pythia8.PDF_xbSea_set
//    __swig_getmethods__["xbSea"] = _pythia8.PDF_xbSea_get
//    if _newclass:
//        xbSea = _swig_property(_pythia8.PDF_xbSea_get, _pythia8.PDF_xbSea_set)
//    __swig_setmethods__["hasGammaInLepton"] = _pythia8.PDF_hasGammaInLepton_set
//    __swig_getmethods__["hasGammaInLepton"] = _pythia8.PDF_hasGammaInLepton_get
//    if _newclass:
//        hasGammaInLepton = _swig_property(_pythia8.PDF_hasGammaInLepton_get, _pythia8.PDF_hasGammaInLepton_set)
//
//    def setValenceContent(self):
//        """
//"""
//        return _pythia8.PDF_setValenceContent(self)
//
//    def xfUpdate(self, id, x, Q2):
//        return _pythia8.PDF_xfUpdate(self, id, x, Q2)
//
//    def printErr(self, errMsg, infoPtr=None):
//        return _pythia8.PDF_printErr(self, errMsg, infoPtr)
//    def __disown__(self):
//        self.this.disown()
//        _pythia8.disown_PDF(self)
//        return weakref_proxy(self)
//PDF_swigregister = _pythia8.PDF_swigregister
//PDF_swigregister(PDF)
//
//class GRV94L(PDF):
//    """
//Gives the GRV 94L (leading order) parton distribution function set
//in parametrized form. Authors: M. Glueck, E. Reya and A. Vogt.
//"""
//    __swig_setmethods__ = {}
//    for _s in [PDF]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, GRV94L, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PDF]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, GRV94L, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idBeamIn=2212):
//        """
//Constructor.
//"""
//        this = _pythia8.new_GRV94L(idBeamIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_GRV94L
//    __del__ = lambda self: None
//GRV94L_swigregister = _pythia8.GRV94L_swigregister
//GRV94L_swigregister(GRV94L)
//
//class CTEQ5L(PDF):
//    """
//Gives the CTEQ 5L (leading order) parton distribution function set
//in parametrized form. Parametrization by J. Pumplin. Authors: CTEQ.
//"""
//    __swig_setmethods__ = {}
//    for _s in [PDF]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, CTEQ5L, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PDF]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, CTEQ5L, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idBeamIn=2212):
//        """
//Constructor.
//"""
//        this = _pythia8.new_CTEQ5L(idBeamIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_CTEQ5L
//    __del__ = lambda self: None
//CTEQ5L_swigregister = _pythia8.CTEQ5L_swigregister
//CTEQ5L_swigregister(CTEQ5L)
//
//class MSTWpdf(PDF):
//    """
//The MSTWpdf class.
//MRST LO*(*) and MSTW 2008 PDF's, specifically the LO one.
//Original C++ version by Jeppe Andersen.
//Modified by Graeme Watt <watt(at)hep.ucl.ac.uk>.
//Sets available:
//iFit = 1 : MRST LO*  (2007).
//iFit = 2 : MRST LO** (2008).
//iFit = 3 : MSTW 2008 LO, central member.
//iFit = 4 : MSTW 2008 NLO, central member. (Warning!)
//"""
//    __swig_setmethods__ = {}
//    for _s in [PDF]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, MSTWpdf, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PDF]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, MSTWpdf, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor with a stream.
//"""
//        this = _pythia8.new_MSTWpdf(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_MSTWpdf
//    __del__ = lambda self: None
//MSTWpdf_swigregister = _pythia8.MSTWpdf_swigregister
//MSTWpdf_swigregister(MSTWpdf)
//
//class CTEQ6pdf(PDF):
//    """
//The CTEQ6pdf class.
//Proton sets available:
//iFit = 1 : CTEQ6L
//iFit = 2 : CTEQ6L1
//iFit = 3 : CTEQ66.00 (NLO, central member)
//iFit = 4 : CT09MC1
//iFit = 5 : CT09MC2
//iFit = 6 : CT09MCS
//Pomeron sets available (uses same .pds file format as CTEQ6pdf) :
//iFit = 11: ACTWB14
//iFit = 12: ACTWD14
//iFit = 13: ACTWSG14
//iFit = 14: ACTWD19
//"""
//    __swig_setmethods__ = {}
//    for _s in [PDF]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, CTEQ6pdf, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PDF]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, CTEQ6pdf, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor with a stream.
//"""
//        this = _pythia8.new_CTEQ6pdf(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def setExtrapolate(self, doExtraPolIn):
//        """
//Allow extrapolation beyond boundaries. This is optional.
//"""
//        return _pythia8.CTEQ6pdf_setExtrapolate(self, doExtraPolIn)
//    __swig_destroy__ = _pythia8.delete_CTEQ6pdf
//    __del__ = lambda self: None
//CTEQ6pdf_swigregister = _pythia8.CTEQ6pdf_swigregister
//CTEQ6pdf_swigregister(CTEQ6pdf)
//
//class ProtonPoint(PDF):
//    """
//SA Unresolved proton: equivalent photon spectrum from
//V.M. Budnev, I.F. Ginzburg, G.V. Meledin and V.G. Serbo,
//Phys. Rept. 15 (1974/1975) 181.
//"""
//    __swig_setmethods__ = {}
//    for _s in [PDF]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ProtonPoint, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PDF]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ProtonPoint, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idBeamIn=2212, infoPtrIn=None):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ProtonPoint(idBeamIn, infoPtrIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ProtonPoint
//    __del__ = lambda self: None
//ProtonPoint_swigregister = _pythia8.ProtonPoint_swigregister
//ProtonPoint_swigregister(ProtonPoint)
//
//class GRVpiL(PDF):
//    """
//Gives the GRV 1992 pi+ (leading order) parton distribution function set
//in parametrized form. Authors: Glueck, Reya and Vogt.
//"""
//    __swig_setmethods__ = {}
//    for _s in [PDF]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, GRVpiL, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PDF]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, GRVpiL, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idBeamIn=211, rescaleIn=1.):
//        """
//Constructor.
//"""
//        this = _pythia8.new_GRVpiL(idBeamIn, rescaleIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def setVMDscale(self, rescaleIn=1.):
//        """
//Allow for new rescaling factor of the PDF for VMD beams.
//"""
//        return _pythia8.GRVpiL_setVMDscale(self, rescaleIn)
//    __swig_destroy__ = _pythia8.delete_GRVpiL
//    __del__ = lambda self: None
//GRVpiL_swigregister = _pythia8.GRVpiL_swigregister
//GRVpiL_swigregister(GRVpiL)
//
//class PomFix(PDF):
//    """
//Gives generic Q2-independent Pomeron PDF.
//"""
//    __swig_setmethods__ = {}
//    for _s in [PDF]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, PomFix, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PDF]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, PomFix, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idBeamIn=990, PomGluonAIn=0., PomGluonBIn=0., PomQuarkAIn=0., PomQuarkBIn=0., PomQuarkFracIn=0., PomStrangeSuppIn=0.):
//        """
//Constructor.
//"""
//        this = _pythia8.new_PomFix(idBeamIn, PomGluonAIn, PomGluonBIn, PomQuarkAIn, PomQuarkBIn, PomQuarkFracIn, PomStrangeSuppIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_PomFix
//    __del__ = lambda self: None
//PomFix_swigregister = _pythia8.PomFix_swigregister
//PomFix_swigregister(PomFix)
//
//class PomH1FitAB(PDF):
//    """
//The H1 2006 Fit A and Fit B Pomeron parametrization.
//H1 Collaboration, A. Aktas et al., "Measurement and QCD Analysis of
//the Diffractive Deep-Inelastic Scattering Cross Section at HERA",
//DESY-06-049, Eur. Phys. J. C48 (2006) 715. e-Print: hep-ex/0606004.
//"""
//    __swig_setmethods__ = {}
//    for _s in [PDF]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, PomH1FitAB, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PDF]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, PomH1FitAB, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor with a stream.
//"""
//        this = _pythia8.new_PomH1FitAB(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def setExtrapolate(self, doExtraPolIn):
//        """
//Allow extrapolation beyond boundaries. This is optional.
//"""
//        return _pythia8.PomH1FitAB_setExtrapolate(self, doExtraPolIn)
//    __swig_destroy__ = _pythia8.delete_PomH1FitAB
//    __del__ = lambda self: None
//PomH1FitAB_swigregister = _pythia8.PomH1FitAB_swigregister
//PomH1FitAB_swigregister(PomH1FitAB)
//
//class PomH1Jets(PDF):
//    """
//The H1 2007 Jets Pomeron parametrization..
//H1 Collaboration, A. Aktas et al., "Dijet Cross Sections and Parton
//Densities in Diffractive DIS at HERA", DESY-07-115, Aug 2007. 33pp.
//Published in JHEP 0710:042,2007. e-Print: arXiv:0708.3217 [hep-ex]
//"""
//    __swig_setmethods__ = {}
//    for _s in [PDF]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, PomH1Jets, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PDF]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, PomH1Jets, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor with a stream.
//"""
//        this = _pythia8.new_PomH1Jets(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def setExtrapolate(self, doExtraPolIn):
//        """
//Allow extrapolation beyond boundaries. This is optional.
//"""
//        return _pythia8.PomH1Jets_setExtrapolate(self, doExtraPolIn)
//    __swig_destroy__ = _pythia8.delete_PomH1Jets
//    __del__ = lambda self: None
//PomH1Jets_swigregister = _pythia8.PomH1Jets_swigregister
//PomH1Jets_swigregister(PomH1Jets)
//
//class PomHISASD(PDF):
//    """
//"""
//    __swig_setmethods__ = {}
//    for _s in [PDF]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, PomHISASD, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PDF]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, PomHISASD, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idBeamIn, ppdf, settings, infoPtrIn=None):
//        """
//Basic constructor
//"""
//        this = _pythia8.new_PomHISASD(idBeamIn, ppdf, settings, infoPtrIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_PomHISASD
//    __del__ = lambda self: None
//
//    def xPom(self, xpom=-1.0):
//        """
//(re-)Set the x_pomeron value.
//"""
//        return _pythia8.PomHISASD_xPom(self, xpom)
//PomHISASD_swigregister = _pythia8.PomHISASD_swigregister
//PomHISASD_swigregister(PomHISASD)
//
//class Lepton(PDF):
//    """
//Gives electron (or muon, or tau) parton distribution.
//"""
//    __swig_setmethods__ = {}
//    for _s in [PDF]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Lepton, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PDF]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Lepton, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor with further info.
//"""
//        this = _pythia8.new_Lepton(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sampleQ2gamma(self, Q2min):
//        """
//Sample the Q2 value.
//"""
//        return _pythia8.Lepton_sampleQ2gamma(self, Q2min)
//    __swig_destroy__ = _pythia8.delete_Lepton
//    __del__ = lambda self: None
//Lepton_swigregister = _pythia8.Lepton_swigregister
//Lepton_swigregister(Lepton)
//
//class LeptonPoint(PDF):
//    """
//Gives electron (or other lepton) parton distribution when unresolved.
//"""
//    __swig_setmethods__ = {}
//    for _s in [PDF]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, LeptonPoint, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PDF]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, LeptonPoint, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idBeamIn=11):
//        """
//Constructor.
//"""
//        this = _pythia8.new_LeptonPoint(idBeamIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_LeptonPoint
//    __del__ = lambda self: None
//LeptonPoint_swigregister = _pythia8.LeptonPoint_swigregister
//LeptonPoint_swigregister(LeptonPoint)
//
//class NeutrinoPoint(PDF):
//    """
//Gives neutrino parton distribution when unresolved (only choice for now).
//Note factor of 2 since only lefthanded implies no spin averaging.
//"""
//    __swig_setmethods__ = {}
//    for _s in [PDF]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, NeutrinoPoint, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PDF]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, NeutrinoPoint, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idBeamIn=12):
//        """
//Constructor.
//"""
//        this = _pythia8.new_NeutrinoPoint(idBeamIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_NeutrinoPoint
//    __del__ = lambda self: None
//NeutrinoPoint_swigregister = _pythia8.NeutrinoPoint_swigregister
//NeutrinoPoint_swigregister(NeutrinoPoint)
//
//class NNPDF(PDF):
//    """
//The NNPDF class.
//Sets available:
//Leading order QCD+QED Proton PDF sets
//iFit = 1 : NNPDF2.3 QCD+QED LO, alphas(MZ) = 0.130
//iFit = 2 : NNPDF2.3 QCD+QED LO, alphas(MZ) = 0.119
//(Next-to-)Next-to-Leading order QCD+QED Proton PDF sets
//iFit = 3 : NNPDF2.3 QCD+QED NLO, alphas(MZ) = 0.119
//iFit = 4 : NNPDF2.3 QCD+QED NNLO, alphas(MZ) = 0.119
//Code provided by Juan Rojo and Stefano Carrazza.
//"""
//    __swig_setmethods__ = {}
//    for _s in [PDF]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, NNPDF, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PDF]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, NNPDF, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor with a stream.
//"""
//        this = _pythia8.new_NNPDF(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_NNPDF
//    __del__ = lambda self: None
//NNPDF_swigregister = _pythia8.NNPDF_swigregister
//NNPDF_swigregister(NNPDF)
//
//class LHAPDF(PDF):
//    """
//LHAPDF plugin interface class.
//"""
//    __swig_setmethods__ = {}
//    for _s in [PDF]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, LHAPDF, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PDF]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, LHAPDF, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idIn, pSet, infoPtrIn):
//        """
//Constructor and destructor.
//"""
//        this = _pythia8.new_LHAPDF(idIn, pSet, infoPtrIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_LHAPDF
//    __del__ = lambda self: None
//
//    def isSetup(self):
//        """
//Confirm that PDF has been set up.
//"""
//        return _pythia8.LHAPDF_isSetup(self)
//
//    def newValenceContent(self, idVal1In, idVal2In):
//        """
//Dynamic choice of meson valence flavours for pi0, K0S, K0L, Pomeron.
//"""
//        return _pythia8.LHAPDF_newValenceContent(self, idVal1In, idVal2In)
//
//    def setExtrapolate(self, extrapolate):
//        """
//Allow extrapolation beyond boundaries.
//"""
//        return _pythia8.LHAPDF_setExtrapolate(self, extrapolate)
//
//    def xf(self, id, x, Q2):
//        """
//Read out parton density
//"""
//        return _pythia8.LHAPDF_xf(self, id, x, Q2)
//
//    def xfVal(self, id, x, Q2):
//        """
//Read out valence and sea part of parton densities.
//"""
//        return _pythia8.LHAPDF_xfVal(self, id, x, Q2)
//
//    def xfSea(self, id, x, Q2):
//        """
//"""
//        return _pythia8.LHAPDF_xfSea(self, id, x, Q2)
//
//    def insideBounds(self, x, Q2):
//        """
//Check whether x and Q2 values fall inside the fit bounds (LHAPDF6 only).
//"""
//        return _pythia8.LHAPDF_insideBounds(self, x, Q2)
//
//    def alphaS(self, Q2):
//        """
//Access the running alpha_s of a PDF set (LHAPDF6 only).
//"""
//        return _pythia8.LHAPDF_alphaS(self, Q2)
//
//    def mQuarkPDF(self, idIn):
//        """
//Return quark masses used in the PDF fit (LHAPDF6 only).
//"""
//        return _pythia8.LHAPDF_mQuarkPDF(self, idIn)
//
//    def nMembers(self):
//        """
//Return quark masses used in the PDF fit (LHAPDF6 only).
//"""
//        return _pythia8.LHAPDF_nMembers(self)
//
//    def calcPDFEnvelope(self, *args):
//        """
//"""
//        return _pythia8.LHAPDF_calcPDFEnvelope(self, *args)
//
//    def getPDFEnvelope(self):
//        """
//"""
//        return _pythia8.LHAPDF_getPDFEnvelope(self)
//LHAPDF_swigregister = _pythia8.LHAPDF_swigregister
//LHAPDF_swigregister(LHAPDF)
//
//class CJKL(PDF):
//    """
//Gives the CJKL leading order parton distribution function set
//in parametrized form for the real photons. Authors: F.Cornet, P.Jankowski,
//M.Krawczyk and A.Lorca, Phys. Rev. D68: 014010, 2003.
//"""
//    __swig_setmethods__ = {}
//    for _s in [PDF]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, CJKL, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PDF]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, CJKL, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idBeamIn=22, rndmPtrIn=None):
//        """
//Constructor. Needs the randon number generator to sample valence content.
//"""
//        this = _pythia8.new_CJKL(idBeamIn, rndmPtrIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def gammaPDFxDependence(self, id, arg3):
//        """
//Functions to approximate pdfs for ISR.
//"""
//        return _pythia8.CJKL_gammaPDFxDependence(self, id, arg3)
//
//    def gammaPDFRefScale(self, arg2):
//        """
//"""
//        return _pythia8.CJKL_gammaPDFRefScale(self, arg2)
//
//    def sampleGammaValFlavor(self, Q2):
//        """
//Set the valence content for photons.
//"""
//        return _pythia8.CJKL_sampleGammaValFlavor(self, Q2)
//
//    def xfIntegratedTotal(self, Q2):
//        """
//The total x-integrated PDFs. Relevant for MPIs with photon beams.
//"""
//        return _pythia8.CJKL_xfIntegratedTotal(self, Q2)
//    __swig_destroy__ = _pythia8.delete_CJKL
//    __del__ = lambda self: None
//CJKL_swigregister = _pythia8.CJKL_swigregister
//CJKL_swigregister(CJKL)
//
//class LHAGrid1(PDF):
//    """
//The LHAGrid1 can be used to read files in the LHAPDF6 lhagrid1 format,
//assuming that the same x grid is used for all Q subgrids.
//Results are not identical with LHAPDF6, owing to different interpolation.
//"""
//    __swig_setmethods__ = {}
//    for _s in [PDF]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, LHAGrid1, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PDF]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, LHAGrid1, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor with a stream.
//"""
//        this = _pythia8.new_LHAGrid1(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_LHAGrid1
//    __del__ = lambda self: None
//
//    def setExtrapolate(self, doExtraPolIn):
//        """
//Allow extrapolation beyond boundaries. This is optional.
//"""
//        return _pythia8.LHAGrid1_setExtrapolate(self, doExtraPolIn)
//LHAGrid1_swigregister = _pythia8.LHAGrid1_swigregister
//LHAGrid1_swigregister(LHAGrid1)
//
//class Lepton2gamma(PDF):
//    """
//Convolution with photon flux from leptons and photon PDFs.
//Photon flux from equivalent photon approximation (EPA).
//Contains a pointer to a photon PDF set and samples the
//convolution integral event-by-event basis.
//Includes also a overestimate for the PDF set in order to set up
//the phase-space sampling correctly.
//"""
//    __swig_setmethods__ = {}
//    for _s in [PDF]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Lepton2gamma, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PDF]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Lepton2gamma, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idBeamIn, m2leptonIn, Q2maxGamma, gammaPDFPtrIn, infoPtrIn, rndmPtrIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Lepton2gamma(idBeamIn, m2leptonIn, Q2maxGamma, gammaPDFPtrIn, infoPtrIn, rndmPtrIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def xfUpdate(self, id, x, Q2):
//        """
//Overload the member function definitions where relevant.
//"""
//        return _pythia8.Lepton2gamma_xfUpdate(self, id, x, Q2)
//
//    def xGamma(self):
//        """
//"""
//        return _pythia8.Lepton2gamma_xGamma(self)
//
//    def xfMax(self, id, x, Q2):
//        """
//"""
//        return _pythia8.Lepton2gamma_xfMax(self, id, x, Q2)
//
//    def xfSame(self, id, x, Q2):
//        """
//"""
//        return _pythia8.Lepton2gamma_xfSame(self, id, x, Q2)
//
//    def sampleQ2gamma(self, Q2min):
//        """
//Sample the Q2 value.
//"""
//        return _pythia8.Lepton2gamma_sampleQ2gamma(self, Q2min)
//    __swig_destroy__ = _pythia8.delete_Lepton2gamma
//    __del__ = lambda self: None
//Lepton2gamma_swigregister = _pythia8.Lepton2gamma_swigregister
//Lepton2gamma_swigregister(Lepton2gamma)
//
//class GammaPoint(PDF):
//    """
//Gives electron (or other lepton) parton distribution when unresolved.
//"""
//    __swig_setmethods__ = {}
//    for _s in [PDF]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, GammaPoint, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PDF]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, GammaPoint, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idBeamIn=22):
//        """
//Constructor.
//"""
//        this = _pythia8.new_GammaPoint(idBeamIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_GammaPoint
//    __del__ = lambda self: None
//GammaPoint_swigregister = _pythia8.GammaPoint_swigregister
//GammaPoint_swigregister(GammaPoint)
//
//class EPAexternal(PDF):
//    """
//Equivalent photon approximation for sampling with external photon flux.
//"""
//    __swig_setmethods__ = {}
//    for _s in [PDF]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, EPAexternal, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PDF]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, EPAexternal, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idBeamIn, m2In, gammaFluxPtrIn, gammaPDFPtrIn, settingsPtrIn, infoPtrIn, rndmPtrIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_EPAexternal(idBeamIn, m2In, gammaFluxPtrIn, gammaPDFPtrIn, settingsPtrIn, infoPtrIn, rndmPtrIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def xfUpdate(self, arg2, x, Q2):
//        """
//Update PDFs.
//"""
//        return _pythia8.EPAexternal_xfUpdate(self, arg2, x, Q2)
//
//    def xfFlux(self, id, x, Q2):
//        """
//External flux and photon PDFs, and approximated flux for sampling.
//"""
//        return _pythia8.EPAexternal_xfFlux(self, id, x, Q2)
//
//    def xfGamma(self, id, x, Q2):
//        """
//"""
//        return _pythia8.EPAexternal_xfGamma(self, id, x, Q2)
//
//    def xfApprox(self, id, x, Q2):
//        """
//"""
//        return _pythia8.EPAexternal_xfApprox(self, id, x, Q2)
//
//    def getQ2min(self):
//        """
//Kinematics.
//"""
//        return _pythia8.EPAexternal_getQ2min(self)
//
//    def getXmin(self):
//        """
//"""
//        return _pythia8.EPAexternal_getXmin(self)
//
//    def getXhadr(self):
//        """
//"""
//        return _pythia8.EPAexternal_getXhadr(self)
//
//    def getGammaFluxNorm(self):
//        """
//"""
//        return _pythia8.EPAexternal_getGammaFluxNorm(self)
//
//    def sampleXgamma(self, xMinIn):
//        """
//Sampling of the x and Q2 according to 1/x and 1/Q2.
//"""
//        return _pythia8.EPAexternal_sampleXgamma(self, xMinIn)
//
//    def sampleQ2gamma(self, arg2):
//        """
//"""
//        return _pythia8.EPAexternal_sampleQ2gamma(self, arg2)
//    __swig_destroy__ = _pythia8.delete_EPAexternal
//    __del__ = lambda self: None
//EPAexternal_swigregister = _pythia8.EPAexternal_swigregister
//EPAexternal_swigregister(EPAexternal)
//
//class nPDF(PDF):
//    """
//A derived class for nuclear PDFs. Needs a pointer for (free) proton PDFs.
//"""
//    __swig_setmethods__ = {}
//    for _s in [PDF]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, nPDF, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PDF]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, nPDF, name)
//
//    def __init__(self, *args, **kwargs):
//        """
//Constructor.
//"""
//        raise AttributeError("No constructor defined - class is abstract")
//    __repr__ = _swig_repr
//
//    def xfUpdate(self, id, x, Q2):
//        """
//Update parton densities.
//"""
//        return _pythia8.nPDF_xfUpdate(self, id, x, Q2)
//
//    def rUpdate(self, arg2, arg3, arg4):
//        """
//Update nuclear modifications.
//"""
//        return _pythia8.nPDF_rUpdate(self, arg2, arg3, arg4)
//
//    def initNPDF(self, protonPDFPtrIn=None):
//        """
//Initialize the nPDF-related members.
//"""
//        return _pythia8.nPDF_initNPDF(self, protonPDFPtrIn)
//
//    def getA(self):
//        """
//Return the number of protons and nucleons.
//"""
//        return _pythia8.nPDF_getA(self)
//
//    def getZ(self):
//        """
//"""
//        return _pythia8.nPDF_getZ(self)
//
//    def setMode(self, zaIn):
//        """
//Set (and reset) the ratio of protons to nucleons to study nuclear
//modifications of protons (= 1.0) and neutrons (= 0.0). By default Z/A.
//"""
//        return _pythia8.nPDF_setMode(self, zaIn)
//
//    def resetMode(self):
//        """
//"""
//        return _pythia8.nPDF_resetMode(self)
//    __swig_destroy__ = _pythia8.delete_nPDF
//    __del__ = lambda self: None
//nPDF_swigregister = _pythia8.nPDF_swigregister
//nPDF_swigregister(nPDF)
//
//class Isospin(nPDF):
//    """
//Isospin modification with nuclear beam, i.e. no other modifications
//but correct number of protons and neutrons.
//"""
//    __swig_setmethods__ = {}
//    for _s in [nPDF]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Isospin, name, value)
//    __swig_getmethods__ = {}
//    for _s in [nPDF]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Isospin, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idBeamIn=2212, protonPDFPtrIn=None):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Isospin(idBeamIn, protonPDFPtrIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def rUpdate(self, arg2, arg3, arg4):
//        """
//Only the Isospin effect so no need to do anything here.
//"""
//        return _pythia8.Isospin_rUpdate(self, arg2, arg3, arg4)
//    __swig_destroy__ = _pythia8.delete_Isospin
//    __del__ = lambda self: None
//Isospin_swigregister = _pythia8.Isospin_swigregister
//Isospin_swigregister(Isospin)
//
//class EPS09(nPDF):
//    """
//Nuclear modifications from EPS09 fit.
//"""
//    __swig_setmethods__ = {}
//    for _s in [nPDF]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, EPS09, name, value)
//    __swig_getmethods__ = {}
//    for _s in [nPDF]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, EPS09, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor.
//"""
//        this = _pythia8.new_EPS09(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def rUpdate(self, id, x, Q2):
//        """
//Update parton densities.
//"""
//        return _pythia8.EPS09_rUpdate(self, id, x, Q2)
//
//    def setErrorSet(self, iSetIn):
//        """
//Use other than central set to study uncertainties.
//"""
//        return _pythia8.EPS09_setErrorSet(self, iSetIn)
//    __swig_destroy__ = _pythia8.delete_EPS09
//    __del__ = lambda self: None
//EPS09_swigregister = _pythia8.EPS09_swigregister
//EPS09_swigregister(EPS09)
//
//class EPPS16(nPDF):
//    """
//Nuclear modifications from EPPS16 fit.
//"""
//    __swig_setmethods__ = {}
//    for _s in [nPDF]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, EPPS16, name, value)
//    __swig_getmethods__ = {}
//    for _s in [nPDF]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, EPPS16, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor.
//"""
//        this = _pythia8.new_EPPS16(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def rUpdate(self, id, x, Q2):
//        """
//Update parton densities.
//"""
//        return _pythia8.EPPS16_rUpdate(self, id, x, Q2)
//
//    def setErrorSet(self, iSetIn):
//        """
//Use other than central set to study uncertainties.
//"""
//        return _pythia8.EPPS16_setErrorSet(self, iSetIn)
//    __swig_destroy__ = _pythia8.delete_EPPS16
//    __del__ = lambda self: None
//EPPS16_swigregister = _pythia8.EPPS16_swigregister
//EPPS16_swigregister(EPPS16)
//
//class ResonanceWidths(_object):
//    """
//The ResonanceWidths is the base class. Also used for generic resonaces.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceWidths, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceWidths, name)
//    __repr__ = _swig_repr
//    __swig_destroy__ = _pythia8.delete_ResonanceWidths
//    __del__ = lambda self: None
//
//    def initBasic(self, idResIn, isGenericIn=False):
//        """
//Set up standard properties.
//"""
//        return _pythia8.ResonanceWidths_initBasic(self, idResIn, isGenericIn)
//
//    def init(self, infoPtrIn, settingsPtrIn, particleDataPtrIn, couplingsPtrIn):
//        """
//Calculate and store partial and total widths at the nominal mass.
//"""
//        return _pythia8.ResonanceWidths_init(self, infoPtrIn, settingsPtrIn, particleDataPtrIn, couplingsPtrIn)
//
//    def id(self):
//        """
//Return identity of particle species.
//"""
//        return _pythia8.ResonanceWidths_id(self)
//
//    def width(self, idSgn, mHatIn, idInFlavIn=0, openOnly=False, setBR=False, idOutFlav1=0, idOutFlav2=0):
//        """
//"""
//        return _pythia8.ResonanceWidths_width(self, idSgn, mHatIn, idInFlavIn, openOnly, setBR, idOutFlav1, idOutFlav2)
//
//    def widthOpen(self, idSgn, mHatIn, idIn=0):
//        """
//Special case to calculate open final-state width.
//"""
//        return _pythia8.ResonanceWidths_widthOpen(self, idSgn, mHatIn, idIn)
//
//    def widthStore(self, idSgn, mHatIn, idIn=0):
//        """
//Special case to store open final-state widths for channel selection.
//"""
//        return _pythia8.ResonanceWidths_widthStore(self, idSgn, mHatIn, idIn)
//
//    def openFrac(self, idSgn):
//        """
//Return fraction of width open for particle and antiparticle.
//"""
//        return _pythia8.ResonanceWidths_openFrac(self, idSgn)
//
//    def widthRescaleFactor(self):
//        """
//Return forced rescaling factor of resonance width.
//"""
//        return _pythia8.ResonanceWidths_widthRescaleFactor(self)
//
//    def widthChan(self, mHatIn, idOutFlav1, idOutFlav2):
//        """
//Special case to calculate one final-state width.
//Currently only used for Higgs -> qqbar, g g or gamma gamma.
//"""
//        return _pythia8.ResonanceWidths_widthChan(self, mHatIn, idOutFlav1, idOutFlav2)
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        if self.__class__ == ResonanceWidths:
//            _self = None
//        else:
//            _self = self
//        this = _pythia8.new_ResonanceWidths(_self, )
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["idRes"] = _pythia8.ResonanceWidths_idRes_set
//    __swig_getmethods__["idRes"] = _pythia8.ResonanceWidths_idRes_get
//    if _newclass:
//        idRes = _swig_property(_pythia8.ResonanceWidths_idRes_get, _pythia8.ResonanceWidths_idRes_set)
//    __swig_setmethods__["hasAntiRes"] = _pythia8.ResonanceWidths_hasAntiRes_set
//    __swig_getmethods__["hasAntiRes"] = _pythia8.ResonanceWidths_hasAntiRes_get
//    if _newclass:
//        hasAntiRes = _swig_property(_pythia8.ResonanceWidths_hasAntiRes_get, _pythia8.ResonanceWidths_hasAntiRes_set)
//    __swig_setmethods__["doForceWidth"] = _pythia8.ResonanceWidths_doForceWidth_set
//    __swig_getmethods__["doForceWidth"] = _pythia8.ResonanceWidths_doForceWidth_get
//    if _newclass:
//        doForceWidth = _swig_property(_pythia8.ResonanceWidths_doForceWidth_get, _pythia8.ResonanceWidths_doForceWidth_set)
//    __swig_setmethods__["isGeneric"] = _pythia8.ResonanceWidths_isGeneric_set
//    __swig_getmethods__["isGeneric"] = _pythia8.ResonanceWidths_isGeneric_get
//    if _newclass:
//        isGeneric = _swig_property(_pythia8.ResonanceWidths_isGeneric_get, _pythia8.ResonanceWidths_isGeneric_set)
//    __swig_setmethods__["allowCalcWidth"] = _pythia8.ResonanceWidths_allowCalcWidth_set
//    __swig_getmethods__["allowCalcWidth"] = _pythia8.ResonanceWidths_allowCalcWidth_get
//    if _newclass:
//        allowCalcWidth = _swig_property(_pythia8.ResonanceWidths_allowCalcWidth_get, _pythia8.ResonanceWidths_allowCalcWidth_set)
//    __swig_setmethods__["minWidth"] = _pythia8.ResonanceWidths_minWidth_set
//    __swig_getmethods__["minWidth"] = _pythia8.ResonanceWidths_minWidth_get
//    if _newclass:
//        minWidth = _swig_property(_pythia8.ResonanceWidths_minWidth_get, _pythia8.ResonanceWidths_minWidth_set)
//    __swig_setmethods__["minThreshold"] = _pythia8.ResonanceWidths_minThreshold_set
//    __swig_getmethods__["minThreshold"] = _pythia8.ResonanceWidths_minThreshold_get
//    if _newclass:
//        minThreshold = _swig_property(_pythia8.ResonanceWidths_minThreshold_get, _pythia8.ResonanceWidths_minThreshold_set)
//    __swig_setmethods__["mRes"] = _pythia8.ResonanceWidths_mRes_set
//    __swig_getmethods__["mRes"] = _pythia8.ResonanceWidths_mRes_get
//    if _newclass:
//        mRes = _swig_property(_pythia8.ResonanceWidths_mRes_get, _pythia8.ResonanceWidths_mRes_set)
//    __swig_setmethods__["GammaRes"] = _pythia8.ResonanceWidths_GammaRes_set
//    __swig_getmethods__["GammaRes"] = _pythia8.ResonanceWidths_GammaRes_get
//    if _newclass:
//        GammaRes = _swig_property(_pythia8.ResonanceWidths_GammaRes_get, _pythia8.ResonanceWidths_GammaRes_set)
//    __swig_setmethods__["m2Res"] = _pythia8.ResonanceWidths_m2Res_set
//    __swig_getmethods__["m2Res"] = _pythia8.ResonanceWidths_m2Res_get
//    if _newclass:
//        m2Res = _swig_property(_pythia8.ResonanceWidths_m2Res_get, _pythia8.ResonanceWidths_m2Res_set)
//    __swig_setmethods__["GamMRat"] = _pythia8.ResonanceWidths_GamMRat_set
//    __swig_getmethods__["GamMRat"] = _pythia8.ResonanceWidths_GamMRat_get
//    if _newclass:
//        GamMRat = _swig_property(_pythia8.ResonanceWidths_GamMRat_get, _pythia8.ResonanceWidths_GamMRat_set)
//    __swig_setmethods__["openPos"] = _pythia8.ResonanceWidths_openPos_set
//    __swig_getmethods__["openPos"] = _pythia8.ResonanceWidths_openPos_get
//    if _newclass:
//        openPos = _swig_property(_pythia8.ResonanceWidths_openPos_get, _pythia8.ResonanceWidths_openPos_set)
//    __swig_setmethods__["openNeg"] = _pythia8.ResonanceWidths_openNeg_set
//    __swig_getmethods__["openNeg"] = _pythia8.ResonanceWidths_openNeg_get
//    if _newclass:
//        openNeg = _swig_property(_pythia8.ResonanceWidths_openNeg_get, _pythia8.ResonanceWidths_openNeg_set)
//    __swig_setmethods__["forceFactor"] = _pythia8.ResonanceWidths_forceFactor_set
//    __swig_getmethods__["forceFactor"] = _pythia8.ResonanceWidths_forceFactor_get
//    if _newclass:
//        forceFactor = _swig_property(_pythia8.ResonanceWidths_forceFactor_get, _pythia8.ResonanceWidths_forceFactor_set)
//    __swig_setmethods__["iChannel"] = _pythia8.ResonanceWidths_iChannel_set
//    __swig_getmethods__["iChannel"] = _pythia8.ResonanceWidths_iChannel_get
//    if _newclass:
//        iChannel = _swig_property(_pythia8.ResonanceWidths_iChannel_get, _pythia8.ResonanceWidths_iChannel_set)
//    __swig_setmethods__["onMode"] = _pythia8.ResonanceWidths_onMode_set
//    __swig_getmethods__["onMode"] = _pythia8.ResonanceWidths_onMode_get
//    if _newclass:
//        onMode = _swig_property(_pythia8.ResonanceWidths_onMode_get, _pythia8.ResonanceWidths_onMode_set)
//    __swig_setmethods__["meMode"] = _pythia8.ResonanceWidths_meMode_set
//    __swig_getmethods__["meMode"] = _pythia8.ResonanceWidths_meMode_get
//    if _newclass:
//        meMode = _swig_property(_pythia8.ResonanceWidths_meMode_get, _pythia8.ResonanceWidths_meMode_set)
//    __swig_setmethods__["mult"] = _pythia8.ResonanceWidths_mult_set
//    __swig_getmethods__["mult"] = _pythia8.ResonanceWidths_mult_get
//    if _newclass:
//        mult = _swig_property(_pythia8.ResonanceWidths_mult_get, _pythia8.ResonanceWidths_mult_set)
//    __swig_setmethods__["id1"] = _pythia8.ResonanceWidths_id1_set
//    __swig_getmethods__["id1"] = _pythia8.ResonanceWidths_id1_get
//    if _newclass:
//        id1 = _swig_property(_pythia8.ResonanceWidths_id1_get, _pythia8.ResonanceWidths_id1_set)
//    __swig_setmethods__["id2"] = _pythia8.ResonanceWidths_id2_set
//    __swig_getmethods__["id2"] = _pythia8.ResonanceWidths_id2_get
//    if _newclass:
//        id2 = _swig_property(_pythia8.ResonanceWidths_id2_get, _pythia8.ResonanceWidths_id2_set)
//    __swig_setmethods__["id3"] = _pythia8.ResonanceWidths_id3_set
//    __swig_getmethods__["id3"] = _pythia8.ResonanceWidths_id3_get
//    if _newclass:
//        id3 = _swig_property(_pythia8.ResonanceWidths_id3_get, _pythia8.ResonanceWidths_id3_set)
//    __swig_setmethods__["id1Abs"] = _pythia8.ResonanceWidths_id1Abs_set
//    __swig_getmethods__["id1Abs"] = _pythia8.ResonanceWidths_id1Abs_get
//    if _newclass:
//        id1Abs = _swig_property(_pythia8.ResonanceWidths_id1Abs_get, _pythia8.ResonanceWidths_id1Abs_set)
//    __swig_setmethods__["id2Abs"] = _pythia8.ResonanceWidths_id2Abs_set
//    __swig_getmethods__["id2Abs"] = _pythia8.ResonanceWidths_id2Abs_get
//    if _newclass:
//        id2Abs = _swig_property(_pythia8.ResonanceWidths_id2Abs_get, _pythia8.ResonanceWidths_id2Abs_set)
//    __swig_setmethods__["id3Abs"] = _pythia8.ResonanceWidths_id3Abs_set
//    __swig_getmethods__["id3Abs"] = _pythia8.ResonanceWidths_id3Abs_get
//    if _newclass:
//        id3Abs = _swig_property(_pythia8.ResonanceWidths_id3Abs_get, _pythia8.ResonanceWidths_id3Abs_set)
//    __swig_setmethods__["idInFlav"] = _pythia8.ResonanceWidths_idInFlav_set
//    __swig_getmethods__["idInFlav"] = _pythia8.ResonanceWidths_idInFlav_get
//    if _newclass:
//        idInFlav = _swig_property(_pythia8.ResonanceWidths_idInFlav_get, _pythia8.ResonanceWidths_idInFlav_set)
//    __swig_setmethods__["widNow"] = _pythia8.ResonanceWidths_widNow_set
//    __swig_getmethods__["widNow"] = _pythia8.ResonanceWidths_widNow_get
//    if _newclass:
//        widNow = _swig_property(_pythia8.ResonanceWidths_widNow_get, _pythia8.ResonanceWidths_widNow_set)
//    __swig_setmethods__["mHat"] = _pythia8.ResonanceWidths_mHat_set
//    __swig_getmethods__["mHat"] = _pythia8.ResonanceWidths_mHat_get
//    if _newclass:
//        mHat = _swig_property(_pythia8.ResonanceWidths_mHat_get, _pythia8.ResonanceWidths_mHat_set)
//    __swig_setmethods__["mf1"] = _pythia8.ResonanceWidths_mf1_set
//    __swig_getmethods__["mf1"] = _pythia8.ResonanceWidths_mf1_get
//    if _newclass:
//        mf1 = _swig_property(_pythia8.ResonanceWidths_mf1_get, _pythia8.ResonanceWidths_mf1_set)
//    __swig_setmethods__["mf2"] = _pythia8.ResonanceWidths_mf2_set
//    __swig_getmethods__["mf2"] = _pythia8.ResonanceWidths_mf2_get
//    if _newclass:
//        mf2 = _swig_property(_pythia8.ResonanceWidths_mf2_get, _pythia8.ResonanceWidths_mf2_set)
//    __swig_setmethods__["mf3"] = _pythia8.ResonanceWidths_mf3_set
//    __swig_getmethods__["mf3"] = _pythia8.ResonanceWidths_mf3_get
//    if _newclass:
//        mf3 = _swig_property(_pythia8.ResonanceWidths_mf3_get, _pythia8.ResonanceWidths_mf3_set)
//    __swig_setmethods__["mr1"] = _pythia8.ResonanceWidths_mr1_set
//    __swig_getmethods__["mr1"] = _pythia8.ResonanceWidths_mr1_get
//    if _newclass:
//        mr1 = _swig_property(_pythia8.ResonanceWidths_mr1_get, _pythia8.ResonanceWidths_mr1_set)
//    __swig_setmethods__["mr2"] = _pythia8.ResonanceWidths_mr2_set
//    __swig_getmethods__["mr2"] = _pythia8.ResonanceWidths_mr2_get
//    if _newclass:
//        mr2 = _swig_property(_pythia8.ResonanceWidths_mr2_get, _pythia8.ResonanceWidths_mr2_set)
//    __swig_setmethods__["mr3"] = _pythia8.ResonanceWidths_mr3_set
//    __swig_getmethods__["mr3"] = _pythia8.ResonanceWidths_mr3_get
//    if _newclass:
//        mr3 = _swig_property(_pythia8.ResonanceWidths_mr3_get, _pythia8.ResonanceWidths_mr3_set)
//    __swig_setmethods__["ps"] = _pythia8.ResonanceWidths_ps_set
//    __swig_getmethods__["ps"] = _pythia8.ResonanceWidths_ps_get
//    if _newclass:
//        ps = _swig_property(_pythia8.ResonanceWidths_ps_get, _pythia8.ResonanceWidths_ps_set)
//    __swig_setmethods__["kinFac"] = _pythia8.ResonanceWidths_kinFac_set
//    __swig_getmethods__["kinFac"] = _pythia8.ResonanceWidths_kinFac_get
//    if _newclass:
//        kinFac = _swig_property(_pythia8.ResonanceWidths_kinFac_get, _pythia8.ResonanceWidths_kinFac_set)
//    __swig_setmethods__["alpEM"] = _pythia8.ResonanceWidths_alpEM_set
//    __swig_getmethods__["alpEM"] = _pythia8.ResonanceWidths_alpEM_get
//    if _newclass:
//        alpEM = _swig_property(_pythia8.ResonanceWidths_alpEM_get, _pythia8.ResonanceWidths_alpEM_set)
//    __swig_setmethods__["alpS"] = _pythia8.ResonanceWidths_alpS_set
//    __swig_getmethods__["alpS"] = _pythia8.ResonanceWidths_alpS_get
//    if _newclass:
//        alpS = _swig_property(_pythia8.ResonanceWidths_alpS_get, _pythia8.ResonanceWidths_alpS_set)
//    __swig_setmethods__["colQ"] = _pythia8.ResonanceWidths_colQ_set
//    __swig_getmethods__["colQ"] = _pythia8.ResonanceWidths_colQ_get
//    if _newclass:
//        colQ = _swig_property(_pythia8.ResonanceWidths_colQ_get, _pythia8.ResonanceWidths_colQ_set)
//    __swig_setmethods__["preFac"] = _pythia8.ResonanceWidths_preFac_set
//    __swig_getmethods__["preFac"] = _pythia8.ResonanceWidths_preFac_get
//    if _newclass:
//        preFac = _swig_property(_pythia8.ResonanceWidths_preFac_get, _pythia8.ResonanceWidths_preFac_set)
//    __swig_setmethods__["particlePtr"] = _pythia8.ResonanceWidths_particlePtr_set
//    __swig_getmethods__["particlePtr"] = _pythia8.ResonanceWidths_particlePtr_get
//    if _newclass:
//        particlePtr = _swig_property(_pythia8.ResonanceWidths_particlePtr_get, _pythia8.ResonanceWidths_particlePtr_set)
//    __swig_setmethods__["infoPtr"] = _pythia8.ResonanceWidths_infoPtr_set
//    __swig_getmethods__["infoPtr"] = _pythia8.ResonanceWidths_infoPtr_get
//    if _newclass:
//        infoPtr = _swig_property(_pythia8.ResonanceWidths_infoPtr_get, _pythia8.ResonanceWidths_infoPtr_set)
//    __swig_setmethods__["settingsPtr"] = _pythia8.ResonanceWidths_settingsPtr_set
//    __swig_getmethods__["settingsPtr"] = _pythia8.ResonanceWidths_settingsPtr_get
//    if _newclass:
//        settingsPtr = _swig_property(_pythia8.ResonanceWidths_settingsPtr_get, _pythia8.ResonanceWidths_settingsPtr_set)
//    __swig_setmethods__["particleDataPtr"] = _pythia8.ResonanceWidths_particleDataPtr_set
//    __swig_getmethods__["particleDataPtr"] = _pythia8.ResonanceWidths_particleDataPtr_get
//    if _newclass:
//        particleDataPtr = _swig_property(_pythia8.ResonanceWidths_particleDataPtr_get, _pythia8.ResonanceWidths_particleDataPtr_set)
//    __swig_setmethods__["couplingsPtr"] = _pythia8.ResonanceWidths_couplingsPtr_set
//    __swig_getmethods__["couplingsPtr"] = _pythia8.ResonanceWidths_couplingsPtr_get
//    if _newclass:
//        couplingsPtr = _swig_property(_pythia8.ResonanceWidths_couplingsPtr_get, _pythia8.ResonanceWidths_couplingsPtr_set)
//
//    def initConstants(self):
//        """
//Constants: could only be changed in the code itself.
//Particle properties always present.
//Properties for currently studied decay channel(s).
//Pointer to properties of the particle species.
//Pointer to various information on the generation.
//Pointer to the settings database.
//Pointer to the particle data table.
//Pointers to Standard Model and SUSY couplings.
//Initialize constants.
//"""
//        return _pythia8.ResonanceWidths_initConstants(self)
//
//    def initBSM(self):
//        """
//Virtual methods to handle model-specific (non-SM) part of initialization
//for use by derived classes that implement additional models (eg SUSY).
//"""
//        return _pythia8.ResonanceWidths_initBSM(self)
//
//    def allowCalc(self):
//        """
//"""
//        return _pythia8.ResonanceWidths_allowCalc(self)
//
//    def calcPreFac(self, arg0=False):
//        """
//Calculate various common prefactors for the current mass.
//Optional argument calledFromInit only used for Z0.
//"""
//        return _pythia8.ResonanceWidths_calcPreFac(self, arg0)
//
//    def calcWidth(self, arg0=False):
//        """
//Calculate width for currently considered channel.
//Optional argument calledFromInit only used for Z0.
//"""
//        return _pythia8.ResonanceWidths_calcWidth(self, arg0)
//
//    def numInt1BW(self, mHatIn, m1, Gamma1, mMin1, m2, psMode=1):
//        """
//Simple routines for matrix-element integration over Breit-Wigners.
//"""
//        return _pythia8.ResonanceWidths_numInt1BW(self, mHatIn, m1, Gamma1, mMin1, m2, psMode)
//
//    def numInt2BW(self, mHatIn, m1, Gamma1, mMin1, m2, Gamma2, mMin2, psMode=1):
//        """
//"""
//        return _pythia8.ResonanceWidths_numInt2BW(self, mHatIn, m1, Gamma1, mMin1, m2, Gamma2, mMin2, psMode)
//    def __disown__(self):
//        self.this.disown()
//        _pythia8.disown_ResonanceWidths(self)
//        return weakref_proxy(self)
//ResonanceWidths_swigregister = _pythia8.ResonanceWidths_swigregister
//ResonanceWidths_swigregister(ResonanceWidths)
//ResonanceWidths.NPOINT = _pythia8.cvar.ResonanceWidths_NPOINT
//ResonanceWidths.MASSMIN = _pythia8.cvar.ResonanceWidths_MASSMIN
//ResonanceWidths.MASSMARGIN = _pythia8.cvar.ResonanceWidths_MASSMARGIN
//
//class ResonanceGeneric(ResonanceWidths):
//    """
//The ResonanceGeneric class handles a generic resonance.
//Only needs a constructor and allowCalc = false; for the rest uses
//defaults in base class.
//"""
//    __swig_setmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceGeneric, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceGeneric, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceGeneric(idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def allowCalc(self):
//        """
//By default, assume no dedicated code exists to compute width.
//"""
//        return _pythia8.ResonanceGeneric_allowCalc(self)
//    __swig_destroy__ = _pythia8.delete_ResonanceGeneric
//    __del__ = lambda self: None
//ResonanceGeneric_swigregister = _pythia8.ResonanceGeneric_swigregister
//ResonanceGeneric_swigregister(ResonanceGeneric)
//
//class ResonanceGmZ(ResonanceWidths):
//    """
//The ResonanceGmZ class handles the gamma*/Z0 resonance.
//"""
//    __swig_setmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceGmZ, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceGmZ, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceGmZ(idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ResonanceGmZ
//    __del__ = lambda self: None
//ResonanceGmZ_swigregister = _pythia8.ResonanceGmZ_swigregister
//ResonanceGmZ_swigregister(ResonanceGmZ)
//
//class ResonanceW(ResonanceWidths):
//    """
//The ResonanceW class handles the W+- resonance.
//"""
//    __swig_setmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceW, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceW, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceW(idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ResonanceW
//    __del__ = lambda self: None
//ResonanceW_swigregister = _pythia8.ResonanceW_swigregister
//ResonanceW_swigregister(ResonanceW)
//
//class ResonanceTop(ResonanceWidths):
//    """
//The ResonanceTop class handles the top/antitop resonance.
//"""
//    __swig_setmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceTop, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceTop, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceTop(idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ResonanceTop
//    __del__ = lambda self: None
//ResonanceTop_swigregister = _pythia8.ResonanceTop_swigregister
//ResonanceTop_swigregister(ResonanceTop)
//
//class ResonanceFour(ResonanceWidths):
//    """
//The ResonanceFour class handles fourth-generation resonances.
//"""
//    __swig_setmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceFour, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceFour, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceFour(idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ResonanceFour
//    __del__ = lambda self: None
//ResonanceFour_swigregister = _pythia8.ResonanceFour_swigregister
//ResonanceFour_swigregister(ResonanceFour)
//
//class ResonanceH(ResonanceWidths):
//    """
//The ResonanceH class handles the SM and BSM Higgs resonance.
//higgsType = 0 : SM H; = 1: h^0/H_1; = 2 : H^0/H_2; = 3 : A^0/A_3.
//"""
//    __swig_setmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceH, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceH, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, higgsTypeIn, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceH(higgsTypeIn, idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ResonanceH
//    __del__ = lambda self: None
//ResonanceH_swigregister = _pythia8.ResonanceH_swigregister
//ResonanceH_swigregister(ResonanceH)
//
//class ResonanceHchg(ResonanceWidths):
//    """
//The ResonanceHchg class handles the H+- resonance.
//"""
//    __swig_setmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceHchg, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceHchg, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceHchg(idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ResonanceHchg
//    __del__ = lambda self: None
//ResonanceHchg_swigregister = _pythia8.ResonanceHchg_swigregister
//ResonanceHchg_swigregister(ResonanceHchg)
//
//class ResonanceZprime(ResonanceWidths):
//    """
//The ResonanceZprime class handles the gamma*/Z0 /Z'^0 resonance.
//"""
//    __swig_setmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceZprime, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceZprime, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceZprime(idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ResonanceZprime
//    __del__ = lambda self: None
//ResonanceZprime_swigregister = _pythia8.ResonanceZprime_swigregister
//ResonanceZprime_swigregister(ResonanceZprime)
//
//class ResonanceWprime(ResonanceWidths):
//    """
//The ResonanceWprime class handles the W'+- resonance.
//"""
//    __swig_setmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceWprime, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceWprime, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceWprime(idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ResonanceWprime
//    __del__ = lambda self: None
//ResonanceWprime_swigregister = _pythia8.ResonanceWprime_swigregister
//ResonanceWprime_swigregister(ResonanceWprime)
//
//class ResonanceRhorizontal(ResonanceWidths):
//    """
//The ResonanceRhorizontal class handles the R^0 resonance.
//"""
//    __swig_setmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceRhorizontal, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceRhorizontal, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceRhorizontal(idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ResonanceRhorizontal
//    __del__ = lambda self: None
//ResonanceRhorizontal_swigregister = _pythia8.ResonanceRhorizontal_swigregister
//ResonanceRhorizontal_swigregister(ResonanceRhorizontal)
//
//class ResonanceExcited(ResonanceWidths):
//    """
//The ResonanceExcited class handles excited-fermion resonances.
//"""
//    __swig_setmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceExcited, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceExcited, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceExcited(idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ResonanceExcited
//    __del__ = lambda self: None
//ResonanceExcited_swigregister = _pythia8.ResonanceExcited_swigregister
//ResonanceExcited_swigregister(ResonanceExcited)
//
//class ResonanceGraviton(ResonanceWidths):
//    """
//The ResonanceGraviton class handles the excited Graviton resonance.
//"""
//    __swig_setmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceGraviton, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceGraviton, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceGraviton(idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ResonanceGraviton
//    __del__ = lambda self: None
//ResonanceGraviton_swigregister = _pythia8.ResonanceGraviton_swigregister
//ResonanceGraviton_swigregister(ResonanceGraviton)
//
//class ResonanceKKgluon(ResonanceWidths):
//    """
//The ResonanceKKgluon class handles the g^*/KK-gluon^* resonance.
//"""
//    __swig_setmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceKKgluon, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceKKgluon, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceKKgluon(idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ResonanceKKgluon
//    __del__ = lambda self: None
//ResonanceKKgluon_swigregister = _pythia8.ResonanceKKgluon_swigregister
//ResonanceKKgluon_swigregister(ResonanceKKgluon)
//
//class ResonanceLeptoquark(ResonanceWidths):
//    """
//The ResonanceLeptoquark class handles the LQ/LQbar resonance.
//"""
//    __swig_setmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceLeptoquark, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceLeptoquark, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceLeptoquark(idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ResonanceLeptoquark
//    __del__ = lambda self: None
//ResonanceLeptoquark_swigregister = _pythia8.ResonanceLeptoquark_swigregister
//ResonanceLeptoquark_swigregister(ResonanceLeptoquark)
//
//class ResonanceNuRight(ResonanceWidths):
//    """
//The ResonanceNuRight class handles righthanded Majorana neutrinos.
//"""
//    __swig_setmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceNuRight, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceNuRight, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceNuRight(idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ResonanceNuRight
//    __del__ = lambda self: None
//ResonanceNuRight_swigregister = _pythia8.ResonanceNuRight_swigregister
//ResonanceNuRight_swigregister(ResonanceNuRight)
//
//class ResonanceZRight(ResonanceWidths):
//    """
//The ResonanceZRight class handles the Z_R^0 resonance.
//"""
//    __swig_setmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceZRight, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceZRight, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceZRight(idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ResonanceZRight
//    __del__ = lambda self: None
//ResonanceZRight_swigregister = _pythia8.ResonanceZRight_swigregister
//ResonanceZRight_swigregister(ResonanceZRight)
//
//class ResonanceWRight(ResonanceWidths):
//    """
//The ResonanceWRight class handles the W_R+- resonance.
//"""
//    __swig_setmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceWRight, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceWRight, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceWRight(idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ResonanceWRight
//    __del__ = lambda self: None
//ResonanceWRight_swigregister = _pythia8.ResonanceWRight_swigregister
//ResonanceWRight_swigregister(ResonanceWRight)
//
//class ResonanceHchgchgLeft(ResonanceWidths):
//    """
//The ResonanceHchgchgLeft class handles the H++/H-- (left) resonance.
//"""
//    __swig_setmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceHchgchgLeft, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceHchgchgLeft, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceHchgchgLeft(idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ResonanceHchgchgLeft
//    __del__ = lambda self: None
//ResonanceHchgchgLeft_swigregister = _pythia8.ResonanceHchgchgLeft_swigregister
//ResonanceHchgchgLeft_swigregister(ResonanceHchgchgLeft)
//
//class ResonanceHchgchgRight(ResonanceWidths):
//    """
//The ResonanceHchgchgRight class handles the H++/H-- (right) resonance.
//"""
//    __swig_setmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceHchgchgRight, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceHchgchgRight, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceHchgchgRight(idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ResonanceHchgchgRight
//    __del__ = lambda self: None
//ResonanceHchgchgRight_swigregister = _pythia8.ResonanceHchgchgRight_swigregister
//ResonanceHchgchgRight_swigregister(ResonanceHchgchgRight)
//
//class SigmaTotAux(_object):
//    """
//The SigmaTotAux is base class for the different parametrizations
//made accessible via SigmaTotal. Many variables are public, since
//they can only be accessed via the SigmaTotal methods anyway.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SigmaTotAux, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, SigmaTotAux, name)
//    __repr__ = _swig_repr
//    __swig_destroy__ = _pythia8.delete_SigmaTotAux
//    __del__ = lambda self: None
//
//    def init(self, arg2, arg3, arg4, arg5):
//        """
//Store pointers and initialize data members.
//"""
//        return _pythia8.SigmaTotAux_init(self, arg2, arg3, arg4, arg5)
//
//    def calcTotEl(self, arg2, arg3, arg4, arg5, arg6):
//        """
//Calculate integrated total/elastic cross sections.
//Usage: calcTotEl( idAin, idBin, sIn, mAin, mBin).
//"""
//        return _pythia8.SigmaTotAux_calcTotEl(self, arg2, arg3, arg4, arg5, arg6)
//    __swig_setmethods__["isExpEl"] = _pythia8.SigmaTotAux_isExpEl_set
//    __swig_getmethods__["isExpEl"] = _pythia8.SigmaTotAux_isExpEl_get
//    if _newclass:
//        isExpEl = _swig_property(_pythia8.SigmaTotAux_isExpEl_get, _pythia8.SigmaTotAux_isExpEl_set)
//    __swig_setmethods__["hasCou"] = _pythia8.SigmaTotAux_hasCou_set
//    __swig_getmethods__["hasCou"] = _pythia8.SigmaTotAux_hasCou_get
//    if _newclass:
//        hasCou = _swig_property(_pythia8.SigmaTotAux_hasCou_get, _pythia8.SigmaTotAux_hasCou_set)
//    __swig_setmethods__["sigTot"] = _pythia8.SigmaTotAux_sigTot_set
//    __swig_getmethods__["sigTot"] = _pythia8.SigmaTotAux_sigTot_get
//    if _newclass:
//        sigTot = _swig_property(_pythia8.SigmaTotAux_sigTot_get, _pythia8.SigmaTotAux_sigTot_set)
//    __swig_setmethods__["rhoOwn"] = _pythia8.SigmaTotAux_rhoOwn_set
//    __swig_getmethods__["rhoOwn"] = _pythia8.SigmaTotAux_rhoOwn_get
//    if _newclass:
//        rhoOwn = _swig_property(_pythia8.SigmaTotAux_rhoOwn_get, _pythia8.SigmaTotAux_rhoOwn_set)
//    __swig_setmethods__["sigEl"] = _pythia8.SigmaTotAux_sigEl_set
//    __swig_getmethods__["sigEl"] = _pythia8.SigmaTotAux_sigEl_get
//    if _newclass:
//        sigEl = _swig_property(_pythia8.SigmaTotAux_sigEl_get, _pythia8.SigmaTotAux_sigEl_set)
//    __swig_setmethods__["bEl"] = _pythia8.SigmaTotAux_bEl_set
//    __swig_getmethods__["bEl"] = _pythia8.SigmaTotAux_bEl_get
//    if _newclass:
//        bEl = _swig_property(_pythia8.SigmaTotAux_bEl_get, _pythia8.SigmaTotAux_bEl_set)
//    __swig_setmethods__["sigTotCou"] = _pythia8.SigmaTotAux_sigTotCou_set
//    __swig_getmethods__["sigTotCou"] = _pythia8.SigmaTotAux_sigTotCou_get
//    if _newclass:
//        sigTotCou = _swig_property(_pythia8.SigmaTotAux_sigTotCou_get, _pythia8.SigmaTotAux_sigTotCou_set)
//    __swig_setmethods__["sigElCou"] = _pythia8.SigmaTotAux_sigElCou_set
//    __swig_getmethods__["sigElCou"] = _pythia8.SigmaTotAux_sigElCou_get
//    if _newclass:
//        sigElCou = _swig_property(_pythia8.SigmaTotAux_sigElCou_get, _pythia8.SigmaTotAux_sigElCou_set)
//
//    def dsigmaEl(self, arg2, arg3=False, arg4=True):
//        """
//Store total and elastic cross section properties.
//Differential elastic cross section, d(sigma_el) / dt.
//"""
//        return _pythia8.SigmaTotAux_dsigmaEl(self, arg2, arg3, arg4)
//
//    def calcDiff(self, arg2, arg3, arg4, arg5, arg6):
//        """
//Calculate integrated diffractive cross sections.
//Usage: calcDiff(  idAin, idBin, sIn, mAin, mBin).
//"""
//        return _pythia8.SigmaTotAux_calcDiff(self, arg2, arg3, arg4, arg5, arg6)
//    __swig_setmethods__["sigXB"] = _pythia8.SigmaTotAux_sigXB_set
//    __swig_getmethods__["sigXB"] = _pythia8.SigmaTotAux_sigXB_get
//    if _newclass:
//        sigXB = _swig_property(_pythia8.SigmaTotAux_sigXB_get, _pythia8.SigmaTotAux_sigXB_set)
//    __swig_setmethods__["sigAX"] = _pythia8.SigmaTotAux_sigAX_set
//    __swig_getmethods__["sigAX"] = _pythia8.SigmaTotAux_sigAX_get
//    if _newclass:
//        sigAX = _swig_property(_pythia8.SigmaTotAux_sigAX_get, _pythia8.SigmaTotAux_sigAX_set)
//    __swig_setmethods__["sigXX"] = _pythia8.SigmaTotAux_sigXX_set
//    __swig_getmethods__["sigXX"] = _pythia8.SigmaTotAux_sigXX_get
//    if _newclass:
//        sigXX = _swig_property(_pythia8.SigmaTotAux_sigXX_get, _pythia8.SigmaTotAux_sigXX_set)
//    __swig_setmethods__["sigAXB"] = _pythia8.SigmaTotAux_sigAXB_set
//    __swig_getmethods__["sigAXB"] = _pythia8.SigmaTotAux_sigAXB_get
//    if _newclass:
//        sigAXB = _swig_property(_pythia8.SigmaTotAux_sigAXB_get, _pythia8.SigmaTotAux_sigAXB_set)
//
//    def dsigmaSD(self, arg2, arg3, arg4=True, arg5=0):
//        """
//Store diffractive cross sections.
//Differential single diffractive cross section,
//xi * d(sigma_SD) / (dxi dt).
//"""
//        return _pythia8.SigmaTotAux_dsigmaSD(self, arg2, arg3, arg4, arg5)
//
//    def splitDiff(self):
//        """
//Possibility to separate xi and t choices for diffraction.
//"""
//        return _pythia8.SigmaTotAux_splitDiff(self)
//
//    def dsigmaDD(self, arg2, arg3, arg4, arg5=0):
//        """
//Differential double diffractive cross section,
//xi1 * xi2 * d(sigma_DD) / (dxi1 dxi2 dt).
//"""
//        return _pythia8.SigmaTotAux_dsigmaDD(self, arg2, arg3, arg4, arg5)
//
//    def dsigmaCD(self, arg2, arg3, arg4, arg5, arg6):
//        """
//Differential central diffractive cross section,
//xi1 * xi2 * d(sigma_CD) / (dxi1 dxi2 dt1 dt2).
//"""
//        return _pythia8.SigmaTotAux_dsigmaCD(self, arg2, arg3, arg4, arg5, arg6)
//
//    def mMinCD(self):
//        """
//Minimal central diffractive mass.
//"""
//        return _pythia8.SigmaTotAux_mMinCD(self)
//
//    def tRange(self, sIn, s1In, s2In, s3In, s4In):
//        """
//"""
//        return _pythia8.SigmaTotAux_tRange(self, sIn, s1In, s2In, s3In, s4In)
//
//    def tInRange(self, tIn, sIn, s1In, s2In, s3In, s4In):
//        """
//"""
//        return _pythia8.SigmaTotAux_tInRange(self, tIn, sIn, s1In, s2In, s3In, s4In)
//
//    def pFormFac(self, tIn):
//        """
//Commonly used proton form factor.
//"""
//        return _pythia8.SigmaTotAux_pFormFac(self, tIn)
//
//    def __init__(self):
//        this = _pythia8.new_SigmaTotAux()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//SigmaTotAux_swigregister = _pythia8.SigmaTotAux_swigregister
//SigmaTotAux_swigregister(SigmaTotAux)
//
//class SigmaTotal(_object):
//    """
//The SigmaTotal class contains parametrizations of total, elastic and
//diffractive cross sections, and of the respective slope parameter.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SigmaTotal, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, SigmaTotal, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_SigmaTotal()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_SigmaTotal
//    __del__ = lambda self: None
//
//    def init(self, infoPtrIn, settings, particleDataPtrIn, rndmPtrIn):
//        """
//Store pointers and initialize data members.
//"""
//        return _pythia8.SigmaTotal_init(self, infoPtrIn, settings, particleDataPtrIn, rndmPtrIn)
//
//    def calc(self, idA, idB, eCM):
//        """
//Calculate, or recalculate for new beams or new energy.
//"""
//        return _pythia8.SigmaTotal_calc(self, idA, idB, eCM)
//
//    def hasSigmaTot(self):
//        """
//Confirm that initialization worked.
//"""
//        return _pythia8.SigmaTotal_hasSigmaTot(self)
//
//    def sigmaTot(self):
//        """
//Total and integrated elastic cross sections.
//"""
//        return _pythia8.SigmaTotal_sigmaTot(self)
//
//    def rho(self):
//        """
//"""
//        return _pythia8.SigmaTotal_rho(self)
//
//    def sigmaEl(self):
//        """
//"""
//        return _pythia8.SigmaTotal_sigmaEl(self)
//
//    def bElIsExp(self):
//        """
//"""
//        return _pythia8.SigmaTotal_bElIsExp(self)
//
//    def bSlopeEl(self):
//        """
//"""
//        return _pythia8.SigmaTotal_bSlopeEl(self)
//
//    def hasCoulomb(self):
//        """
//"""
//        return _pythia8.SigmaTotal_hasCoulomb(self)
//
//    def dsigmaEl(self, t, useCoulomb=False, onlyPomerons=False):
//        """
//Differential elastic cross section.
//"""
//        return _pythia8.SigmaTotal_dsigmaEl(self, t, useCoulomb, onlyPomerons)
//
//    def sigmaXB(self):
//        """
//Integrated diffractive cross sections.
//"""
//        return _pythia8.SigmaTotal_sigmaXB(self)
//
//    def sigmaAX(self):
//        """
//"""
//        return _pythia8.SigmaTotal_sigmaAX(self)
//
//    def sigmaXX(self):
//        """
//"""
//        return _pythia8.SigmaTotal_sigmaXX(self)
//
//    def sigmaAXB(self):
//        """
//"""
//        return _pythia8.SigmaTotal_sigmaAXB(self)
//
//    def sigmaND(self):
//        """
//"""
//        return _pythia8.SigmaTotal_sigmaND(self)
//
//    def dsigmaSD(self, xi, t, isXB=True, step=0):
//        """
//Differential single diffractive cross section.
//"""
//        return _pythia8.SigmaTotal_dsigmaSD(self, xi, t, isXB, step)
//
//    def splitDiff(self):
//        """
//Possibility to separate xi and t choices for diffraction.
//"""
//        return _pythia8.SigmaTotal_splitDiff(self)
//
//    def dsigmaDD(self, xi1, xi2, t, step=0):
//        """
//Differential double diffractive cross section.
//"""
//        return _pythia8.SigmaTotal_dsigmaDD(self, xi1, xi2, t, step)
//
//    def dsigmaCD(self, xi1, xi2, t1, t2, step=0):
//        """
//Differential central diffractive cross section.
//"""
//        return _pythia8.SigmaTotal_dsigmaCD(self, xi1, xi2, t1, t2, step)
//
//    def mMinCD(self):
//        """
//Minimal central diffractive mass.
//"""
//        return _pythia8.SigmaTotal_mMinCD(self)
//
//    def tRange(self, sIn, s1In, s2In, s3In, s4In):
//        """
//Standard methods to find t range of a 2 -> 2 process
//and to check whether a given t value is in that range.
//"""
//        return _pythia8.SigmaTotal_tRange(self, sIn, s1In, s2In, s3In, s4In)
//
//    def tInRange(self, tIn, sIn, s1In, s2In, s3In, s4In):
//        """
//"""
//        return _pythia8.SigmaTotal_tInRange(self, tIn, sIn, s1In, s2In, s3In, s4In)
//SigmaTotal_swigregister = _pythia8.SigmaTotal_swigregister
//SigmaTotal_swigregister(SigmaTotal)
//
//class SigmaTotOwn(SigmaTotAux):
//    """
//The SigmaTotOwn class parametrizes total, elastic and diffractive
//cross sections by user settings.
//"""
//    __swig_setmethods__ = {}
//    for _s in [SigmaTotAux]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SigmaTotOwn, name, value)
//    __swig_getmethods__ = {}
//    for _s in [SigmaTotAux]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, SigmaTotOwn, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_SigmaTotOwn()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, arg2, settings, particleDataPtrIn, arg5):
//        """
//Store pointers and initialize data members.
//"""
//        return _pythia8.SigmaTotOwn_init(self, arg2, settings, particleDataPtrIn, arg5)
//
//    def calcTotEl(self, idAin, idBin, arg4, arg5, arg6):
//        """
//Calculate integrated total/elastic cross sections.
//"""
//        return _pythia8.SigmaTotOwn_calcTotEl(self, idAin, idBin, arg4, arg5, arg6)
//
//    def dsigmaEl(self, t, useCoulomb=False, arg4=True):
//        """
//Differential elastic cross section.
//"""
//        return _pythia8.SigmaTotOwn_dsigmaEl(self, t, useCoulomb, arg4)
//
//    def calcDiff(self, arg2, arg3, sIn, arg5, arg6):
//        """
//Calculate integrated diffractive cross sections.
//"""
//        return _pythia8.SigmaTotOwn_calcDiff(self, arg2, arg3, sIn, arg5, arg6)
//
//    def dsigmaSD(self, xi, t, arg4=True, arg5=0):
//        """
//Differential single diffractive cross section.
//"""
//        return _pythia8.SigmaTotOwn_dsigmaSD(self, xi, t, arg4, arg5)
//
//    def dsigmaDD(self, xi1, xi2, t, arg5=0):
//        """
//Differential double diffractive cross section.
//"""
//        return _pythia8.SigmaTotOwn_dsigmaDD(self, xi1, xi2, t, arg5)
//
//    def dsigmaCD(self, xi1, xi2, t1, t2, arg6=0):
//        """
//Differential central diffractive cross section.
//"""
//        return _pythia8.SigmaTotOwn_dsigmaCD(self, xi1, xi2, t1, t2, arg6)
//
//    def mMinCD(self):
//        """
//Minimal central diffractive mass.
//"""
//        return _pythia8.SigmaTotOwn_mMinCD(self)
//    __swig_destroy__ = _pythia8.delete_SigmaTotOwn
//    __del__ = lambda self: None
//SigmaTotOwn_swigregister = _pythia8.SigmaTotOwn_swigregister
//SigmaTotOwn_swigregister(SigmaTotOwn)
//
//class SigmaSaSDL(SigmaTotAux):
//    """
//The SigmaSaSDL class parametrizes total, elastic and diffractive
//cross sections according to Schuler and Sjostrand, starting from
//Donnachie and Landshoff.
//"""
//    __swig_setmethods__ = {}
//    for _s in [SigmaTotAux]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SigmaSaSDL, name, value)
//    __swig_getmethods__ = {}
//    for _s in [SigmaTotAux]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, SigmaSaSDL, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_SigmaSaSDL()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, infoPtrIn, settings, particleDataPtrIn, arg5):
//        """
//Store pointers and initialize data members.
//"""
//        return _pythia8.SigmaSaSDL_init(self, infoPtrIn, settings, particleDataPtrIn, arg5)
//
//    def calcTotEl(self, idAin, idBin, sIn, mAin, mBin):
//        """
//Calculate integrated total/elastic cross sections.
//"""
//        return _pythia8.SigmaSaSDL_calcTotEl(self, idAin, idBin, sIn, mAin, mBin)
//
//    def dsigmaEl(self, t, useCoulomb=False, arg4=True):
//        """
//Differential elastic cross section.
//"""
//        return _pythia8.SigmaSaSDL_dsigmaEl(self, t, useCoulomb, arg4)
//
//    def calcDiff(self, idAin, idBin, sIn, mAin, mBin):
//        """
//Calculate integrated diffractive cross sections.
//"""
//        return _pythia8.SigmaSaSDL_calcDiff(self, idAin, idBin, sIn, mAin, mBin)
//
//    def dsigmaSD(self, xi, t, isXB, arg5=0):
//        """
//Differential single diffractive cross section.
//"""
//        return _pythia8.SigmaSaSDL_dsigmaSD(self, xi, t, isXB, arg5)
//
//    def dsigmaDD(self, xi1, xi2, t, arg5=0):
//        """
//Differential double diffractive cross section.
//"""
//        return _pythia8.SigmaSaSDL_dsigmaDD(self, xi1, xi2, t, arg5)
//
//    def dsigmaCD(self, xi1, xi2, t1, t2, arg6=0):
//        """
//Differential central diffractive cross section.
//"""
//        return _pythia8.SigmaSaSDL_dsigmaCD(self, xi1, xi2, t1, t2, arg6)
//
//    def mMinCD(self):
//        """
//Minimal central diffractive mass.
//"""
//        return _pythia8.SigmaSaSDL_mMinCD(self)
//    __swig_destroy__ = _pythia8.delete_SigmaSaSDL
//    __del__ = lambda self: None
//SigmaSaSDL_swigregister = _pythia8.SigmaSaSDL_swigregister
//SigmaSaSDL_swigregister(SigmaSaSDL)
//
//class SigmaMBR(SigmaTotAux):
//    """
//The SigmaMBR class parametrizes total and elastic cross sections
//according to the Minimum Bias Rockefeller (MBR) model.
//"""
//    __swig_setmethods__ = {}
//    for _s in [SigmaTotAux]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SigmaMBR, name, value)
//    __swig_getmethods__ = {}
//    for _s in [SigmaTotAux]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, SigmaMBR, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_SigmaMBR()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, arg2, settings, particleDataPtrIn, arg5):
//        """
//Initialize data members.
//"""
//        return _pythia8.SigmaMBR_init(self, arg2, settings, particleDataPtrIn, arg5)
//
//    def calcTotEl(self, idAin, idBin, sIn, arg5, arg6):
//        """
//Calculate integrated total/elastic cross sections.
//"""
//        return _pythia8.SigmaMBR_calcTotEl(self, idAin, idBin, sIn, arg5, arg6)
//
//    def dsigmaEl(self, t, useCoulomb=False, arg4=True):
//        """
//Differential elastic cross section.
//"""
//        return _pythia8.SigmaMBR_dsigmaEl(self, t, useCoulomb, arg4)
//
//    def calcDiff(self, arg2, arg3, sIn, arg5, arg6):
//        """
//Calculate integrated diffractive cross sections.
//"""
//        return _pythia8.SigmaMBR_calcDiff(self, arg2, arg3, sIn, arg5, arg6)
//
//    def splitDiff(self):
//        """
//In MBR choice of xi and t values are separated.
//"""
//        return _pythia8.SigmaMBR_splitDiff(self)
//
//    def dsigmaSD(self, xi, t, arg4=True, step=0):
//        """
//Differential single diffractive cross section.
//"""
//        return _pythia8.SigmaMBR_dsigmaSD(self, xi, t, arg4, step)
//
//    def dsigmaDD(self, xi1, xi2, t, step=0):
//        """
//Differential double diffractive cross section.
//"""
//        return _pythia8.SigmaMBR_dsigmaDD(self, xi1, xi2, t, step)
//
//    def dsigmaCD(self, xi1, xi2, t1, t2, step=0):
//        """
//Differential central diffractive cross section.
//"""
//        return _pythia8.SigmaMBR_dsigmaCD(self, xi1, xi2, t1, t2, step)
//
//    def mMinCD(self):
//        """
//Minimal central diffractive mass.
//"""
//        return _pythia8.SigmaMBR_mMinCD(self)
//    __swig_destroy__ = _pythia8.delete_SigmaMBR
//    __del__ = lambda self: None
//SigmaMBR_swigregister = _pythia8.SigmaMBR_swigregister
//SigmaMBR_swigregister(SigmaMBR)
//
//class SigmaABMST(SigmaTotAux):
//    """
//The SigmaABMST class parametrizes total and elastic cross sections
//according to Appleby, Barlow, Molson, Serluca and Toader (ABMST).
//"""
//    __swig_setmethods__ = {}
//    for _s in [SigmaTotAux]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SigmaABMST, name, value)
//    __swig_getmethods__ = {}
//    for _s in [SigmaTotAux]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, SigmaABMST, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_SigmaABMST()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, arg2, settings, arg4, rndmPtrIn):
//        """
//Initialize data members.
//"""
//        return _pythia8.SigmaABMST_init(self, arg2, settings, arg4, rndmPtrIn)
//
//    def calcTotEl(self, idAin, idBin, sIn, arg5, arg6):
//        """
//Calculate integrated total/elastic cross sections.
//"""
//        return _pythia8.SigmaABMST_calcTotEl(self, idAin, idBin, sIn, arg5, arg6)
//
//    def dsigmaEl(self, t, useCoulomb=False, onlyPomerons=False):
//        """
//Differential elastic cross section.
//"""
//        return _pythia8.SigmaABMST_dsigmaEl(self, t, useCoulomb, onlyPomerons)
//
//    def calcDiff(self, idAin, idBin, sIn, arg5, arg6):
//        """
//Calculate integrated diffractive cross sections.
//"""
//        return _pythia8.SigmaABMST_calcDiff(self, idAin, idBin, sIn, arg5, arg6)
//
//    def dsigmaSD(self, xi, t, arg4=True, arg5=0):
//        """
//Differential single diffractive cross section.
//"""
//        return _pythia8.SigmaABMST_dsigmaSD(self, xi, t, arg4, arg5)
//
//    def dsigmaDD(self, xi1, xi2, t, arg5=0):
//        """
//Differential double diffractive cross section.
//"""
//        return _pythia8.SigmaABMST_dsigmaDD(self, xi1, xi2, t, arg5)
//
//    def dsigmaCD(self, xi1, xi2, t1, t2, arg6=0):
//        """
//Differential central diffractive cross section.
//"""
//        return _pythia8.SigmaABMST_dsigmaCD(self, xi1, xi2, t1, t2, arg6)
//
//    def mMinCD(self):
//        """
//Minimal central diffractive mass.
//"""
//        return _pythia8.SigmaABMST_mMinCD(self)
//    __swig_destroy__ = _pythia8.delete_SigmaABMST
//    __del__ = lambda self: None
//SigmaABMST_swigregister = _pythia8.SigmaABMST_swigregister
//SigmaABMST_swigregister(SigmaABMST)
//
//class SigmaRPP(SigmaTotAux):
//    """
//The SigmaRPP class parametrizes total and elastic cross sections
//according to the fit in Review of Particle Physics 2014.
//"""
//    __swig_setmethods__ = {}
//    for _s in [SigmaTotAux]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SigmaRPP, name, value)
//    __swig_getmethods__ = {}
//    for _s in [SigmaTotAux]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, SigmaRPP, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_SigmaRPP()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, arg2, settings, arg4, arg5):
//        """
//Initialize data members.
//"""
//        return _pythia8.SigmaRPP_init(self, arg2, settings, arg4, arg5)
//
//    def calcTotEl(self, idAin, idBin, sIn, arg5, arg6):
//        """
//Calculate integrated total/elastic cross sections.
//"""
//        return _pythia8.SigmaRPP_calcTotEl(self, idAin, idBin, sIn, arg5, arg6)
//
//    def dsigmaEl(self, t, useCoulomb=False, arg4=True):
//        """
//Differential elastic cross section.
//"""
//        return _pythia8.SigmaRPP_dsigmaEl(self, t, useCoulomb, arg4)
//    __swig_destroy__ = _pythia8.delete_SigmaRPP
//    __del__ = lambda self: None
//SigmaRPP_swigregister = _pythia8.SigmaRPP_swigregister
//SigmaRPP_swigregister(SigmaRPP)
//
//class SLHAinterface(_object):
//    """
//The SLHAinterface class handles communication between Pythia and
//SusyLesHouches.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SLHAinterface, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, SLHAinterface, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_SLHAinterface()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def setPtr(self, infoPtrIn):
//        """
//Set pointers
//"""
//        return _pythia8.SLHAinterface_setPtr(self, infoPtrIn)
//
//    def init(self, settings, rndmPtr, couplingsPtrIn, particleDataPtr, useSHLAcouplings, ParticleDataBuffer):
//        """
//Initialize and switch to SUSY couplings if reading SLHA spectrum
//"""
//        return _pythia8.SLHAinterface_init(self, settings, rndmPtr, couplingsPtrIn, particleDataPtr, useSHLAcouplings, ParticleDataBuffer)
//
//    def initSLHA(self, settings, particleDataPtr):
//        """
//Initialize SUSY Les Houches Accord data.
//"""
//        return _pythia8.SLHAinterface_initSLHA(self, settings, particleDataPtr)
//
//    def pythia2slha(self, particleDataPtr):
//        """
//Initialize SLHA blocks SMINPUTS and MASS from PYTHIA SM parameter values.
//E.g., to make sure that there are no important unfilled entries
//"""
//        return _pythia8.SLHAinterface_pythia2slha(self, particleDataPtr)
//    __swig_setmethods__["slha"] = _pythia8.SLHAinterface_slha_set
//    __swig_getmethods__["slha"] = _pythia8.SLHAinterface_slha_get
//    if _newclass:
//        slha = _swig_property(_pythia8.SLHAinterface_slha_get, _pythia8.SLHAinterface_slha_set)
//    __swig_setmethods__["coupSUSY"] = _pythia8.SLHAinterface_coupSUSY_set
//    __swig_getmethods__["coupSUSY"] = _pythia8.SLHAinterface_coupSUSY_get
//    if _newclass:
//        coupSUSY = _swig_property(_pythia8.SLHAinterface_coupSUSY_get, _pythia8.SLHAinterface_coupSUSY_set)
//    __swig_setmethods__["couplingsPtr"] = _pythia8.SLHAinterface_couplingsPtr_set
//    __swig_getmethods__["couplingsPtr"] = _pythia8.SLHAinterface_couplingsPtr_get
//    if _newclass:
//        couplingsPtr = _swig_property(_pythia8.SLHAinterface_couplingsPtr_get, _pythia8.SLHAinterface_couplingsPtr_set)
//    __swig_setmethods__["infoPtr"] = _pythia8.SLHAinterface_infoPtr_set
//    __swig_getmethods__["infoPtr"] = _pythia8.SLHAinterface_infoPtr_get
//    if _newclass:
//        infoPtr = _swig_property(_pythia8.SLHAinterface_infoPtr_get, _pythia8.SLHAinterface_infoPtr_set)
//    __swig_setmethods__["settingsPtr"] = _pythia8.SLHAinterface_settingsPtr_set
//    __swig_getmethods__["settingsPtr"] = _pythia8.SLHAinterface_settingsPtr_get
//    if _newclass:
//        settingsPtr = _swig_property(_pythia8.SLHAinterface_settingsPtr_get, _pythia8.SLHAinterface_settingsPtr_set)
//    __swig_setmethods__["meMode"] = _pythia8.SLHAinterface_meMode_set
//    __swig_getmethods__["meMode"] = _pythia8.SLHAinterface_meMode_get
//    if _newclass:
//        meMode = _swig_property(_pythia8.SLHAinterface_meMode_get, _pythia8.SLHAinterface_meMode_set)
//    __swig_destroy__ = _pythia8.delete_SLHAinterface
//    __del__ = lambda self: None
//SLHAinterface_swigregister = _pythia8.SLHAinterface_swigregister
//SLHAinterface_swigregister(SLHAinterface)
//
//class WidthFunction(_object):
//    """
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, WidthFunction, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, WidthFunction, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor and destructor.
//"""
//        this = _pythia8.new_WidthFunction()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_WidthFunction
//    __del__ = lambda self: None
//
//    def setPointers(self, particleDataPtrIn, coupSUSYPtrIn, infoPtrIn):
//        """
//Public methods.
//"""
//        return _pythia8.WidthFunction_setPointers(self, particleDataPtrIn, coupSUSYPtrIn, infoPtrIn)
//
//    def getWidth(self, arg2, arg3):
//        """
//"""
//        return _pythia8.WidthFunction_getWidth(self, arg2, arg3)
//
//    def f(self, xIn):
//        """
//Wrappers to simplify using FunctionEncapsulator's integrator.
//"""
//        return _pythia8.WidthFunction_f(self, xIn)
//WidthFunction_swigregister = _pythia8.WidthFunction_swigregister
//WidthFunction_swigregister(WidthFunction)
//
//class StauWidths(WidthFunction):
//    """
//Class StauWidths.
//"""
//    __swig_setmethods__ = {}
//    for _s in [WidthFunction]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, StauWidths, name, value)
//    __swig_getmethods__ = {}
//    for _s in [WidthFunction]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, StauWidths, name)
//    __repr__ = _swig_repr
//    __swig_destroy__ = _pythia8.delete_StauWidths
//    __del__ = lambda self: None
//
//    def getWidth(self, idResIn, idIn):
//        """
//Public method.
//"""
//        return _pythia8.StauWidths_getWidth(self, idResIn, idIn)
//
//    def __init__(self):
//        this = _pythia8.new_StauWidths()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//StauWidths_swigregister = _pythia8.StauWidths_swigregister
//StauWidths_swigregister(StauWidths)
//
//class Particle(_object):
//    """
//Particle class.
//This class holds info on a particle in general.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Particle, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, Particle, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_Particle(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def setEvtPtr(self, evtPtrIn):
//        """
//Member functions to set the Event and ParticleDataEntry pointers.
//"""
//        return _pythia8.Particle_setEvtPtr(self, evtPtrIn)
//
//    def setPDEPtr(self, pdePtrIn=None):
//        """
//"""
//        return _pythia8.Particle_setPDEPtr(self, pdePtrIn)
//
//    def statusPos(self):
//        """
//"""
//        return _pythia8.Particle_statusPos(self)
//
//    def statusNeg(self):
//        """
//"""
//        return _pythia8.Particle_statusNeg(self)
//
//    def statusCode(self, statusIn):
//        """
//"""
//        return _pythia8.Particle_statusCode(self, statusIn)
//
//    def mothers(self, mother1In=0, mother2In=0):
//        """
//"""
//        return _pythia8.Particle_mothers(self, mother1In, mother2In)
//
//    def daughters(self, daughter1In=0, daughter2In=0):
//        """
//"""
//        return _pythia8.Particle_daughters(self, daughter1In, daughter2In)
//
//    def cols(self, colIn=0, acolIn=0):
//        """
//"""
//        return _pythia8.Particle_cols(self, colIn, acolIn)
//
//    def id(self, *args):
//        """
//Member functions for output.
//"""
//        return _pythia8.Particle_id(self, *args)
//
//    def status(self, *args):
//        """
//"""
//        return _pythia8.Particle_status(self, *args)
//
//    def mother1(self, *args):
//        """
//"""
//        return _pythia8.Particle_mother1(self, *args)
//
//    def mother2(self, *args):
//        """
//"""
//        return _pythia8.Particle_mother2(self, *args)
//
//    def daughter1(self, *args):
//        """
//"""
//        return _pythia8.Particle_daughter1(self, *args)
//
//    def daughter2(self, *args):
//        """
//"""
//        return _pythia8.Particle_daughter2(self, *args)
//
//    def col(self, *args):
//        """
//"""
//        return _pythia8.Particle_col(self, *args)
//
//    def acol(self, *args):
//        """
//"""
//        return _pythia8.Particle_acol(self, *args)
//
//    def p(self, *args):
//        """
//"""
//        return _pythia8.Particle_p(self, *args)
//
//    def px(self, *args):
//        """
//"""
//        return _pythia8.Particle_px(self, *args)
//
//    def py(self, *args):
//        """
//"""
//        return _pythia8.Particle_py(self, *args)
//
//    def pz(self, *args):
//        """
//"""
//        return _pythia8.Particle_pz(self, *args)
//
//    def e(self, *args):
//        """
//"""
//        return _pythia8.Particle_e(self, *args)
//
//    def m(self, *args):
//        """
//"""
//        return _pythia8.Particle_m(self, *args)
//
//    def scale(self, *args):
//        """
//"""
//        return _pythia8.Particle_scale(self, *args)
//
//    def pol(self, *args):
//        """
//"""
//        return _pythia8.Particle_pol(self, *args)
//
//    def hasVertex(self):
//        """
//"""
//        return _pythia8.Particle_hasVertex(self)
//
//    def vProd(self, *args):
//        """
//"""
//        return _pythia8.Particle_vProd(self, *args)
//
//    def xProd(self, *args):
//        """
//"""
//        return _pythia8.Particle_xProd(self, *args)
//
//    def yProd(self, *args):
//        """
//"""
//        return _pythia8.Particle_yProd(self, *args)
//
//    def zProd(self, *args):
//        """
//"""
//        return _pythia8.Particle_zProd(self, *args)
//
//    def tProd(self, *args):
//        """
//"""
//        return _pythia8.Particle_tProd(self, *args)
//
//    def tau(self, *args):
//        """
//"""
//        return _pythia8.Particle_tau(self, *args)
//
//    def idAbs(self):
//        """
//Member functions for output; derived int and bool quantities.
//"""
//        return _pythia8.Particle_idAbs(self)
//
//    def statusAbs(self):
//        """
//"""
//        return _pythia8.Particle_statusAbs(self)
//
//    def isFinal(self):
//        """
//"""
//        return _pythia8.Particle_isFinal(self)
//
//    def intPol(self):
//        """
//"""
//        return _pythia8.Particle_intPol(self)
//
//    def isRescatteredIncoming(self):
//        """
//"""
//        return _pythia8.Particle_isRescatteredIncoming(self)
//
//    def m2(self):
//        """
//Member functions for output; derived double quantities.
//"""
//        return _pythia8.Particle_m2(self)
//
//    def mCalc(self):
//        """
//"""
//        return _pythia8.Particle_mCalc(self)
//
//    def m2Calc(self):
//        """
//"""
//        return _pythia8.Particle_m2Calc(self)
//
//    def eCalc(self):
//        """
//"""
//        return _pythia8.Particle_eCalc(self)
//
//    def pT(self):
//        """
//"""
//        return _pythia8.Particle_pT(self)
//
//    def pT2(self):
//        """
//"""
//        return _pythia8.Particle_pT2(self)
//
//    def mT(self):
//        """
//"""
//        return _pythia8.Particle_mT(self)
//
//    def mT2(self):
//        """
//"""
//        return _pythia8.Particle_mT2(self)
//
//    def pAbs(self):
//        """
//"""
//        return _pythia8.Particle_pAbs(self)
//
//    def pAbs2(self):
//        """
//"""
//        return _pythia8.Particle_pAbs2(self)
//
//    def eT(self):
//        """
//"""
//        return _pythia8.Particle_eT(self)
//
//    def eT2(self):
//        """
//"""
//        return _pythia8.Particle_eT2(self)
//
//    def theta(self):
//        """
//"""
//        return _pythia8.Particle_theta(self)
//
//    def phi(self):
//        """
//"""
//        return _pythia8.Particle_phi(self)
//
//    def thetaXZ(self):
//        """
//"""
//        return _pythia8.Particle_thetaXZ(self)
//
//    def pPos(self):
//        """
//"""
//        return _pythia8.Particle_pPos(self)
//
//    def pNeg(self):
//        """
//"""
//        return _pythia8.Particle_pNeg(self)
//
//    def eta(self):
//        """
//"""
//        return _pythia8.Particle_eta(self)
//
//    def y(self, *args):
//        """
//"""
//        return _pythia8.Particle_y(self, *args)
//
//    def vDec(self):
//        """
//"""
//        return _pythia8.Particle_vDec(self)
//
//    def xDec(self):
//        """
//"""
//        return _pythia8.Particle_xDec(self)
//
//    def yDec(self):
//        """
//"""
//        return _pythia8.Particle_yDec(self)
//
//    def zDec(self):
//        """
//"""
//        return _pythia8.Particle_zDec(self)
//
//    def tDec(self):
//        """
//"""
//        return _pythia8.Particle_tDec(self)
//
//    def index(self):
//        """
//Methods that can refer back to the event the particle belongs to.
//"""
//        return _pythia8.Particle_index(self)
//
//    def iTopCopy(self):
//        """
//"""
//        return _pythia8.Particle_iTopCopy(self)
//
//    def iBotCopy(self):
//        """
//"""
//        return _pythia8.Particle_iBotCopy(self)
//
//    def iTopCopyId(self, simplify=False):
//        """
//"""
//        return _pythia8.Particle_iTopCopyId(self, simplify)
//
//    def iBotCopyId(self, simplify=False):
//        """
//"""
//        return _pythia8.Particle_iBotCopyId(self, simplify)
//
//    def motherList(self):
//        """
//"""
//        return _pythia8.Particle_motherList(self)
//
//    def daughterList(self):
//        """
//"""
//        return _pythia8.Particle_daughterList(self)
//
//    def daughterListRecursive(self):
//        """
//"""
//        return _pythia8.Particle_daughterListRecursive(self)
//
//    def sisterList(self, traceTopBot=False):
//        """
//"""
//        return _pythia8.Particle_sisterList(self, traceTopBot)
//
//    def isAncestor(self, iAncestor):
//        """
//"""
//        return _pythia8.Particle_isAncestor(self, iAncestor)
//
//    def statusHepMC(self):
//        """
//"""
//        return _pythia8.Particle_statusHepMC(self)
//
//    def isFinalPartonLevel(self):
//        """
//"""
//        return _pythia8.Particle_isFinalPartonLevel(self)
//
//    def undoDecay(self):
//        """
//"""
//        return _pythia8.Particle_undoDecay(self)
//
//    def name(self):
//        """
//Further output, based on a pointer to a ParticleDataEntry object.
//"""
//        return _pythia8.Particle_name(self)
//
//    def nameWithStatus(self, maxLen=20):
//        """
//"""
//        return _pythia8.Particle_nameWithStatus(self, maxLen)
//
//    def spinType(self):
//        """
//"""
//        return _pythia8.Particle_spinType(self)
//
//    def chargeType(self):
//        """
//"""
//        return _pythia8.Particle_chargeType(self)
//
//    def charge(self):
//        """
//"""
//        return _pythia8.Particle_charge(self)
//
//    def isCharged(self):
//        """
//"""
//        return _pythia8.Particle_isCharged(self)
//
//    def isNeutral(self):
//        """
//"""
//        return _pythia8.Particle_isNeutral(self)
//
//    def colType(self):
//        """
//"""
//        return _pythia8.Particle_colType(self)
//
//    def m0(self):
//        """
//"""
//        return _pythia8.Particle_m0(self)
//
//    def mWidth(self):
//        """
//"""
//        return _pythia8.Particle_mWidth(self)
//
//    def mMin(self):
//        """
//"""
//        return _pythia8.Particle_mMin(self)
//
//    def mMax(self):
//        """
//"""
//        return _pythia8.Particle_mMax(self)
//
//    def mSel(self):
//        """
//"""
//        return _pythia8.Particle_mSel(self)
//
//    def constituentMass(self):
//        """
//"""
//        return _pythia8.Particle_constituentMass(self)
//
//    def tau0(self):
//        """
//"""
//        return _pythia8.Particle_tau0(self)
//
//    def mayDecay(self):
//        """
//"""
//        return _pythia8.Particle_mayDecay(self)
//
//    def canDecay(self):
//        """
//"""
//        return _pythia8.Particle_canDecay(self)
//
//    def doExternalDecay(self):
//        """
//"""
//        return _pythia8.Particle_doExternalDecay(self)
//
//    def isResonance(self):
//        """
//"""
//        return _pythia8.Particle_isResonance(self)
//
//    def isVisible(self):
//        """
//"""
//        return _pythia8.Particle_isVisible(self)
//
//    def isLepton(self):
//        """
//"""
//        return _pythia8.Particle_isLepton(self)
//
//    def isQuark(self):
//        """
//"""
//        return _pythia8.Particle_isQuark(self)
//
//    def isGluon(self):
//        """
//"""
//        return _pythia8.Particle_isGluon(self)
//
//    def isDiquark(self):
//        """
//"""
//        return _pythia8.Particle_isDiquark(self)
//
//    def isParton(self):
//        """
//"""
//        return _pythia8.Particle_isParton(self)
//
//    def isHadron(self):
//        """
//"""
//        return _pythia8.Particle_isHadron(self)
//
//    def particleDataEntry(self):
//        """
//"""
//        return _pythia8.Particle_particleDataEntry(self)
//
//    def rescale3(self, fac):
//        """
//Member functions that perform operations.
//"""
//        return _pythia8.Particle_rescale3(self, fac)
//
//    def rescale4(self, fac):
//        """
//"""
//        return _pythia8.Particle_rescale4(self, fac)
//
//    def rescale5(self, fac):
//        """
//"""
//        return _pythia8.Particle_rescale5(self, fac)
//
//    def rot(self, thetaIn, phiIn):
//        """
//"""
//        return _pythia8.Particle_rot(self, thetaIn, phiIn)
//
//    def bst(self, *args):
//        """
//"""
//        return _pythia8.Particle_bst(self, *args)
//
//    def bstback(self, *args):
//        """
//"""
//        return _pythia8.Particle_bstback(self, *args)
//
//    def rotbst(self, M):
//        """
//"""
//        return _pythia8.Particle_rotbst(self, M)
//
//    def offsetHistory(self, minMother, addMother, minDaughter, addDaughter):
//        """
//"""
//        return _pythia8.Particle_offsetHistory(self, minMother, addMother, minDaughter, addDaughter)
//
//    def offsetCol(self, addCol):
//        """
//"""
//        return _pythia8.Particle_offsetCol(self, addCol)
//    __swig_destroy__ = _pythia8.delete_Particle
//    __del__ = lambda self: None
//Particle_swigregister = _pythia8.Particle_swigregister
//Particle_swigregister(Particle)
//
//
//def m(*args):
//    return _pythia8.m(*args)
//m = _pythia8.m
//class Junction(_object):
//    """
//The junction class stores what kind of junction it is, the colour indices
//of the legs at the junction and as far out as legs have been traced,
//and the status codes assigned for fragmentation of each leg.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Junction, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, Junction, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_Junction(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def cols(self, j, colIn, endColIn):
//        """
//"""
//        return _pythia8.Junction_cols(self, j, colIn, endColIn)
//
//    def remains(self, *args):
//        """
//Read out value.
//"""
//        return _pythia8.Junction_remains(self, *args)
//
//    def kind(self):
//        """
//"""
//        return _pythia8.Junction_kind(self)
//
//    def col(self, *args):
//        """
//"""
//        return _pythia8.Junction_col(self, *args)
//
//    def endCol(self, *args):
//        """
//"""
//        return _pythia8.Junction_endCol(self, *args)
//
//    def status(self, *args):
//        """
//"""
//        return _pythia8.Junction_status(self, *args)
//    __swig_destroy__ = _pythia8.delete_Junction
//    __del__ = lambda self: None
//Junction_swigregister = _pythia8.Junction_swigregister
//Junction_swigregister(Junction)
//
//class Event(_object):
//    """
//The Event class holds all info on the generated event.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Event, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, Event, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_Event(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, *args):
//        """
//Initialize header for event listing, particle data table, and colour.
//"""
//        return _pythia8.Event_init(self, *args)
//
//    def clear(self):
//        """
//Clear event record.
//"""
//        return _pythia8.Event_clear(self)
//
//    def reset(self):
//        """
//Clear event record, and set first particle empty.
//"""
//        return _pythia8.Event_reset(self)
//
//    def front(self):
//        """
//Implement standard references to elements in the particle array.
//"""
//        return _pythia8.Event_front(self)
//
//    def at(self, i):
//        """
//"""
//        return _pythia8.Event_at(self, i)
//
//    def back(self):
//        """
//"""
//        return _pythia8.Event_back(self)
//
//    def size(self):
//        """
//Event record size.
//"""
//        return _pythia8.Event_size(self)
//
//    def append(self, *args):
//        """
//"""
//        return _pythia8.Event_append(self, *args)
//
//    def setEvtPtr(self, iSet=-1):
//        """
//Set pointer to the event for a particle, by default latest one.
//"""
//        return _pythia8.Event_setEvtPtr(self, iSet)
//
//    def copy(self, iCopy, newStatus=0):
//        """
//Add a copy of an existing particle at the end of the event record.
//"""
//        return _pythia8.Event_copy(self, iCopy, newStatus)
//
//    def popBack(self, nRemove=1):
//        """
//Remove last n entries.
//"""
//        return _pythia8.Event_popBack(self, nRemove)
//
//    def remove(self, iFirst, iLast, shiftHistory=True):
//        """
//Remove entries from iFirst to iLast, including endpoints, anf fix history.
//(To the extent possible; history pointers in removed range are zeroed.)
//"""
//        return _pythia8.Event_remove(self, iFirst, iLast, shiftHistory)
//
//    def restorePtrs(self):
//        """
//Restore all ParticleDataEntry* pointers in the Particle vector.
//Useful when a persistent copy of the event record is read back in.
//"""
//        return _pythia8.Event_restorePtrs(self)
//
//    def saveSize(self):
//        """
//Save or restore the size of the event record (throwing at the end).
//"""
//        return _pythia8.Event_saveSize(self)
//
//    def restoreSize(self):
//        """
//"""
//        return _pythia8.Event_restoreSize(self)
//
//    def savedSizeValue(self):
//        """
//"""
//        return _pythia8.Event_savedSizeValue(self)
//
//    def initColTag(self, colTag=0):
//        """
//Initialize and access colour tag information.
//"""
//        return _pythia8.Event_initColTag(self, colTag)
//
//    def lastColTag(self):
//        """
//"""
//        return _pythia8.Event_lastColTag(self)
//
//    def nextColTag(self):
//        """
//"""
//        return _pythia8.Event_nextColTag(self)
//
//    def scale(self, *args):
//        """
//"""
//        return _pythia8.Event_scale(self, *args)
//
//    def scaleSecond(self, *args):
//        """
//"""
//        return _pythia8.Event_scaleSecond(self, *args)
//
//    def daughterList(self, i):
//        """
//Find complete list of daughters.
//Note: temporarily retained for CMS compatibility. Do not use!
//"""
//        return _pythia8.Event_daughterList(self, i)
//
//    def rot(self, theta, phi):
//        """
//Member functions for rotations and boosts of an event.
//"""
//        return _pythia8.Event_rot(self, theta, phi)
//
//    def bst(self, *args):
//        """
//"""
//        return _pythia8.Event_bst(self, *args)
//
//    def rotbst(self, M):
//        """
//"""
//        return _pythia8.Event_rotbst(self, M)
//
//    def clearJunctions(self):
//        """
//Clear the list of junctions.
//"""
//        return _pythia8.Event_clearJunctions(self)
//
//    def appendJunction(self, *args):
//        """
//"""
//        return _pythia8.Event_appendJunction(self, *args)
//
//    def sizeJunction(self):
//        """
//"""
//        return _pythia8.Event_sizeJunction(self)
//
//    def remainsJunction(self, *args):
//        """
//"""
//        return _pythia8.Event_remainsJunction(self, *args)
//
//    def kindJunction(self, i):
//        """
//"""
//        return _pythia8.Event_kindJunction(self, i)
//
//    def colJunction(self, *args):
//        """
//"""
//        return _pythia8.Event_colJunction(self, *args)
//
//    def endColJunction(self, *args):
//        """
//"""
//        return _pythia8.Event_endColJunction(self, *args)
//
//    def statusJunction(self, *args):
//        """
//"""
//        return _pythia8.Event_statusJunction(self, *args)
//
//    def getJunction(self, *args):
//        """
//"""
//        return _pythia8.Event_getJunction(self, *args)
//
//    def eraseJunction(self, i):
//        """
//"""
//        return _pythia8.Event_eraseJunction(self, i)
//
//    def saveJunctionSize(self):
//        """
//Save or restore the size of the junction list (throwing at the end).
//"""
//        return _pythia8.Event_saveJunctionSize(self)
//
//    def restoreJunctionSize(self):
//        """
//"""
//        return _pythia8.Event_restoreJunctionSize(self)
//
//    def listJunctions(self):
//        """
//List any junctions in the event; for debug mainly.
//"""
//        return _pythia8.Event_listJunctions(self)
//
//    def savePartonLevelSize(self):
//        """
//Save event record size at Parton Level, i.e. before hadronization.
//"""
//        return _pythia8.Event_savePartonLevelSize(self)
//
//    def __iadd__(self, addEvent):
//        return _pythia8.Event___iadd__(self, addEvent)
//
//    def __str__(self):
//        return _pythia8.Event___str__(self)
//
//    def __getitem__(self, i):
//        return _pythia8.Event___getitem__(self, i)
//    __swig_destroy__ = _pythia8.delete_Event
//    __del__ = lambda self: None
//Event_swigregister = _pythia8.Event_swigregister
//Event_swigregister(Event)
//
//class FlavContainer(_object):
//    """
//The FlavContainer class is a simple container for flavour,
//including the extra properties needed for popcorn baryon handling.
//id = current flavour.
//rank = current rank; 0 for endpoint flavour and then increase by 1.
//nPop = number of popcorn mesons yet to be produced (1 or 0).
//idPop = (absolute sign of) popcorn quark, shared between B and Bbar.
//idVtx = (absolute sign of) vertex (= non-shared) quark in diquark.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, FlavContainer, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, FlavContainer, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idIn=0, rankIn=0, nPopIn=0, idPopIn=0, idVtxIn=0):
//        """
//Constructor.
//"""
//        this = _pythia8.new_FlavContainer(idIn, rankIn, nPopIn, idPopIn, idVtxIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def copy(self, flav):
//        """
//Read in a container into another, without/with id sign flip.
//"""
//        return _pythia8.FlavContainer_copy(self, flav)
//
//    def anti(self, *args):
//        """
//"""
//        return _pythia8.FlavContainer_anti(self, *args)
//
//    def isDiquark(self):
//        """
//Check whether is diquark.
//"""
//        return _pythia8.FlavContainer_isDiquark(self)
//    __swig_setmethods__["id"] = _pythia8.FlavContainer_id_set
//    __swig_getmethods__["id"] = _pythia8.FlavContainer_id_get
//    if _newclass:
//        id = _swig_property(_pythia8.FlavContainer_id_get, _pythia8.FlavContainer_id_set)
//    __swig_setmethods__["rank"] = _pythia8.FlavContainer_rank_set
//    __swig_getmethods__["rank"] = _pythia8.FlavContainer_rank_get
//    if _newclass:
//        rank = _swig_property(_pythia8.FlavContainer_rank_get, _pythia8.FlavContainer_rank_set)
//    __swig_setmethods__["nPop"] = _pythia8.FlavContainer_nPop_set
//    __swig_getmethods__["nPop"] = _pythia8.FlavContainer_nPop_get
//    if _newclass:
//        nPop = _swig_property(_pythia8.FlavContainer_nPop_get, _pythia8.FlavContainer_nPop_set)
//    __swig_setmethods__["idPop"] = _pythia8.FlavContainer_idPop_set
//    __swig_getmethods__["idPop"] = _pythia8.FlavContainer_idPop_get
//    if _newclass:
//        idPop = _swig_property(_pythia8.FlavContainer_idPop_get, _pythia8.FlavContainer_idPop_set)
//    __swig_setmethods__["idVtx"] = _pythia8.FlavContainer_idVtx_set
//    __swig_getmethods__["idVtx"] = _pythia8.FlavContainer_idVtx_get
//    if _newclass:
//        idVtx = _swig_property(_pythia8.FlavContainer_idVtx_get, _pythia8.FlavContainer_idVtx_set)
//    __swig_destroy__ = _pythia8.delete_FlavContainer
//    __del__ = lambda self: None
//FlavContainer_swigregister = _pythia8.FlavContainer_swigregister
//FlavContainer_swigregister(FlavContainer)
//
//class StringFlav(_object):
//    """
//The StringFlav class is used to select quark and hadron flavours.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, StringFlav, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, StringFlav, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_StringFlav()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_StringFlav
//    __del__ = lambda self: None
//
//    def init(self, settings, particleDataPtrIn, rndmPtrIn, infoPtrIn):
//        """
//Initialize data members.
//"""
//        return _pythia8.StringFlav_init(self, settings, particleDataPtrIn, rndmPtrIn, infoPtrIn)
//
//    def pickLightQ(self):
//        """
//Pick a light d, u or s quark according to fixed ratios.
//"""
//        return _pythia8.StringFlav_pickLightQ(self)
//
//    def pick(self, flavOld, pT=-1.0, nNSP=0.0):
//        """
//Pick a new flavour (including diquarks) given an incoming one,
//either by old standard Gaussian or new alternative exponential.
//"""
//        return _pythia8.StringFlav_pick(self, flavOld, pT, nNSP)
//
//    def pickGauss(self, flavOld):
//        """
//"""
//        return _pythia8.StringFlav_pickGauss(self, flavOld)
//
//    def pickThermal(self, flavOld, pT, nNSP):
//        """
//"""
//        return _pythia8.StringFlav_pickThermal(self, flavOld, pT, nNSP)
//
//    def combine(self, flav1, flav2):
//        """
//"""
//        return _pythia8.StringFlav_combine(self, flav1, flav2)
//
//    def combineId(self, id1, id2, keepTrying=True):
//        """
//Ditto, simplified input argument for simple configurations.
//"""
//        return _pythia8.StringFlav_combineId(self, id1, id2, keepTrying)
//
//    def getHadronIDwin(self):
//        """
//Return chosen hadron in case of thermal model.
//"""
//        return _pythia8.StringFlav_getHadronIDwin(self)
//
//    def combineLastThermal(self, flav1, flav2, pT, nNSP):
//        """
//"""
//        return _pythia8.StringFlav_combineLastThermal(self, flav1, flav2, pT, nNSP)
//
//    def getHadronID(self, flav1, flav2, pT=-1.0, nNSP=0, finalTwo=False):
//        """
//General function, decides whether to just return the hadron id
//if thermal model was use or whether to combine the two flavours.
//"""
//        return _pythia8.StringFlav_getHadronID(self, flav1, flav2, pT, nNSP, finalTwo)
//
//    def getHadronMassWin(self, idHad):
//        """
//Return hadron mass. Used one if present, pick otherwise.
//"""
//        return _pythia8.StringFlav_getHadronMassWin(self, idHad)
//
//    def assignPopQ(self, flav):
//        """
//Assign popcorn quark inside an original (= rank 0) diquark.
//"""
//        return _pythia8.StringFlav_assignPopQ(self, flav)
//
//    def makeDiquark(self, id1, id2, idHad=0):
//        """
//Combine two quarks to produce a diquark.
//"""
//        return _pythia8.StringFlav_makeDiquark(self, id1, id2, idHad)
//
//    def addQuarkDiquark(self, quarkCombis, qID, diqID, hadronID):
//        """
//Check if quark-diquark combination should be added. If so add.
//"""
//        return _pythia8.StringFlav_addQuarkDiquark(self, quarkCombis, qID, diqID, hadronID)
//
//    def getMesonSpinCounter(self, hadronID):
//        """
//Get spin counter for mesons.
//"""
//        return _pythia8.StringFlav_getMesonSpinCounter(self, hadronID)
//StringFlav_swigregister = _pythia8.StringFlav_swigregister
//StringFlav_swigregister(StringFlav)
//
//class LundFFRaw(_object):
//    """
//Auxiliary class to encapsulate (unnormalised) Lund FF.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, LundFFRaw, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, LundFFRaw, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor and destructor.
//"""
//        this = _pythia8.new_LundFFRaw()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_LundFFRaw
//    __del__ = lambda self: None
//
//    def f(self, args):
//        """
//f(z) = (1-z)^a / z^c * Exp ( - b * mT2 / z).
//"""
//        return _pythia8.LundFFRaw_f(self, args)
//LundFFRaw_swigregister = _pythia8.LundFFRaw_swigregister
//LundFFRaw_swigregister(LundFFRaw)
//
//class LundFFAvg(_object):
//    """
//Auxiliary class to encapsulate average, <z>, of Lund FF.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, LundFFAvg, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, LundFFAvg, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor and destructor.
//"""
//        this = _pythia8.new_LundFFAvg()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_LundFFAvg
//    __del__ = lambda self: None
//
//    def f(self, argsIn):
//        """
//<z> = integral( z * f(z) dz ) / integral( f(z) dz ),
//argsIn[] : a, b, c, mT2, and optionally integrator tolerance parameter.
//"""
//        return _pythia8.LundFFAvg_f(self, argsIn)
//LundFFAvg_swigregister = _pythia8.LundFFAvg_swigregister
//LundFFAvg_swigregister(LundFFAvg)
//
//class StringZ(_object):
//    """
//The StringZ class is used to sample the fragmentation function f(z).
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, StringZ, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, StringZ, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_StringZ()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_StringZ
//    __del__ = lambda self: None
//
//    def init(self, settings, particleData, rndmPtrIn, infoPtrIn):
//        """
//Initialize data members.
//"""
//        return _pythia8.StringZ_init(self, settings, particleData, rndmPtrIn, infoPtrIn)
//
//    def zFrag(self, idOld, idNew=0, mT2=1.):
//        """
//Fragmentation function: top-level to determine parameters.
//"""
//        return _pythia8.StringZ_zFrag(self, idOld, idNew, mT2)
//
//    def stopMass(self):
//        """
//Parameters for stopping in the middle; overloaded for Hidden Valley.
//"""
//        return _pythia8.StringZ_stopMass(self)
//
//    def stopNewFlav(self):
//        """
//"""
//        return _pythia8.StringZ_stopNewFlav(self)
//
//    def stopSmear(self):
//        """
//"""
//        return _pythia8.StringZ_stopSmear(self)
//
//    def aAreaLund(self):
//        """
//a and b fragmentation parameters needed in some operations.
//"""
//        return _pythia8.StringZ_aAreaLund(self)
//
//    def bAreaLund(self):
//        """
//"""
//        return _pythia8.StringZ_bAreaLund(self)
//
//    def deriveBLund(self, settings, particleData):
//        """
//Method to derive bLund from <z> (for fixed a and reference mT2).
//"""
//        return _pythia8.StringZ_deriveBLund(self, settings, particleData)
//StringZ_swigregister = _pythia8.StringZ_swigregister
//StringZ_swigregister(StringZ)
//
//class StringPT(_object):
//    """
//The StringPT class is used to select select transverse momenta.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, StringPT, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, StringPT, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_StringPT()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_StringPT
//    __del__ = lambda self: None
//
//    def init(self, settings, particleDataPtr, rndmPtrIn, infoPtrIn):
//        """
//Initialize data members.
//"""
//        return _pythia8.StringPT_init(self, settings, particleDataPtr, rndmPtrIn, infoPtrIn)
//
//    def pxy(self, idIn, nNSP=0.0):
//        """
//General function, return px and py as a pair in the same call
//in either model.
//"""
//        return _pythia8.StringPT_pxy(self, idIn, nNSP)
//
//    def pxyGauss(self, idIn=0, nNSP=0.0):
//        """
//"""
//        return _pythia8.StringPT_pxyGauss(self, idIn, nNSP)
//
//    def pxyThermal(self, idIn, nNSP=0.0):
//        """
//"""
//        return _pythia8.StringPT_pxyThermal(self, idIn, nNSP)
//
//    def suppressPT2(self, pT2):
//        """
//Gaussian suppression of given pT2; used in MiniStringFragmentation.
//"""
//        return _pythia8.StringPT_suppressPT2(self, pT2)
//StringPT_swigregister = _pythia8.StringPT_swigregister
//StringPT_swigregister(StringPT)
//
//class ColSinglet(_object):
//    """
//The ColSinglet class contains info on an individual singlet.
//Only to be used inside ColConfig, so no private members.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ColSinglet, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, ColSinglet, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_ColSinglet(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def size(self):
//        """
//Size of iParton array.
//"""
//        return _pythia8.ColSinglet_size(self)
//    __swig_setmethods__["iParton"] = _pythia8.ColSinglet_iParton_set
//    __swig_getmethods__["iParton"] = _pythia8.ColSinglet_iParton_get
//    if _newclass:
//        iParton = _swig_property(_pythia8.ColSinglet_iParton_get, _pythia8.ColSinglet_iParton_set)
//    __swig_setmethods__["pSum"] = _pythia8.ColSinglet_pSum_set
//    __swig_getmethods__["pSum"] = _pythia8.ColSinglet_pSum_get
//    if _newclass:
//        pSum = _swig_property(_pythia8.ColSinglet_pSum_get, _pythia8.ColSinglet_pSum_set)
//    __swig_setmethods__["mass"] = _pythia8.ColSinglet_mass_set
//    __swig_getmethods__["mass"] = _pythia8.ColSinglet_mass_get
//    if _newclass:
//        mass = _swig_property(_pythia8.ColSinglet_mass_get, _pythia8.ColSinglet_mass_set)
//    __swig_setmethods__["massExcess"] = _pythia8.ColSinglet_massExcess_set
//    __swig_getmethods__["massExcess"] = _pythia8.ColSinglet_massExcess_get
//    if _newclass:
//        massExcess = _swig_property(_pythia8.ColSinglet_massExcess_get, _pythia8.ColSinglet_massExcess_set)
//    __swig_setmethods__["hasJunction"] = _pythia8.ColSinglet_hasJunction_set
//    __swig_getmethods__["hasJunction"] = _pythia8.ColSinglet_hasJunction_get
//    if _newclass:
//        hasJunction = _swig_property(_pythia8.ColSinglet_hasJunction_get, _pythia8.ColSinglet_hasJunction_set)
//    __swig_setmethods__["isClosed"] = _pythia8.ColSinglet_isClosed_set
//    __swig_getmethods__["isClosed"] = _pythia8.ColSinglet_isClosed_get
//    if _newclass:
//        isClosed = _swig_property(_pythia8.ColSinglet_isClosed_get, _pythia8.ColSinglet_isClosed_set)
//    __swig_setmethods__["isCollected"] = _pythia8.ColSinglet_isCollected_set
//    __swig_getmethods__["isCollected"] = _pythia8.ColSinglet_isCollected_get
//    if _newclass:
//        isCollected = _swig_property(_pythia8.ColSinglet_isCollected_get, _pythia8.ColSinglet_isCollected_set)
//    __swig_destroy__ = _pythia8.delete_ColSinglet
//    __del__ = lambda self: None
//ColSinglet_swigregister = _pythia8.ColSinglet_swigregister
//ColSinglet_swigregister(ColSinglet)
//
//class ColConfig(_object):
//    """
//The ColConfig class describes the colour configuration of the whole event.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ColConfig, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, ColConfig, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ColConfig()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, infoPtrIn, settings, flavSelPtrIn):
//        """
//Initialize and save pointers.
//"""
//        return _pythia8.ColConfig_init(self, infoPtrIn, settings, flavSelPtrIn)
//
//    def size(self):
//        """
//Number of colour singlets.
//"""
//        return _pythia8.ColConfig_size(self)
//
//    def clear(self):
//        """
//Clear contents.
//"""
//        return _pythia8.ColConfig_clear(self)
//
//    def insert(self, iPartonIn, event):
//        """
//Insert a new colour singlet system in ascending mass order.
//Calculate its properties. Join nearby partons.
//"""
//        return _pythia8.ColConfig_insert(self, iPartonIn, event)
//
//    def erase(self, iSub):
//        """
//Erase a colour singlet system. (Rare operation.)
//"""
//        return _pythia8.ColConfig_erase(self, iSub)
//
//    def collect(self, iSub, event, skipTrivial=True):
//        """
//Collect all partons of singlet to be consecutively ordered.
//"""
//        return _pythia8.ColConfig_collect(self, iSub, event, skipTrivial)
//
//    def findSinglet(self, i):
//        """
//Find to which singlet system a particle belongs.
//"""
//        return _pythia8.ColConfig_findSinglet(self, i)
//    __swig_setmethods__["rapPairs"] = _pythia8.ColConfig_rapPairs_set
//    __swig_getmethods__["rapPairs"] = _pythia8.ColConfig_rapPairs_get
//    if _newclass:
//        rapPairs = _swig_property(_pythia8.ColConfig_rapPairs_get, _pythia8.ColConfig_rapPairs_set)
//
//    def __str__(self):
//        return _pythia8.ColConfig___str__(self)
//
//    def __getitem__(self, i):
//        return _pythia8.ColConfig___getitem__(self, i)
//    __swig_destroy__ = _pythia8.delete_ColConfig
//    __del__ = lambda self: None
//ColConfig_swigregister = _pythia8.ColConfig_swigregister
//ColConfig_swigregister(ColConfig)
//
//class StringRegion(_object):
//    """
//The StringRegion class contains the information related to
//one string section in the evolution of a multiparton system.
//Only to be used inside StringFragmentation and MiniStringFragmentation,
//so no private members.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, StringRegion, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, StringRegion, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_StringRegion()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["isSetUp"] = _pythia8.StringRegion_isSetUp_set
//    __swig_getmethods__["isSetUp"] = _pythia8.StringRegion_isSetUp_get
//    if _newclass:
//        isSetUp = _swig_property(_pythia8.StringRegion_isSetUp_get, _pythia8.StringRegion_isSetUp_set)
//    __swig_setmethods__["isEmpty"] = _pythia8.StringRegion_isEmpty_set
//    __swig_getmethods__["isEmpty"] = _pythia8.StringRegion_isEmpty_get
//    if _newclass:
//        isEmpty = _swig_property(_pythia8.StringRegion_isEmpty_get, _pythia8.StringRegion_isEmpty_set)
//    __swig_setmethods__["pPos"] = _pythia8.StringRegion_pPos_set
//    __swig_getmethods__["pPos"] = _pythia8.StringRegion_pPos_get
//    if _newclass:
//        pPos = _swig_property(_pythia8.StringRegion_pPos_get, _pythia8.StringRegion_pPos_set)
//    __swig_setmethods__["pNeg"] = _pythia8.StringRegion_pNeg_set
//    __swig_getmethods__["pNeg"] = _pythia8.StringRegion_pNeg_get
//    if _newclass:
//        pNeg = _swig_property(_pythia8.StringRegion_pNeg_get, _pythia8.StringRegion_pNeg_set)
//    __swig_setmethods__["eX"] = _pythia8.StringRegion_eX_set
//    __swig_getmethods__["eX"] = _pythia8.StringRegion_eX_get
//    if _newclass:
//        eX = _swig_property(_pythia8.StringRegion_eX_get, _pythia8.StringRegion_eX_set)
//    __swig_setmethods__["eY"] = _pythia8.StringRegion_eY_set
//    __swig_getmethods__["eY"] = _pythia8.StringRegion_eY_get
//    if _newclass:
//        eY = _swig_property(_pythia8.StringRegion_eY_get, _pythia8.StringRegion_eY_set)
//    __swig_setmethods__["pPosMass"] = _pythia8.StringRegion_pPosMass_set
//    __swig_getmethods__["pPosMass"] = _pythia8.StringRegion_pPosMass_get
//    if _newclass:
//        pPosMass = _swig_property(_pythia8.StringRegion_pPosMass_get, _pythia8.StringRegion_pPosMass_set)
//    __swig_setmethods__["pNegMass"] = _pythia8.StringRegion_pNegMass_set
//    __swig_getmethods__["pNegMass"] = _pythia8.StringRegion_pNegMass_get
//    if _newclass:
//        pNegMass = _swig_property(_pythia8.StringRegion_pNegMass_get, _pythia8.StringRegion_pNegMass_set)
//    __swig_setmethods__["massOffset"] = _pythia8.StringRegion_massOffset_set
//    __swig_getmethods__["massOffset"] = _pythia8.StringRegion_massOffset_get
//    if _newclass:
//        massOffset = _swig_property(_pythia8.StringRegion_massOffset_get, _pythia8.StringRegion_massOffset_set)
//    __swig_setmethods__["w2"] = _pythia8.StringRegion_w2_set
//    __swig_getmethods__["w2"] = _pythia8.StringRegion_w2_get
//    if _newclass:
//        w2 = _swig_property(_pythia8.StringRegion_w2_get, _pythia8.StringRegion_w2_set)
//    __swig_setmethods__["xPosProj"] = _pythia8.StringRegion_xPosProj_set
//    __swig_getmethods__["xPosProj"] = _pythia8.StringRegion_xPosProj_get
//    if _newclass:
//        xPosProj = _swig_property(_pythia8.StringRegion_xPosProj_get, _pythia8.StringRegion_xPosProj_set)
//    __swig_setmethods__["xNegProj"] = _pythia8.StringRegion_xNegProj_set
//    __swig_getmethods__["xNegProj"] = _pythia8.StringRegion_xNegProj_get
//    if _newclass:
//        xNegProj = _swig_property(_pythia8.StringRegion_xNegProj_get, _pythia8.StringRegion_xNegProj_set)
//    __swig_setmethods__["pxProj"] = _pythia8.StringRegion_pxProj_set
//    __swig_getmethods__["pxProj"] = _pythia8.StringRegion_pxProj_get
//    if _newclass:
//        pxProj = _swig_property(_pythia8.StringRegion_pxProj_get, _pythia8.StringRegion_pxProj_set)
//    __swig_setmethods__["pyProj"] = _pythia8.StringRegion_pyProj_set
//    __swig_getmethods__["pyProj"] = _pythia8.StringRegion_pyProj_get
//    if _newclass:
//        pyProj = _swig_property(_pythia8.StringRegion_pyProj_get, _pythia8.StringRegion_pyProj_set)
//
//    def gluonOffset(self, iSys, event, iPos, iNeg):
//        """
//Constants: could only be changed in the code itself.
//Data members.
//Calculate offset of the region from parton list. Special junction case.
//"""
//        return _pythia8.StringRegion_gluonOffset(self, iSys, event, iPos, iNeg)
//
//    def gluonOffsetJRF(self, iSys, event, iPos, iNeg, MtoJRF):
//        """
//"""
//        return _pythia8.StringRegion_gluonOffsetJRF(self, iSys, event, iPos, iNeg, MtoJRF)
//
//    def massiveOffset(self, iPos, iNeg, iMax, id1, id2, mc, mb):
//        """
//If massive case, the offset of the initial regions is calculated.
//"""
//        return _pythia8.StringRegion_massiveOffset(self, iPos, iNeg, iMax, id1, id2, mc, mb)
//
//    def setUp(self, p1, p2, isMassless=False):
//        """
//Set up four-vectors for longitudinal and transverse directions.
//"""
//        return _pythia8.StringRegion_setUp(self, p1, p2, isMassless)
//
//    def pHad(self, xPosIn, xNegIn, pxIn, pyIn):
//        """
//Construct a four-momentum from (x+, x-, px, py).
//"""
//        return _pythia8.StringRegion_pHad(self, xPosIn, xNegIn, pxIn, pyIn)
//
//    def project(self, *args):
//        """
//"""
//        return _pythia8.StringRegion_project(self, *args)
//
//    def xPos(self):
//        """
//"""
//        return _pythia8.StringRegion_xPos(self)
//
//    def xNeg(self):
//        """
//"""
//        return _pythia8.StringRegion_xNeg(self)
//
//    def px(self):
//        """
//"""
//        return _pythia8.StringRegion_px(self)
//
//    def py(self):
//        """
//"""
//        return _pythia8.StringRegion_py(self)
//    __swig_destroy__ = _pythia8.delete_StringRegion
//    __del__ = lambda self: None
//StringRegion_swigregister = _pythia8.StringRegion_swigregister
//StringRegion_swigregister(StringRegion)
//StringRegion.MJOIN = _pythia8.cvar.StringRegion_MJOIN
//StringRegion.TINY = _pythia8.cvar.StringRegion_TINY
//
//class StringSystem(_object):
//    """
//The StringSystem class contains the complete set of all string regions.
//Only to be used inside StringFragmentation, so no private members.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, StringSystem, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, StringSystem, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_StringSystem()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def setUp(self, iSys, event):
//        """
//Set up system from parton list.
//"""
//        return _pythia8.StringSystem_setUp(self, iSys, event)
//
//    def iReg(self, iPos, iNeg):
//        """
//Calculate string region from (iPos, iNeg) pair.
//"""
//        return _pythia8.StringSystem_iReg(self, iPos, iNeg)
//
//    def region(self, iPos, iNeg):
//        """
//Reference to string region specified by (iPos, iNeg) pair.
//"""
//        return _pythia8.StringSystem_region(self, iPos, iNeg)
//
//    def regionLowPos(self, iPos):
//        """
//Reference to low string region specified either by iPos or iNeg.
//"""
//        return _pythia8.StringSystem_regionLowPos(self, iPos)
//
//    def regionLowNeg(self, iNeg):
//        """
//"""
//        return _pythia8.StringSystem_regionLowNeg(self, iNeg)
//    __swig_setmethods__["system"] = _pythia8.StringSystem_system_set
//    __swig_getmethods__["system"] = _pythia8.StringSystem_system_get
//    if _newclass:
//        system = _swig_property(_pythia8.StringSystem_system_get, _pythia8.StringSystem_system_set)
//    __swig_setmethods__["sizePartons"] = _pythia8.StringSystem_sizePartons_set
//    __swig_getmethods__["sizePartons"] = _pythia8.StringSystem_sizePartons_get
//    if _newclass:
//        sizePartons = _swig_property(_pythia8.StringSystem_sizePartons_get, _pythia8.StringSystem_sizePartons_set)
//    __swig_setmethods__["sizeStrings"] = _pythia8.StringSystem_sizeStrings_set
//    __swig_getmethods__["sizeStrings"] = _pythia8.StringSystem_sizeStrings_get
//    if _newclass:
//        sizeStrings = _swig_property(_pythia8.StringSystem_sizeStrings_get, _pythia8.StringSystem_sizeStrings_set)
//    __swig_setmethods__["sizeRegions"] = _pythia8.StringSystem_sizeRegions_set
//    __swig_getmethods__["sizeRegions"] = _pythia8.StringSystem_sizeRegions_get
//    if _newclass:
//        sizeRegions = _swig_property(_pythia8.StringSystem_sizeRegions_get, _pythia8.StringSystem_sizeRegions_set)
//    __swig_setmethods__["indxReg"] = _pythia8.StringSystem_indxReg_set
//    __swig_getmethods__["indxReg"] = _pythia8.StringSystem_indxReg_get
//    if _newclass:
//        indxReg = _swig_property(_pythia8.StringSystem_indxReg_get, _pythia8.StringSystem_indxReg_set)
//    __swig_setmethods__["iMax"] = _pythia8.StringSystem_iMax_set
//    __swig_getmethods__["iMax"] = _pythia8.StringSystem_iMax_get
//    if _newclass:
//        iMax = _swig_property(_pythia8.StringSystem_iMax_get, _pythia8.StringSystem_iMax_set)
//    __swig_setmethods__["mJoin"] = _pythia8.StringSystem_mJoin_set
//    __swig_getmethods__["mJoin"] = _pythia8.StringSystem_mJoin_get
//    if _newclass:
//        mJoin = _swig_property(_pythia8.StringSystem_mJoin_get, _pythia8.StringSystem_mJoin_set)
//    __swig_setmethods__["m2Join"] = _pythia8.StringSystem_m2Join_set
//    __swig_getmethods__["m2Join"] = _pythia8.StringSystem_m2Join_get
//    if _newclass:
//        m2Join = _swig_property(_pythia8.StringSystem_m2Join_get, _pythia8.StringSystem_m2Join_set)
//    __swig_destroy__ = _pythia8.delete_StringSystem
//    __del__ = lambda self: None
//StringSystem_swigregister = _pythia8.StringSystem_swigregister
//StringSystem_swigregister(StringSystem)
//
//class StringVertex(_object):
//    """
//The StringVertex class contains the space-time vertex location information
//stored during the fragmentation process. No private members.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, StringVertex, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, StringVertex, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_StringVertex(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["fromPos"] = _pythia8.StringVertex_fromPos_set
//    __swig_getmethods__["fromPos"] = _pythia8.StringVertex_fromPos_get
//    if _newclass:
//        fromPos = _swig_property(_pythia8.StringVertex_fromPos_get, _pythia8.StringVertex_fromPos_set)
//    __swig_setmethods__["iRegPos"] = _pythia8.StringVertex_iRegPos_set
//    __swig_getmethods__["iRegPos"] = _pythia8.StringVertex_iRegPos_get
//    if _newclass:
//        iRegPos = _swig_property(_pythia8.StringVertex_iRegPos_get, _pythia8.StringVertex_iRegPos_set)
//    __swig_setmethods__["iRegNeg"] = _pythia8.StringVertex_iRegNeg_set
//    __swig_getmethods__["iRegNeg"] = _pythia8.StringVertex_iRegNeg_get
//    if _newclass:
//        iRegNeg = _swig_property(_pythia8.StringVertex_iRegNeg_get, _pythia8.StringVertex_iRegNeg_set)
//    __swig_setmethods__["xRegPos"] = _pythia8.StringVertex_xRegPos_set
//    __swig_getmethods__["xRegPos"] = _pythia8.StringVertex_xRegPos_get
//    if _newclass:
//        xRegPos = _swig_property(_pythia8.StringVertex_xRegPos_get, _pythia8.StringVertex_xRegPos_set)
//    __swig_setmethods__["xRegNeg"] = _pythia8.StringVertex_xRegNeg_set
//    __swig_getmethods__["xRegNeg"] = _pythia8.StringVertex_xRegNeg_get
//    if _newclass:
//        xRegNeg = _swig_property(_pythia8.StringVertex_xRegNeg_get, _pythia8.StringVertex_xRegNeg_set)
//    __swig_destroy__ = _pythia8.delete_StringVertex
//    __del__ = lambda self: None
//StringVertex_swigregister = _pythia8.StringVertex_swigregister
//StringVertex_swigregister(StringVertex)
//
//class SigmaPartialWave(_object):
//    """
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SigmaPartialWave, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, SigmaPartialWave, name)
//    __repr__ = _swig_repr
//
//    def init(self, arg2, arg3, arg4, arg5, arg6, arg7):
//        """
//Initialisation
//"""
//        return _pythia8.SigmaPartialWave_init(self, arg2, arg3, arg4, arg5, arg6, arg7)
//
//    def readFile(self, arg2, arg3):
//        """
//Read data file
//"""
//        return _pythia8.SigmaPartialWave_readFile(self, arg2, arg3)
//
//    def setSubprocess(self, *args):
//        """
//"""
//        return _pythia8.SigmaPartialWave_setSubprocess(self, *args)
//
//    def sigmaEl(self, Wcm):
//        """
//Return sigma total/elastic, dSigma/dCos(theta)
//"""
//        return _pythia8.SigmaPartialWave_sigmaEl(self, Wcm)
//
//    def sigmaTot(self, Wcm):
//        """
//"""
//        return _pythia8.SigmaPartialWave_sigmaTot(self, Wcm)
//
//    def dSigma(self, Wcm, cTheta):
//        """
//"""
//        return _pythia8.SigmaPartialWave_dSigma(self, Wcm, cTheta)
//
//    def pickCosTheta(self, arg2):
//        """
//Return a cos(theta) value
//"""
//        return _pythia8.SigmaPartialWave_pickCosTheta(self, arg2)
//
//    def getSigmaElMax(self):
//        """
//Return maximum sigma elastic
//"""
//        return _pythia8.SigmaPartialWave_getSigmaElMax(self)
//
//    def __init__(self):
//        this = _pythia8.new_SigmaPartialWave()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_SigmaPartialWave
//    __del__ = lambda self: None
//SigmaPartialWave_swigregister = _pythia8.SigmaPartialWave_swigregister
//SigmaPartialWave_swigregister(SigmaPartialWave)
//
//class HadronScatterPair(_object):
//    """
//HadronScatterPair class
//  Simple class to hold details of a pair of hadrons which will scatter.
//  Stores indices in event record and the measure used for ordering
//Store a pair of indices
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HadronScatterPair, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, HadronScatterPair, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_HadronScatterPair(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def __lt__(self, arg2):
//        return _pythia8.HadronScatterPair___lt__(self, arg2)
//    __swig_setmethods__["i1"] = _pythia8.HadronScatterPair_i1_set
//    __swig_getmethods__["i1"] = _pythia8.HadronScatterPair_i1_get
//    if _newclass:
//        i1 = _swig_property(_pythia8.HadronScatterPair_i1_get, _pythia8.HadronScatterPair_i1_set)
//    __swig_setmethods__["yt1"] = _pythia8.HadronScatterPair_yt1_set
//    __swig_getmethods__["yt1"] = _pythia8.HadronScatterPair_yt1_get
//    if _newclass:
//        yt1 = _swig_property(_pythia8.HadronScatterPair_yt1_get, _pythia8.HadronScatterPair_yt1_set)
//    __swig_setmethods__["pt1"] = _pythia8.HadronScatterPair_pt1_set
//    __swig_getmethods__["pt1"] = _pythia8.HadronScatterPair_pt1_get
//    if _newclass:
//        pt1 = _swig_property(_pythia8.HadronScatterPair_pt1_get, _pythia8.HadronScatterPair_pt1_set)
//    __swig_setmethods__["i2"] = _pythia8.HadronScatterPair_i2_set
//    __swig_getmethods__["i2"] = _pythia8.HadronScatterPair_i2_get
//    if _newclass:
//        i2 = _swig_property(_pythia8.HadronScatterPair_i2_get, _pythia8.HadronScatterPair_i2_set)
//    __swig_setmethods__["yt2"] = _pythia8.HadronScatterPair_yt2_set
//    __swig_getmethods__["yt2"] = _pythia8.HadronScatterPair_yt2_get
//    if _newclass:
//        yt2 = _swig_property(_pythia8.HadronScatterPair_yt2_get, _pythia8.HadronScatterPair_yt2_set)
//    __swig_setmethods__["pt2"] = _pythia8.HadronScatterPair_pt2_set
//    __swig_getmethods__["pt2"] = _pythia8.HadronScatterPair_pt2_get
//    if _newclass:
//        pt2 = _swig_property(_pythia8.HadronScatterPair_pt2_get, _pythia8.HadronScatterPair_pt2_set)
//    __swig_setmethods__["measure"] = _pythia8.HadronScatterPair_measure_set
//    __swig_getmethods__["measure"] = _pythia8.HadronScatterPair_measure_get
//    if _newclass:
//        measure = _swig_property(_pythia8.HadronScatterPair_measure_get, _pythia8.HadronScatterPair_measure_set)
//    __swig_destroy__ = _pythia8.delete_HadronScatterPair
//    __del__ = lambda self: None
//HadronScatterPair_swigregister = _pythia8.HadronScatterPair_swigregister
//HadronScatterPair_swigregister(HadronScatterPair)
//
//class HadronScatter(_object):
//    """
//HadronScatter class
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HadronScatter, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, HadronScatter, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_HadronScatter()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, infoPtrIn, settings, rndmPtrIn, particleDataPtr):
//        """
//Initialisation
//"""
//        return _pythia8.HadronScatter_init(self, infoPtrIn, settings, rndmPtrIn, particleDataPtr)
//
//    def scatter(self, arg2):
//        """
//Perform all hadron scatterings - new version. Collective flow.
//"""
//        return _pythia8.HadronScatter_scatter(self, arg2)
//
//    def scatterOld(self, arg2):
//        """
//Perform all hadron scatterings - old version.
//"""
//        return _pythia8.HadronScatter_scatterOld(self, arg2)
//    __swig_destroy__ = _pythia8.delete_HadronScatter
//    __del__ = lambda self: None
//HadronScatter_swigregister = _pythia8.HadronScatter_swigregister
//HadronScatter_swigregister(HadronScatter)
//
//class Wave4(_object):
//    """
//The Wave4 class provides a class for complex four-vector wave functions.
//The Wave4 class can be multiplied with the GammaMatrix class to allow
//for the writing of helicity matrix elements.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Wave4, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, Wave4, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_Wave4(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_Wave4
//    __del__ = lambda self: None
//
//    def __call__(self, i):
//        return _pythia8.Wave4___call__(self, i)
//
//    def __add__(self, w):
//        return _pythia8.Wave4___add__(self, w)
//
//    def __sub__(self, w):
//        return _pythia8.Wave4___sub__(self, w)
//
//    def __neg__(self):
//        return _pythia8.Wave4___neg__(self)
//
//    def __div__(self, *args):
//        return _pythia8.Wave4___div__(self, *args)
//
//    def __str__(self):
//        return _pythia8.Wave4___str__(self)
//
//    def __rmul__(self, *args):
//        return _pythia8.Wave4___rmul__(self, *args)
//
//    def __mul__(self, *args):
//        return _pythia8.Wave4___mul__(self, *args)
//Wave4_swigregister = _pythia8.Wave4_swigregister
//Wave4_swigregister(Wave4)
//
//
//def conj(w):
//    return _pythia8.conj(w)
//conj = _pythia8.conj
//
//def epsilon(w1, w2, w3):
//    return _pythia8.epsilon(w1, w2, w3)
//epsilon = _pythia8.epsilon
//
//def m2(*args):
//    return _pythia8.m2(*args)
//m2 = _pythia8.m2
//class GammaMatrix(_object):
//    """
//The GammaMatrix class is a special sparse matrix class used to write
//helicity matrix elements in conjuction with the Wave4 class. Note that
//only left to right multplication of Wave4 vectors with the GammaMatrix
//class is allowed. Additionally, subtracting a scalar from a GammaMatrix
//(or subtracting a GammaMatrix from a scalar) subtracts the scalar from
//with the (1 - gamma^5) structure of matrix elements in mind.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, GammaMatrix, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, GammaMatrix, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_GammaMatrix(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_GammaMatrix
//    __del__ = lambda self: None
//
//    def __call__(self, I, J):
//        return _pythia8.GammaMatrix___call__(self, I, J)
//
//    def __mul__(self, s):
//        return _pythia8.GammaMatrix___mul__(self, s)
//
//    def __sub__(self, s):
//        return _pythia8.GammaMatrix___sub__(self, s)
//
//    def __add__(self, s):
//        return _pythia8.GammaMatrix___add__(self, s)
//
//    def __str__(self):
//        return _pythia8.GammaMatrix___str__(self)
//
//    def __rmul__(self, s):
//        return _pythia8.GammaMatrix___rmul__(self, s)
//
//    def __rsub__(self, s):
//        return _pythia8.GammaMatrix___rsub__(self, s)
//
//    def __radd__(self, s):
//        return _pythia8.GammaMatrix___radd__(self, s)
//GammaMatrix_swigregister = _pythia8.GammaMatrix_swigregister
//GammaMatrix_swigregister(GammaMatrix)
//
//
//def __mul__(*args):
//    return _pythia8.__mul__(*args)
//__mul__ = _pythia8.__mul__
//
//def __sub__(*args):
//    return _pythia8.__sub__(*args)
//__sub__ = _pythia8.__sub__
//
//def __add__(*args):
//    return _pythia8.__add__(*args)
//__add__ = _pythia8.__add__
//
//def __lshift__(*args):
//    return _pythia8.__lshift__(*args)
//__lshift__ = _pythia8.__lshift__
//class HelicityParticle(Particle):
//    """
//Helicity particle class containing helicity information, derived from
//particle base class.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Particle]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HelicityParticle, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Particle]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, HelicityParticle, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_HelicityParticle(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def wave(self, h):
//        """
//Methods.
//"""
//        return _pythia8.HelicityParticle_wave(self, h)
//
//    def waveBar(self, h):
//        """
//"""
//        return _pythia8.HelicityParticle_waveBar(self, h)
//
//    def normalize(self, m):
//        """
//"""
//        return _pythia8.HelicityParticle_normalize(self, m)
//
//    def spinStates(self):
//        """
//"""
//        return _pythia8.HelicityParticle_spinStates(self)
//
//    def m(self, *args):
//        """
//"""
//        return _pythia8.HelicityParticle_m(self, *args)
//
//    def index(self, *args):
//        """
//"""
//        return _pythia8.HelicityParticle_index(self, *args)
//    __swig_setmethods__["direction"] = _pythia8.HelicityParticle_direction_set
//    __swig_getmethods__["direction"] = _pythia8.HelicityParticle_direction_get
//    if _newclass:
//        direction = _swig_property(_pythia8.HelicityParticle_direction_get, _pythia8.HelicityParticle_direction_set)
//    __swig_setmethods__["rho"] = _pythia8.HelicityParticle_rho_set
//    __swig_getmethods__["rho"] = _pythia8.HelicityParticle_rho_get
//    if _newclass:
//        rho = _swig_property(_pythia8.HelicityParticle_rho_get, _pythia8.HelicityParticle_rho_set)
//    __swig_setmethods__["D"] = _pythia8.HelicityParticle_D_set
//    __swig_getmethods__["D"] = _pythia8.HelicityParticle_D_get
//    if _newclass:
//        D = _swig_property(_pythia8.HelicityParticle_D_get, _pythia8.HelicityParticle_D_set)
//    __swig_destroy__ = _pythia8.delete_HelicityParticle
//    __del__ = lambda self: None
//HelicityParticle_swigregister = _pythia8.HelicityParticle_swigregister
//HelicityParticle_swigregister(HelicityParticle)
//
//class HelicityMatrixElement(_object):
//    """
//The helicity matrix element class.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HelicityMatrixElement, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, HelicityMatrixElement, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor and destructor.
//"""
//        this = _pythia8.new_HelicityMatrixElement()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HelicityMatrixElement
//    __del__ = lambda self: None
//
//    def initPointers(self, arg2, arg3, arg4=None):
//        """
//Initialize the physics matrices and pointers.
//"""
//        return _pythia8.HelicityMatrixElement_initPointers(self, arg2, arg3, arg4)
//
//    def initChannel(self, arg2):
//        """
//Initialize the channel.
//"""
//        return _pythia8.HelicityMatrixElement_initChannel(self, arg2)
//
//    def decayWeight(self, arg2):
//        """
//Recursive sub-method to calculate the matrix element weight for a decay.
//"""
//        return _pythia8.HelicityMatrixElement_decayWeight(self, arg2)
//
//    def decayWeightMax(self, arg2):
//        """
//Calculate the maximum matrix element decay weight.
//"""
//        return _pythia8.HelicityMatrixElement_decayWeightMax(self, arg2)
//
//    def calculateME(self, arg2):
//        """
//Calculate the helicity matrix element.
//"""
//        return _pythia8.HelicityMatrixElement_calculateME(self, arg2)
//
//    def calculateD(self, arg2):
//        """
//Recursive sub-method to calculate the decay matrix for a particle.
//"""
//        return _pythia8.HelicityMatrixElement_calculateD(self, arg2)
//
//    def calculateRho(self, arg2, arg3):
//        """
//Pointer to particle data.
//Pointer to Standard Model constants.
//Pointer to Settings.
//Recursive sub-method to calculate the density matrix for a particle.
//"""
//        return _pythia8.HelicityMatrixElement_calculateRho(self, arg2, arg3)
//
//    def setFermionLine(self, arg2, arg3, arg4):
//        """
//Set a fermion line.
//"""
//        return _pythia8.HelicityMatrixElement_setFermionLine(self, arg2, arg3, arg4)
//
//    def breitWigner(self, s, M, G):
//        """
//Calculate Breit-Wigner's with running widths and fixed.
//"""
//        return _pythia8.HelicityMatrixElement_breitWigner(self, s, M, G)
//
//    def sBreitWigner(self, m0, m1, s, M, G):
//        """
//"""
//        return _pythia8.HelicityMatrixElement_sBreitWigner(self, m0, m1, s, M, G)
//
//    def pBreitWigner(self, m0, m1, s, M, G):
//        """
//"""
//        return _pythia8.HelicityMatrixElement_pBreitWigner(self, m0, m1, s, M, G)
//
//    def dBreitWigner(self, m0, m1, s, M, G):
//        """
//"""
//        return _pythia8.HelicityMatrixElement_dBreitWigner(self, m0, m1, s, M, G)
//HelicityMatrixElement_swigregister = _pythia8.HelicityMatrixElement_swigregister
//HelicityMatrixElement_swigregister(HelicityMatrixElement)
//
//class HMETwoFermions2W2TwoFermions(HelicityMatrixElement):
//    """
//Helicity matrix element for the hard process of two fermions -> W/W' ->
//two fermions.
//"""
//    __swig_setmethods__ = {}
//    for _s in [HelicityMatrixElement]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HMETwoFermions2W2TwoFermions, name, value)
//    __swig_getmethods__ = {}
//    for _s in [HelicityMatrixElement]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, HMETwoFermions2W2TwoFermions, name)
//    __repr__ = _swig_repr
//
//    def initConstants(self):
//        """
//"""
//        return _pythia8.HMETwoFermions2W2TwoFermions_initConstants(self)
//
//    def initWaves(self, arg2):
//        """
//"""
//        return _pythia8.HMETwoFermions2W2TwoFermions_initWaves(self, arg2)
//
//    def calculateME(self, arg2):
//        """
//"""
//        return _pythia8.HMETwoFermions2W2TwoFermions_calculateME(self, arg2)
//
//    def __init__(self):
//        this = _pythia8.new_HMETwoFermions2W2TwoFermions()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HMETwoFermions2W2TwoFermions
//    __del__ = lambda self: None
//HMETwoFermions2W2TwoFermions_swigregister = _pythia8.HMETwoFermions2W2TwoFermions_swigregister
//HMETwoFermions2W2TwoFermions_swigregister(HMETwoFermions2W2TwoFermions)
//
//class HMETwoFermions2GammaZ2TwoFermions(HelicityMatrixElement):
//    """
//Helicity matrix element for the hard process of two fermions ->
//photon/Z/Z' -> two fermions.
//"""
//    __swig_setmethods__ = {}
//    for _s in [HelicityMatrixElement]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HMETwoFermions2GammaZ2TwoFermions, name, value)
//    __swig_getmethods__ = {}
//    for _s in [HelicityMatrixElement]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, HMETwoFermions2GammaZ2TwoFermions, name)
//    __repr__ = _swig_repr
//
//    def initConstants(self):
//        """
//"""
//        return _pythia8.HMETwoFermions2GammaZ2TwoFermions_initConstants(self)
//
//    def initWaves(self, arg2):
//        """
//"""
//        return _pythia8.HMETwoFermions2GammaZ2TwoFermions_initWaves(self, arg2)
//
//    def calculateME(self, arg2):
//        """
//"""
//        return _pythia8.HMETwoFermions2GammaZ2TwoFermions_calculateME(self, arg2)
//
//    def __init__(self):
//        this = _pythia8.new_HMETwoFermions2GammaZ2TwoFermions()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HMETwoFermions2GammaZ2TwoFermions
//    __del__ = lambda self: None
//HMETwoFermions2GammaZ2TwoFermions_swigregister = _pythia8.HMETwoFermions2GammaZ2TwoFermions_swigregister
//HMETwoFermions2GammaZ2TwoFermions_swigregister(HMETwoFermions2GammaZ2TwoFermions)
//
//class HMEX2TwoFermions(HelicityMatrixElement):
//    """
//Helicity matrix element for the hard process of X -> two fermions.
//"""
//    __swig_setmethods__ = {}
//    for _s in [HelicityMatrixElement]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HMEX2TwoFermions, name, value)
//    __swig_getmethods__ = {}
//    for _s in [HelicityMatrixElement]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, HMEX2TwoFermions, name)
//    __repr__ = _swig_repr
//
//    def initWaves(self, arg2):
//        """
//"""
//        return _pythia8.HMEX2TwoFermions_initWaves(self, arg2)
//
//    def __init__(self):
//        this = _pythia8.new_HMEX2TwoFermions()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HMEX2TwoFermions
//    __del__ = lambda self: None
//HMEX2TwoFermions_swigregister = _pythia8.HMEX2TwoFermions_swigregister
//HMEX2TwoFermions_swigregister(HMEX2TwoFermions)
//
//class HMEW2TwoFermions(HMEX2TwoFermions):
//    """
//Helicity matrix element for the hard process of W/W' -> two fermions.
//"""
//    __swig_setmethods__ = {}
//    for _s in [HMEX2TwoFermions]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HMEW2TwoFermions, name, value)
//    __swig_getmethods__ = {}
//    for _s in [HMEX2TwoFermions]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, HMEW2TwoFermions, name)
//    __repr__ = _swig_repr
//
//    def initConstants(self):
//        """
//"""
//        return _pythia8.HMEW2TwoFermions_initConstants(self)
//
//    def calculateME(self, arg2):
//        """
//"""
//        return _pythia8.HMEW2TwoFermions_calculateME(self, arg2)
//
//    def __init__(self):
//        this = _pythia8.new_HMEW2TwoFermions()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HMEW2TwoFermions
//    __del__ = lambda self: None
//HMEW2TwoFermions_swigregister = _pythia8.HMEW2TwoFermions_swigregister
//HMEW2TwoFermions_swigregister(HMEW2TwoFermions)
//
//class HMEGamma2TwoFermions(HMEX2TwoFermions):
//    """
//Helicity matrix element for the hard process of photon -> two fermions.
//"""
//    __swig_setmethods__ = {}
//    for _s in [HMEX2TwoFermions]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HMEGamma2TwoFermions, name, value)
//    __swig_getmethods__ = {}
//    for _s in [HMEX2TwoFermions]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, HMEGamma2TwoFermions, name)
//    __repr__ = _swig_repr
//
//    def calculateME(self, arg2):
//        """
//"""
//        return _pythia8.HMEGamma2TwoFermions_calculateME(self, arg2)
//
//    def __init__(self):
//        this = _pythia8.new_HMEGamma2TwoFermions()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HMEGamma2TwoFermions
//    __del__ = lambda self: None
//HMEGamma2TwoFermions_swigregister = _pythia8.HMEGamma2TwoFermions_swigregister
//HMEGamma2TwoFermions_swigregister(HMEGamma2TwoFermions)
//
//class HMEZ2TwoFermions(HMEX2TwoFermions):
//    """
//Helicity matrix element for the hard process of Z/Z' -> two fermions.
//"""
//    __swig_setmethods__ = {}
//    for _s in [HMEX2TwoFermions]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HMEZ2TwoFermions, name, value)
//    __swig_getmethods__ = {}
//    for _s in [HMEX2TwoFermions]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, HMEZ2TwoFermions, name)
//    __repr__ = _swig_repr
//
//    def initConstants(self):
//        """
//"""
//        return _pythia8.HMEZ2TwoFermions_initConstants(self)
//
//    def calculateME(self, arg2):
//        """
//"""
//        return _pythia8.HMEZ2TwoFermions_calculateME(self, arg2)
//
//    def __init__(self):
//        this = _pythia8.new_HMEZ2TwoFermions()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HMEZ2TwoFermions
//    __del__ = lambda self: None
//HMEZ2TwoFermions_swigregister = _pythia8.HMEZ2TwoFermions_swigregister
//HMEZ2TwoFermions_swigregister(HMEZ2TwoFermions)
//
//class HMEHiggs2TwoFermions(HelicityMatrixElement):
//    """
//Helicity matrix element for the decay of a Higgs ->  two fermions.
//Because the Higgs is spin zero the Higgs production mechanism is not
//needed for calculating helicity density matrices. However, the CP mixing
//is needed.
//"""
//    __swig_setmethods__ = {}
//    for _s in [HelicityMatrixElement]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HMEHiggs2TwoFermions, name, value)
//    __swig_getmethods__ = {}
//    for _s in [HelicityMatrixElement]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, HMEHiggs2TwoFermions, name)
//    __repr__ = _swig_repr
//
//    def initConstants(self):
//        """
//"""
//        return _pythia8.HMEHiggs2TwoFermions_initConstants(self)
//
//    def initWaves(self, arg2):
//        """
//"""
//        return _pythia8.HMEHiggs2TwoFermions_initWaves(self, arg2)
//
//    def calculateME(self, arg2):
//        """
//"""
//        return _pythia8.HMEHiggs2TwoFermions_calculateME(self, arg2)
//
//    def __init__(self):
//        this = _pythia8.new_HMEHiggs2TwoFermions()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HMEHiggs2TwoFermions
//    __del__ = lambda self: None
//HMEHiggs2TwoFermions_swigregister = _pythia8.HMEHiggs2TwoFermions_swigregister
//HMEHiggs2TwoFermions_swigregister(HMEHiggs2TwoFermions)
//
//class HMETauDecay(HelicityMatrixElement):
//    """
//Base class for all tau decay helicity matrix elements.
//"""
//    __swig_setmethods__ = {}
//    for _s in [HelicityMatrixElement]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HMETauDecay, name, value)
//    __swig_getmethods__ = {}
//    for _s in [HelicityMatrixElement]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, HMETauDecay, name)
//    __repr__ = _swig_repr
//
//    def initWaves(self, arg2):
//        """
//"""
//        return _pythia8.HMETauDecay_initWaves(self, arg2)
//
//    def calculateME(self, arg2):
//        """
//"""
//        return _pythia8.HMETauDecay_calculateME(self, arg2)
//
//    def decayWeightMax(self, arg2):
//        """
//"""
//        return _pythia8.HMETauDecay_decayWeightMax(self, arg2)
//
//    def __init__(self):
//        this = _pythia8.new_HMETauDecay()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HMETauDecay
//    __del__ = lambda self: None
//HMETauDecay_swigregister = _pythia8.HMETauDecay_swigregister
//HMETauDecay_swigregister(HMETauDecay)
//
//class HMETau2Meson(HMETauDecay):
//    """
//Helicity matrix element for a tau decaying into a single scalar meson.
//"""
//    __swig_setmethods__ = {}
//    for _s in [HMETauDecay]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HMETau2Meson, name, value)
//    __swig_getmethods__ = {}
//    for _s in [HMETauDecay]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, HMETau2Meson, name)
//    __repr__ = _swig_repr
//
//    def initConstants(self):
//        """
//"""
//        return _pythia8.HMETau2Meson_initConstants(self)
//
//    def initHadronicCurrent(self, arg2):
//        """
//"""
//        return _pythia8.HMETau2Meson_initHadronicCurrent(self, arg2)
//
//    def __init__(self):
//        this = _pythia8.new_HMETau2Meson()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HMETau2Meson
//    __del__ = lambda self: None
//HMETau2Meson_swigregister = _pythia8.HMETau2Meson_swigregister
//HMETau2Meson_swigregister(HMETau2Meson)
//
//class HMETau2TwoLeptons(HMETauDecay):
//    """
//Helicity matrix element for a tau decaying into two leptons.
//"""
//    __swig_setmethods__ = {}
//    for _s in [HMETauDecay]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HMETau2TwoLeptons, name, value)
//    __swig_getmethods__ = {}
//    for _s in [HMETauDecay]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, HMETau2TwoLeptons, name)
//    __repr__ = _swig_repr
//
//    def initConstants(self):
//        """
//"""
//        return _pythia8.HMETau2TwoLeptons_initConstants(self)
//
//    def initWaves(self, arg2):
//        """
//"""
//        return _pythia8.HMETau2TwoLeptons_initWaves(self, arg2)
//
//    def calculateME(self, arg2):
//        """
//"""
//        return _pythia8.HMETau2TwoLeptons_calculateME(self, arg2)
//
//    def __init__(self):
//        this = _pythia8.new_HMETau2TwoLeptons()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HMETau2TwoLeptons
//    __del__ = lambda self: None
//HMETau2TwoLeptons_swigregister = _pythia8.HMETau2TwoLeptons_swigregister
//HMETau2TwoLeptons_swigregister(HMETau2TwoLeptons)
//
//class HMETau2TwoMesonsViaVector(HMETauDecay):
//    """
//Helicity matrix element for a tau decaying into two mesons through a
//vector meson resonance.
//"""
//    __swig_setmethods__ = {}
//    for _s in [HMETauDecay]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HMETau2TwoMesonsViaVector, name, value)
//    __swig_getmethods__ = {}
//    for _s in [HMETauDecay]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, HMETau2TwoMesonsViaVector, name)
//    __repr__ = _swig_repr
//
//    def initConstants(self):
//        """
//"""
//        return _pythia8.HMETau2TwoMesonsViaVector_initConstants(self)
//
//    def initHadronicCurrent(self, arg2):
//        """
//"""
//        return _pythia8.HMETau2TwoMesonsViaVector_initHadronicCurrent(self, arg2)
//
//    def __init__(self):
//        this = _pythia8.new_HMETau2TwoMesonsViaVector()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HMETau2TwoMesonsViaVector
//    __del__ = lambda self: None
//HMETau2TwoMesonsViaVector_swigregister = _pythia8.HMETau2TwoMesonsViaVector_swigregister
//HMETau2TwoMesonsViaVector_swigregister(HMETau2TwoMesonsViaVector)
//
//class HMETau2TwoMesonsViaVectorScalar(HMETauDecay):
//    """
//Helicity matrix element for a tau decay into two mesons through a vector
//or scalar meson resonance.
//"""
//    __swig_setmethods__ = {}
//    for _s in [HMETauDecay]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HMETau2TwoMesonsViaVectorScalar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [HMETauDecay]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, HMETau2TwoMesonsViaVectorScalar, name)
//    __repr__ = _swig_repr
//
//    def initConstants(self):
//        """
//"""
//        return _pythia8.HMETau2TwoMesonsViaVectorScalar_initConstants(self)
//
//    def initHadronicCurrent(self, arg2):
//        """
//"""
//        return _pythia8.HMETau2TwoMesonsViaVectorScalar_initHadronicCurrent(self, arg2)
//
//    def __init__(self):
//        this = _pythia8.new_HMETau2TwoMesonsViaVectorScalar()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HMETau2TwoMesonsViaVectorScalar
//    __del__ = lambda self: None
//HMETau2TwoMesonsViaVectorScalar_swigregister = _pythia8.HMETau2TwoMesonsViaVectorScalar_swigregister
//HMETau2TwoMesonsViaVectorScalar_swigregister(HMETau2TwoMesonsViaVectorScalar)
//
//class HMETau2ThreeMesons(HMETauDecay):
//    """
//Helicity matrix element for a tau decay into three mesons (base class).
//"""
//    __swig_setmethods__ = {}
//    for _s in [HMETauDecay]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HMETau2ThreeMesons, name, value)
//    __swig_getmethods__ = {}
//    for _s in [HMETauDecay]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, HMETau2ThreeMesons, name)
//    __repr__ = _swig_repr
//
//    def initConstants(self):
//        """
//"""
//        return _pythia8.HMETau2ThreeMesons_initConstants(self)
//
//    def initHadronicCurrent(self, arg2):
//        """
//"""
//        return _pythia8.HMETau2ThreeMesons_initHadronicCurrent(self, arg2)
//
//    def __init__(self):
//        this = _pythia8.new_HMETau2ThreeMesons()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HMETau2ThreeMesons
//    __del__ = lambda self: None
//HMETau2ThreeMesons_swigregister = _pythia8.HMETau2ThreeMesons_swigregister
//HMETau2ThreeMesons_swigregister(HMETau2ThreeMesons)
//
//class HMETau2ThreePions(HMETau2ThreeMesons):
//    """
//Helicity matrix element for a tau decay into three pions.
//"""
//    __swig_setmethods__ = {}
//    for _s in [HMETau2ThreeMesons]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HMETau2ThreePions, name, value)
//    __swig_getmethods__ = {}
//    for _s in [HMETau2ThreeMesons]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, HMETau2ThreePions, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        this = _pythia8.new_HMETau2ThreePions()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HMETau2ThreePions
//    __del__ = lambda self: None
//HMETau2ThreePions_swigregister = _pythia8.HMETau2ThreePions_swigregister
//HMETau2ThreePions_swigregister(HMETau2ThreePions)
//
//class HMETau2ThreeMesonsWithKaons(HMETau2ThreeMesons):
//    """
//Helicity matrix element for a tau decay into three mesons with kaons.
//"""
//    __swig_setmethods__ = {}
//    for _s in [HMETau2ThreeMesons]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HMETau2ThreeMesonsWithKaons, name, value)
//    __swig_getmethods__ = {}
//    for _s in [HMETau2ThreeMesons]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, HMETau2ThreeMesonsWithKaons, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        this = _pythia8.new_HMETau2ThreeMesonsWithKaons()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HMETau2ThreeMesonsWithKaons
//    __del__ = lambda self: None
//HMETau2ThreeMesonsWithKaons_swigregister = _pythia8.HMETau2ThreeMesonsWithKaons_swigregister
//HMETau2ThreeMesonsWithKaons_swigregister(HMETau2ThreeMesonsWithKaons)
//
//class HMETau2ThreeMesonsGeneric(HMETau2ThreeMesons):
//    """
//Helicity matrix element for a tau decay into generic three mesons.
//"""
//    __swig_setmethods__ = {}
//    for _s in [HMETau2ThreeMesons]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HMETau2ThreeMesonsGeneric, name, value)
//    __swig_getmethods__ = {}
//    for _s in [HMETau2ThreeMesons]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, HMETau2ThreeMesonsGeneric, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        this = _pythia8.new_HMETau2ThreeMesonsGeneric()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HMETau2ThreeMesonsGeneric
//    __del__ = lambda self: None
//HMETau2ThreeMesonsGeneric_swigregister = _pythia8.HMETau2ThreeMesonsGeneric_swigregister
//HMETau2ThreeMesonsGeneric_swigregister(HMETau2ThreeMesonsGeneric)
//
//class HMETau2TwoPionsGamma(HMETauDecay):
//    """
//Helicity matrix element for a tau decay into two pions and a photon.
//"""
//    __swig_setmethods__ = {}
//    for _s in [HMETauDecay]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HMETau2TwoPionsGamma, name, value)
//    __swig_getmethods__ = {}
//    for _s in [HMETauDecay]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, HMETau2TwoPionsGamma, name)
//    __repr__ = _swig_repr
//
//    def initConstants(self):
//        """
//"""
//        return _pythia8.HMETau2TwoPionsGamma_initConstants(self)
//
//    def initWaves(self, arg2):
//        """
//"""
//        return _pythia8.HMETau2TwoPionsGamma_initWaves(self, arg2)
//
//    def calculateME(self, arg2):
//        """
//"""
//        return _pythia8.HMETau2TwoPionsGamma_calculateME(self, arg2)
//
//    def __init__(self):
//        this = _pythia8.new_HMETau2TwoPionsGamma()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HMETau2TwoPionsGamma
//    __del__ = lambda self: None
//HMETau2TwoPionsGamma_swigregister = _pythia8.HMETau2TwoPionsGamma_swigregister
//HMETau2TwoPionsGamma_swigregister(HMETau2TwoPionsGamma)
//
//class HMETau2FourPions(HMETauDecay):
//    """
//Helicity matrix element for a tau decay into four pions.
//"""
//    __swig_setmethods__ = {}
//    for _s in [HMETauDecay]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HMETau2FourPions, name, value)
//    __swig_getmethods__ = {}
//    for _s in [HMETauDecay]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, HMETau2FourPions, name)
//    __repr__ = _swig_repr
//
//    def initConstants(self):
//        """
//"""
//        return _pythia8.HMETau2FourPions_initConstants(self)
//
//    def initHadronicCurrent(self, p):
//        """
//"""
//        return _pythia8.HMETau2FourPions_initHadronicCurrent(self, p)
//
//    def __init__(self):
//        this = _pythia8.new_HMETau2FourPions()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HMETau2FourPions
//    __del__ = lambda self: None
//HMETau2FourPions_swigregister = _pythia8.HMETau2FourPions_swigregister
//HMETau2FourPions_swigregister(HMETau2FourPions)
//
//class HMETau2FivePions(HMETauDecay):
//    """
//Helicity matrix element for a tau decaying into five pions.
//"""
//    __swig_setmethods__ = {}
//    for _s in [HMETauDecay]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HMETau2FivePions, name, value)
//    __swig_getmethods__ = {}
//    for _s in [HMETauDecay]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, HMETau2FivePions, name)
//    __repr__ = _swig_repr
//
//    def initConstants(self):
//        """
//"""
//        return _pythia8.HMETau2FivePions_initConstants(self)
//
//    def initHadronicCurrent(self, arg2):
//        """
//"""
//        return _pythia8.HMETau2FivePions_initHadronicCurrent(self, arg2)
//
//    def __init__(self):
//        this = _pythia8.new_HMETau2FivePions()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HMETau2FivePions
//    __del__ = lambda self: None
//HMETau2FivePions_swigregister = _pythia8.HMETau2FivePions_swigregister
//HMETau2FivePions_swigregister(HMETau2FivePions)
//
//class HMETau2PhaseSpace(HMETauDecay):
//    """
//Helicity matrix element for a tau decay into flat phase space.
//"""
//    __swig_setmethods__ = {}
//    for _s in [HMETauDecay]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HMETau2PhaseSpace, name, value)
//    __swig_getmethods__ = {}
//    for _s in [HMETauDecay]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, HMETau2PhaseSpace, name)
//    __repr__ = _swig_repr
//
//    def initWaves(self, arg2):
//        """
//"""
//        return _pythia8.HMETau2PhaseSpace_initWaves(self, arg2)
//
//    def calculateME(self, arg2):
//        """
//"""
//        return _pythia8.HMETau2PhaseSpace_calculateME(self, arg2)
//
//    def calculateD(self, arg2):
//        """
//"""
//        return _pythia8.HMETau2PhaseSpace_calculateD(self, arg2)
//
//    def calculateRho(self, arg2, arg3):
//        """
//"""
//        return _pythia8.HMETau2PhaseSpace_calculateRho(self, arg2, arg3)
//
//    def decayWeight(self, arg2):
//        """
//"""
//        return _pythia8.HMETau2PhaseSpace_decayWeight(self, arg2)
//
//    def decayWeightMax(self, arg2):
//        """
//"""
//        return _pythia8.HMETau2PhaseSpace_decayWeightMax(self, arg2)
//
//    def __init__(self):
//        this = _pythia8.new_HMETau2PhaseSpace()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HMETau2PhaseSpace
//    __del__ = lambda self: None
//HMETau2PhaseSpace_swigregister = _pythia8.HMETau2PhaseSpace_swigregister
//HMETau2PhaseSpace_swigregister(HMETau2PhaseSpace)
//
//class LHAProcess(_object):
//    """
//A class for the processes stored in LHAup.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, LHAProcess, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, LHAProcess, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_LHAProcess(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["idProc"] = _pythia8.LHAProcess_idProc_set
//    __swig_getmethods__["idProc"] = _pythia8.LHAProcess_idProc_get
//    if _newclass:
//        idProc = _swig_property(_pythia8.LHAProcess_idProc_get, _pythia8.LHAProcess_idProc_set)
//    __swig_setmethods__["xSecProc"] = _pythia8.LHAProcess_xSecProc_set
//    __swig_getmethods__["xSecProc"] = _pythia8.LHAProcess_xSecProc_get
//    if _newclass:
//        xSecProc = _swig_property(_pythia8.LHAProcess_xSecProc_get, _pythia8.LHAProcess_xSecProc_set)
//    __swig_setmethods__["xErrProc"] = _pythia8.LHAProcess_xErrProc_set
//    __swig_getmethods__["xErrProc"] = _pythia8.LHAProcess_xErrProc_get
//    if _newclass:
//        xErrProc = _swig_property(_pythia8.LHAProcess_xErrProc_get, _pythia8.LHAProcess_xErrProc_set)
//    __swig_setmethods__["xMaxProc"] = _pythia8.LHAProcess_xMaxProc_set
//    __swig_getmethods__["xMaxProc"] = _pythia8.LHAProcess_xMaxProc_get
//    if _newclass:
//        xMaxProc = _swig_property(_pythia8.LHAProcess_xMaxProc_get, _pythia8.LHAProcess_xMaxProc_set)
//    __swig_destroy__ = _pythia8.delete_LHAProcess
//    __del__ = lambda self: None
//LHAProcess_swigregister = _pythia8.LHAProcess_swigregister
//LHAProcess_swigregister(LHAProcess)
//
//class LHAParticle(_object):
//    """
//A class for the particles stored in LHAup.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, LHAParticle, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, LHAParticle, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_LHAParticle(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["idPart"] = _pythia8.LHAParticle_idPart_set
//    __swig_getmethods__["idPart"] = _pythia8.LHAParticle_idPart_get
//    if _newclass:
//        idPart = _swig_property(_pythia8.LHAParticle_idPart_get, _pythia8.LHAParticle_idPart_set)
//    __swig_setmethods__["statusPart"] = _pythia8.LHAParticle_statusPart_set
//    __swig_getmethods__["statusPart"] = _pythia8.LHAParticle_statusPart_get
//    if _newclass:
//        statusPart = _swig_property(_pythia8.LHAParticle_statusPart_get, _pythia8.LHAParticle_statusPart_set)
//    __swig_setmethods__["mother1Part"] = _pythia8.LHAParticle_mother1Part_set
//    __swig_getmethods__["mother1Part"] = _pythia8.LHAParticle_mother1Part_get
//    if _newclass:
//        mother1Part = _swig_property(_pythia8.LHAParticle_mother1Part_get, _pythia8.LHAParticle_mother1Part_set)
//    __swig_setmethods__["mother2Part"] = _pythia8.LHAParticle_mother2Part_set
//    __swig_getmethods__["mother2Part"] = _pythia8.LHAParticle_mother2Part_get
//    if _newclass:
//        mother2Part = _swig_property(_pythia8.LHAParticle_mother2Part_get, _pythia8.LHAParticle_mother2Part_set)
//    __swig_setmethods__["col1Part"] = _pythia8.LHAParticle_col1Part_set
//    __swig_getmethods__["col1Part"] = _pythia8.LHAParticle_col1Part_get
//    if _newclass:
//        col1Part = _swig_property(_pythia8.LHAParticle_col1Part_get, _pythia8.LHAParticle_col1Part_set)
//    __swig_setmethods__["col2Part"] = _pythia8.LHAParticle_col2Part_set
//    __swig_getmethods__["col2Part"] = _pythia8.LHAParticle_col2Part_get
//    if _newclass:
//        col2Part = _swig_property(_pythia8.LHAParticle_col2Part_get, _pythia8.LHAParticle_col2Part_set)
//    __swig_setmethods__["pxPart"] = _pythia8.LHAParticle_pxPart_set
//    __swig_getmethods__["pxPart"] = _pythia8.LHAParticle_pxPart_get
//    if _newclass:
//        pxPart = _swig_property(_pythia8.LHAParticle_pxPart_get, _pythia8.LHAParticle_pxPart_set)
//    __swig_setmethods__["pyPart"] = _pythia8.LHAParticle_pyPart_set
//    __swig_getmethods__["pyPart"] = _pythia8.LHAParticle_pyPart_get
//    if _newclass:
//        pyPart = _swig_property(_pythia8.LHAParticle_pyPart_get, _pythia8.LHAParticle_pyPart_set)
//    __swig_setmethods__["pzPart"] = _pythia8.LHAParticle_pzPart_set
//    __swig_getmethods__["pzPart"] = _pythia8.LHAParticle_pzPart_get
//    if _newclass:
//        pzPart = _swig_property(_pythia8.LHAParticle_pzPart_get, _pythia8.LHAParticle_pzPart_set)
//    __swig_setmethods__["ePart"] = _pythia8.LHAParticle_ePart_set
//    __swig_getmethods__["ePart"] = _pythia8.LHAParticle_ePart_get
//    if _newclass:
//        ePart = _swig_property(_pythia8.LHAParticle_ePart_get, _pythia8.LHAParticle_ePart_set)
//    __swig_setmethods__["mPart"] = _pythia8.LHAParticle_mPart_set
//    __swig_getmethods__["mPart"] = _pythia8.LHAParticle_mPart_get
//    if _newclass:
//        mPart = _swig_property(_pythia8.LHAParticle_mPart_get, _pythia8.LHAParticle_mPart_set)
//    __swig_setmethods__["tauPart"] = _pythia8.LHAParticle_tauPart_set
//    __swig_getmethods__["tauPart"] = _pythia8.LHAParticle_tauPart_get
//    if _newclass:
//        tauPart = _swig_property(_pythia8.LHAParticle_tauPart_get, _pythia8.LHAParticle_tauPart_set)
//    __swig_setmethods__["spinPart"] = _pythia8.LHAParticle_spinPart_set
//    __swig_getmethods__["spinPart"] = _pythia8.LHAParticle_spinPart_get
//    if _newclass:
//        spinPart = _swig_property(_pythia8.LHAParticle_spinPart_get, _pythia8.LHAParticle_spinPart_set)
//    __swig_setmethods__["scalePart"] = _pythia8.LHAParticle_scalePart_set
//    __swig_getmethods__["scalePart"] = _pythia8.LHAParticle_scalePart_get
//    if _newclass:
//        scalePart = _swig_property(_pythia8.LHAParticle_scalePart_get, _pythia8.LHAParticle_scalePart_set)
//    __swig_destroy__ = _pythia8.delete_LHAParticle
//    __del__ = lambda self: None
//LHAParticle_swigregister = _pythia8.LHAParticle_swigregister
//LHAParticle_swigregister(LHAParticle)
//
//class LHAup(_object):
//    """
//LHAup is base class for initialization and event information
//from an external parton-level generator.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, LHAup, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, LHAup, name)
//    __repr__ = _swig_repr
//    __swig_destroy__ = _pythia8.delete_LHAup
//    __del__ = lambda self: None
//
//    def setPtr(self, infoPtrIn):
//        """
//Set info pointer.
//"""
//        return _pythia8.LHAup_setPtr(self, infoPtrIn)
//
//    def newEventFile(self, arg0):
//        """
//Method to be used for LHAupLHEF derived class.
//"""
//        return _pythia8.LHAup_newEventFile(self, arg0)
//
//    def fileFound(self):
//        """
//"""
//        return _pythia8.LHAup_fileFound(self)
//
//    def useExternal(self):
//        """
//"""
//        return _pythia8.LHAup_useExternal(self)
//
//    def setInit(self):
//        """
//A pure virtual method setInit, wherein all initialization information
//is supposed to be set in the derived class. Can do this by reading a
//file or some other way, as desired. Returns false if it did not work.
//"""
//        return _pythia8.LHAup_setInit(self)
//
//    def idBeamA(self):
//        """
//Give back info on beams.
//"""
//        return _pythia8.LHAup_idBeamA(self)
//
//    def idBeamB(self):
//        """
//"""
//        return _pythia8.LHAup_idBeamB(self)
//
//    def eBeamA(self):
//        """
//"""
//        return _pythia8.LHAup_eBeamA(self)
//
//    def eBeamB(self):
//        """
//"""
//        return _pythia8.LHAup_eBeamB(self)
//
//    def pdfGroupBeamA(self):
//        """
//"""
//        return _pythia8.LHAup_pdfGroupBeamA(self)
//
//    def pdfGroupBeamB(self):
//        """
//"""
//        return _pythia8.LHAup_pdfGroupBeamB(self)
//
//    def pdfSetBeamA(self):
//        """
//"""
//        return _pythia8.LHAup_pdfSetBeamA(self)
//
//    def pdfSetBeamB(self):
//        """
//"""
//        return _pythia8.LHAup_pdfSetBeamB(self)
//
//    def strategy(self):
//        """
//Give back weight strategy.
//"""
//        return _pythia8.LHAup_strategy(self)
//
//    def sizeProc(self):
//        """
//Give back info on processes.
//"""
//        return _pythia8.LHAup_sizeProc(self)
//
//    def xSec(self, proc):
//        """
//"""
//        return _pythia8.LHAup_xSec(self, proc)
//
//    def xErr(self, proc):
//        """
//"""
//        return _pythia8.LHAup_xErr(self, proc)
//
//    def xMax(self, proc):
//        """
//"""
//        return _pythia8.LHAup_xMax(self, proc)
//
//    def xSecSum(self):
//        """
//"""
//        return _pythia8.LHAup_xSecSum(self)
//
//    def xErrSum(self):
//        """
//"""
//        return _pythia8.LHAup_xErrSum(self)
//
//    def listInit(self):
//        """
//Print the initialization info; useful to check that setting it worked.
//"""
//        return _pythia8.LHAup_listInit(self)
//
//    def setEvent(self, idProcIn=0):
//        """
//A pure virtual method setEvent, wherein information on the next event
//is supposed to be set in the derived class.
//Strategies +-1 and +-2: idProcIn is the process type, selected by PYTHIA.
//Strategies +-3 and +-4: idProcIn is dummy; process choice is made locally.
//The method can find the next event by a runtime interface to another
//program, or by reading a file, as desired.
//The method should return false if it did not work.
//"""
//        return _pythia8.LHAup_setEvent(self, idProcIn)
//
//    def idProcess(self, *args):
//        """
//Give back process number, weight, scale, alpha_em, alpha_s.
//"""
//        return _pythia8.LHAup_idProcess(self, *args)
//
//    def weight(self):
//        """
//"""
//        return _pythia8.LHAup_weight(self)
//
//    def alphaQED(self):
//        """
//"""
//        return _pythia8.LHAup_alphaQED(self)
//
//    def alphaQCD(self):
//        """
//"""
//        return _pythia8.LHAup_alphaQCD(self)
//
//    def sizePart(self):
//        """
//Give back info on separate particle.
//"""
//        return _pythia8.LHAup_sizePart(self)
//
//    def id(self, part):
//        """
//"""
//        return _pythia8.LHAup_id(self, part)
//
//    def status(self, part):
//        """
//"""
//        return _pythia8.LHAup_status(self, part)
//
//    def mother1(self, part):
//        """
//"""
//        return _pythia8.LHAup_mother1(self, part)
//
//    def mother2(self, part):
//        """
//"""
//        return _pythia8.LHAup_mother2(self, part)
//
//    def col1(self, part):
//        """
//"""
//        return _pythia8.LHAup_col1(self, part)
//
//    def col2(self, part):
//        """
//"""
//        return _pythia8.LHAup_col2(self, part)
//
//    def px(self, part):
//        """
//"""
//        return _pythia8.LHAup_px(self, part)
//
//    def py(self, part):
//        """
//"""
//        return _pythia8.LHAup_py(self, part)
//
//    def pz(self, part):
//        """
//"""
//        return _pythia8.LHAup_pz(self, part)
//
//    def e(self, part):
//        """
//"""
//        return _pythia8.LHAup_e(self, part)
//
//    def m(self, part):
//        """
//"""
//        return _pythia8.LHAup_m(self, part)
//
//    def tau(self, part):
//        """
//"""
//        return _pythia8.LHAup_tau(self, part)
//
//    def spin(self, part):
//        """
//"""
//        return _pythia8.LHAup_spin(self, part)
//
//    def scale(self, *args):
//        """
//"""
//        return _pythia8.LHAup_scale(self, *args)
//
//    def id1(self):
//        """
//Give back info on flavour and x values of hard-process initiators.
//"""
//        return _pythia8.LHAup_id1(self)
//
//    def id2(self):
//        """
//"""
//        return _pythia8.LHAup_id2(self)
//
//    def x1(self):
//        """
//"""
//        return _pythia8.LHAup_x1(self)
//
//    def x2(self):
//        """
//"""
//        return _pythia8.LHAup_x2(self)
//
//    def pdfIsSet(self):
//        """
//Optional: give back info on parton density values of event.
//"""
//        return _pythia8.LHAup_pdfIsSet(self)
//
//    def id1pdf(self):
//        """
//"""
//        return _pythia8.LHAup_id1pdf(self)
//
//    def id2pdf(self):
//        """
//"""
//        return _pythia8.LHAup_id2pdf(self)
//
//    def x1pdf(self):
//        """
//"""
//        return _pythia8.LHAup_x1pdf(self)
//
//    def x2pdf(self):
//        """
//"""
//        return _pythia8.LHAup_x2pdf(self)
//
//    def scalePDF(self):
//        """
//"""
//        return _pythia8.LHAup_scalePDF(self)
//
//    def pdf1(self):
//        """
//"""
//        return _pythia8.LHAup_pdf1(self)
//
//    def pdf2(self):
//        """
//"""
//        return _pythia8.LHAup_pdf2(self)
//
//    def listEvent(self):
//        """
//Print the info; useful to check that reading an event worked.
//"""
//        return _pythia8.LHAup_listEvent(self)
//
//    def skipEvent(self, nSkip):
//        """
//Skip ahead a number of events, which are not considered further.
//Mainly intended for debug when using the LHAupLHEF class.
//"""
//        return _pythia8.LHAup_skipEvent(self, nSkip)
//
//    def openLHEF(self, fileNameIn):
//        """
//Four routines to write a Les Houches Event file in steps.
//"""
//        return _pythia8.LHAup_openLHEF(self, fileNameIn)
//
//    def closeLHEF(self, updateInit=False):
//        """
//"""
//        return _pythia8.LHAup_closeLHEF(self, updateInit)
//
//    def initLHEF(self):
//        """
//"""
//        return _pythia8.LHAup_initLHEF(self)
//
//    def eventLHEF(self, verbose=True):
//        """
//"""
//        return _pythia8.LHAup_eventLHEF(self, verbose)
//
//    def getFileName(self):
//        """
//Get access to the Les Houches Event file name.
//"""
//        return _pythia8.LHAup_getFileName(self)
//
//    def __init__(self, strategyIn=3):
//        """
//Constructor. Sets default to be that events come with unit weight.
//"""
//        if self.__class__ == LHAup:
//            _self = None
//        else:
//            _self = self
//        this = _pythia8.new_LHAup(_self, strategyIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["infoPtr"] = _pythia8.LHAup_infoPtr_set
//    __swig_getmethods__["infoPtr"] = _pythia8.LHAup_infoPtr_get
//    if _newclass:
//        infoPtr = _swig_property(_pythia8.LHAup_infoPtr_get, _pythia8.LHAup_infoPtr_set)
//
//    def setBeamA(self, idIn, eIn, pdfGroupIn=0, pdfSetIn=0):
//        """
//Allow conversion from mb to pb.
//Pointer to various information on the generation.
//Input beam info.
//"""
//        return _pythia8.LHAup_setBeamA(self, idIn, eIn, pdfGroupIn, pdfSetIn)
//
//    def setBeamB(self, idIn, eIn, pdfGroupIn=0, pdfSetIn=0):
//        """
//"""
//        return _pythia8.LHAup_setBeamB(self, idIn, eIn, pdfGroupIn, pdfSetIn)
//
//    def setStrategy(self, strategyIn):
//        """
//Input process weight strategy.
//"""
//        return _pythia8.LHAup_setStrategy(self, strategyIn)
//
//    def addProcess(self, idProcIn, xSecIn=1., xErrIn=0., xMaxIn=1.):
//        """
//Input process info.
//"""
//        return _pythia8.LHAup_addProcess(self, idProcIn, xSecIn, xErrIn, xMaxIn)
//
//    def setXSec(self, iP, xSecIn):
//        """
//Possibility to update some cross section info at end of run.
//"""
//        return _pythia8.LHAup_setXSec(self, iP, xSecIn)
//
//    def setXErr(self, iP, xErrIn):
//        """
//"""
//        return _pythia8.LHAup_setXErr(self, iP, xErrIn)
//
//    def setXMax(self, iP, xMaxIn):
//        """
//"""
//        return _pythia8.LHAup_setXMax(self, iP, xMaxIn)
//
//    def setProcess(self, idProcIn=0, weightIn=1., scaleIn=0., alphaQEDIn=0.0073, alphaQCDIn=0.12):
//        """
//Input info on the selected process.
//"""
//        return _pythia8.LHAup_setProcess(self, idProcIn, weightIn, scaleIn, alphaQEDIn, alphaQCDIn)
//
//    def addParticle(self, *args):
//        """
//"""
//        return _pythia8.LHAup_addParticle(self, *args)
//
//    def setIdX(self, id1In, id2In, x1In, x2In):
//        """
//Input info on flavour and x values of hard-process initiators.
//"""
//        return _pythia8.LHAup_setIdX(self, id1In, id2In, x1In, x2In)
//
//    def setPdf(self, id1pdfIn, id2pdfIn, x1pdfIn, x2pdfIn, scalePDFIn, pdf1In, pdf2In, pdfIsSetIn):
//        """
//Optionally input info on parton density values of event.
//"""
//        return _pythia8.LHAup_setPdf(self, id1pdfIn, id2pdfIn, x1pdfIn, x2pdfIn, scalePDFIn, pdf1In, pdf2In, pdfIsSetIn)
//
//    def setInitLHEF(self, arg2, readHeaders=False):
//        """
//Three routines for LHEF files, but put here for flexibility.
//"""
//        return _pythia8.LHAup_setInitLHEF(self, arg2, readHeaders)
//
//    def setNewEventLHEF(self, arg2):
//        """
//"""
//        return _pythia8.LHAup_setNewEventLHEF(self, arg2)
//
//    def setOldEventLHEF(self):
//        """
//"""
//        return _pythia8.LHAup_setOldEventLHEF(self)
//
//    def openFile(self, fn, ifs):
//        """
//Helper routines to open and close a file handling GZIPSUPPORT:
//  ifstream ifs;
//  istream *is = openFile("myFile.txt", ifs);
//  -- Process file using is --
//  closeFile(is, ifs);
//"""
//        return _pythia8.LHAup_openFile(self, fn, ifs)
//
//    def closeFile(self, arg2, ifs):
//        """
//"""
//        return _pythia8.LHAup_closeFile(self, arg2, ifs)
//
//    def setInfoHeader(self, key, val):
//        """
//LHAup is a friend class to infoPtr, but derived classes
//are not. This wrapper function can be used by derived classes
//to set headers in the Info class.
//"""
//        return _pythia8.LHAup_setInfoHeader(self, key, val)
//    __swig_setmethods__["nupSave"] = _pythia8.LHAup_nupSave_set
//    __swig_getmethods__["nupSave"] = _pythia8.LHAup_nupSave_get
//    if _newclass:
//        nupSave = _swig_property(_pythia8.LHAup_nupSave_get, _pythia8.LHAup_nupSave_set)
//    __swig_setmethods__["idprupSave"] = _pythia8.LHAup_idprupSave_set
//    __swig_getmethods__["idprupSave"] = _pythia8.LHAup_idprupSave_get
//    if _newclass:
//        idprupSave = _swig_property(_pythia8.LHAup_idprupSave_get, _pythia8.LHAup_idprupSave_set)
//    __swig_setmethods__["xwgtupSave"] = _pythia8.LHAup_xwgtupSave_set
//    __swig_getmethods__["xwgtupSave"] = _pythia8.LHAup_xwgtupSave_get
//    if _newclass:
//        xwgtupSave = _swig_property(_pythia8.LHAup_xwgtupSave_get, _pythia8.LHAup_xwgtupSave_set)
//    __swig_setmethods__["scalupSave"] = _pythia8.LHAup_scalupSave_set
//    __swig_getmethods__["scalupSave"] = _pythia8.LHAup_scalupSave_get
//    if _newclass:
//        scalupSave = _swig_property(_pythia8.LHAup_scalupSave_get, _pythia8.LHAup_scalupSave_set)
//    __swig_setmethods__["aqedupSave"] = _pythia8.LHAup_aqedupSave_set
//    __swig_getmethods__["aqedupSave"] = _pythia8.LHAup_aqedupSave_get
//    if _newclass:
//        aqedupSave = _swig_property(_pythia8.LHAup_aqedupSave_get, _pythia8.LHAup_aqedupSave_set)
//    __swig_setmethods__["aqcdupSave"] = _pythia8.LHAup_aqcdupSave_set
//    __swig_getmethods__["aqcdupSave"] = _pythia8.LHAup_aqcdupSave_get
//    if _newclass:
//        aqcdupSave = _swig_property(_pythia8.LHAup_aqcdupSave_get, _pythia8.LHAup_aqcdupSave_set)
//    __swig_setmethods__["xSecSumSave"] = _pythia8.LHAup_xSecSumSave_set
//    __swig_getmethods__["xSecSumSave"] = _pythia8.LHAup_xSecSumSave_get
//    if _newclass:
//        xSecSumSave = _swig_property(_pythia8.LHAup_xSecSumSave_get, _pythia8.LHAup_xSecSumSave_set)
//    __swig_setmethods__["xErrSumSave"] = _pythia8.LHAup_xErrSumSave_set
//    __swig_getmethods__["xErrSumSave"] = _pythia8.LHAup_xErrSumSave_get
//    if _newclass:
//        xErrSumSave = _swig_property(_pythia8.LHAup_xErrSumSave_get, _pythia8.LHAup_xErrSumSave_set)
//    __swig_setmethods__["particlesSave"] = _pythia8.LHAup_particlesSave_set
//    __swig_getmethods__["particlesSave"] = _pythia8.LHAup_particlesSave_get
//    if _newclass:
//        particlesSave = _swig_property(_pythia8.LHAup_particlesSave_get, _pythia8.LHAup_particlesSave_set)
//    __swig_setmethods__["getPDFSave"] = _pythia8.LHAup_getPDFSave_set
//    __swig_getmethods__["getPDFSave"] = _pythia8.LHAup_getPDFSave_get
//    if _newclass:
//        getPDFSave = _swig_property(_pythia8.LHAup_getPDFSave_get, _pythia8.LHAup_getPDFSave_set)
//    __swig_setmethods__["getScale"] = _pythia8.LHAup_getScale_set
//    __swig_getmethods__["getScale"] = _pythia8.LHAup_getScale_get
//    if _newclass:
//        getScale = _swig_property(_pythia8.LHAup_getScale_get, _pythia8.LHAup_getScale_set)
//    __swig_setmethods__["id1InSave"] = _pythia8.LHAup_id1InSave_set
//    __swig_getmethods__["id1InSave"] = _pythia8.LHAup_id1InSave_get
//    if _newclass:
//        id1InSave = _swig_property(_pythia8.LHAup_id1InSave_get, _pythia8.LHAup_id1InSave_set)
//    __swig_setmethods__["id2InSave"] = _pythia8.LHAup_id2InSave_set
//    __swig_getmethods__["id2InSave"] = _pythia8.LHAup_id2InSave_get
//    if _newclass:
//        id2InSave = _swig_property(_pythia8.LHAup_id2InSave_get, _pythia8.LHAup_id2InSave_set)
//    __swig_setmethods__["id1pdfInSave"] = _pythia8.LHAup_id1pdfInSave_set
//    __swig_getmethods__["id1pdfInSave"] = _pythia8.LHAup_id1pdfInSave_get
//    if _newclass:
//        id1pdfInSave = _swig_property(_pythia8.LHAup_id1pdfInSave_get, _pythia8.LHAup_id1pdfInSave_set)
//    __swig_setmethods__["id2pdfInSave"] = _pythia8.LHAup_id2pdfInSave_set
//    __swig_getmethods__["id2pdfInSave"] = _pythia8.LHAup_id2pdfInSave_get
//    if _newclass:
//        id2pdfInSave = _swig_property(_pythia8.LHAup_id2pdfInSave_get, _pythia8.LHAup_id2pdfInSave_set)
//    __swig_setmethods__["x1InSave"] = _pythia8.LHAup_x1InSave_set
//    __swig_getmethods__["x1InSave"] = _pythia8.LHAup_x1InSave_get
//    if _newclass:
//        x1InSave = _swig_property(_pythia8.LHAup_x1InSave_get, _pythia8.LHAup_x1InSave_set)
//    __swig_setmethods__["x2InSave"] = _pythia8.LHAup_x2InSave_set
//    __swig_getmethods__["x2InSave"] = _pythia8.LHAup_x2InSave_get
//    if _newclass:
//        x2InSave = _swig_property(_pythia8.LHAup_x2InSave_get, _pythia8.LHAup_x2InSave_set)
//    __swig_setmethods__["x1pdfInSave"] = _pythia8.LHAup_x1pdfInSave_set
//    __swig_getmethods__["x1pdfInSave"] = _pythia8.LHAup_x1pdfInSave_get
//    if _newclass:
//        x1pdfInSave = _swig_property(_pythia8.LHAup_x1pdfInSave_get, _pythia8.LHAup_x1pdfInSave_set)
//    __swig_setmethods__["x2pdfInSave"] = _pythia8.LHAup_x2pdfInSave_set
//    __swig_getmethods__["x2pdfInSave"] = _pythia8.LHAup_x2pdfInSave_get
//    if _newclass:
//        x2pdfInSave = _swig_property(_pythia8.LHAup_x2pdfInSave_get, _pythia8.LHAup_x2pdfInSave_set)
//    __swig_setmethods__["scalePDFInSave"] = _pythia8.LHAup_scalePDFInSave_set
//    __swig_getmethods__["scalePDFInSave"] = _pythia8.LHAup_scalePDFInSave_get
//    if _newclass:
//        scalePDFInSave = _swig_property(_pythia8.LHAup_scalePDFInSave_get, _pythia8.LHAup_scalePDFInSave_set)
//    __swig_setmethods__["pdf1InSave"] = _pythia8.LHAup_pdf1InSave_set
//    __swig_getmethods__["pdf1InSave"] = _pythia8.LHAup_pdf1InSave_get
//    if _newclass:
//        pdf1InSave = _swig_property(_pythia8.LHAup_pdf1InSave_get, _pythia8.LHAup_pdf1InSave_set)
//    __swig_setmethods__["pdf2InSave"] = _pythia8.LHAup_pdf2InSave_set
//    __swig_getmethods__["pdf2InSave"] = _pythia8.LHAup_pdf2InSave_get
//    if _newclass:
//        pdf2InSave = _swig_property(_pythia8.LHAup_pdf2InSave_get, _pythia8.LHAup_pdf2InSave_set)
//    __swig_setmethods__["fileName"] = _pythia8.LHAup_fileName_set
//    __swig_getmethods__["fileName"] = _pythia8.LHAup_fileName_get
//    if _newclass:
//        fileName = _swig_property(_pythia8.LHAup_fileName_get, _pythia8.LHAup_fileName_set)
//    __swig_setmethods__["dateNow"] = _pythia8.LHAup_dateNow_set
//    __swig_getmethods__["dateNow"] = _pythia8.LHAup_dateNow_get
//    if _newclass:
//        dateNow = _swig_property(_pythia8.LHAup_dateNow_get, _pythia8.LHAup_dateNow_set)
//    __swig_setmethods__["timeNow"] = _pythia8.LHAup_timeNow_set
//    __swig_getmethods__["timeNow"] = _pythia8.LHAup_timeNow_get
//    if _newclass:
//        timeNow = _swig_property(_pythia8.LHAup_timeNow_get, _pythia8.LHAup_timeNow_set)
//    def __disown__(self):
//        self.this.disown()
//        _pythia8.disown_LHAup(self)
//        return weakref_proxy(self)
//LHAup_swigregister = _pythia8.LHAup_swigregister
//LHAup_swigregister(LHAup)
//LHAup.CONVERTMB2PB = _pythia8.cvar.LHAup_CONVERTMB2PB
//
//class LHAupLHEF(LHAup):
//    """
//A derived class with information read from a Les Houches Event File.
//"""
//    __swig_setmethods__ = {}
//    for _s in [LHAup]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, LHAupLHEF, name, value)
//    __swig_getmethods__ = {}
//    for _s in [LHAup]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, LHAupLHEF, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_LHAupLHEF(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_LHAupLHEF
//    __del__ = lambda self: None
//
//    def closeAllFiles(self):
//        """
//Close files and then open new file.
//"""
//        return _pythia8.LHAupLHEF_closeAllFiles(self)
//
//    def newEventFile(self, filenameIn):
//        """
//Want to use new file with events, but without reinitialization.
//"""
//        return _pythia8.LHAupLHEF_newEventFile(self, filenameIn)
//
//    def fileFound(self):
//        """
//Set isHead to is to keep expected behaviour in
//fileFound() and closeAllFiles().
//Confirm that file was found and opened as expected.
//"""
//        return _pythia8.LHAupLHEF_fileFound(self)
//
//    def useExternal(self):
//        """
//"""
//        return _pythia8.LHAupLHEF_useExternal(self)
//
//    def setInit(self):
//        """
//Routine for doing the job of reading and setting initialization info.
//"""
//        return _pythia8.LHAupLHEF_setInit(self)
//
//    def setInitLHEF(self, isIn, readHead):
//        """
//Routine for doing the job of reading and setting initialization info.
//"""
//        return _pythia8.LHAupLHEF_setInitLHEF(self, isIn, readHead)
//
//    def setEvent(self, arg2=0):
//        """
//Routine for doing the job of reading and setting info on next event.
//"""
//        return _pythia8.LHAupLHEF_setEvent(self, arg2)
//
//    def skipEvent(self, nSkip):
//        """
//Skip ahead a number of events, which are not considered further.
//"""
//        return _pythia8.LHAupLHEF_skipEvent(self, nSkip)
//
//    def setNewEventLHEF(self):
//        """
//Routine for doing the job of reading and setting info on next event.
//"""
//        return _pythia8.LHAupLHEF_setNewEventLHEF(self)
//
//    def updateSigma(self):
//        """
//Update cross-section information at the end of the run.
//"""
//        return _pythia8.LHAupLHEF_updateSigma(self)
//LHAupLHEF_swigregister = _pythia8.LHAupLHEF_swigregister
//LHAupLHEF_swigregister(LHAupLHEF)
//
//class LHAupFromPYTHIA8(LHAup):
//    """
//A derived class with information read from PYTHIA 8 itself, for output.
//"""
//    __swig_setmethods__ = {}
//    for _s in [LHAup]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, LHAupFromPYTHIA8, name, value)
//    __swig_getmethods__ = {}
//    for _s in [LHAup]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, LHAupFromPYTHIA8, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, processPtrIn, infoPtrIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_LHAupFromPYTHIA8(processPtrIn, infoPtrIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_LHAupFromPYTHIA8
//    __del__ = lambda self: None
//
//    def setInit(self):
//        """
//Routine for doing the job of reading and setting initialization info.
//"""
//        return _pythia8.LHAupFromPYTHIA8_setInit(self)
//
//    def setEvent(self, arg2=0):
//        """
//Routine for doing the job of reading and setting info on next event.
//"""
//        return _pythia8.LHAupFromPYTHIA8_setEvent(self, arg2)
//
//    def updateSigma(self):
//        """
//Update cross-section information at the end of the run.
//"""
//        return _pythia8.LHAupFromPYTHIA8_updateSigma(self)
//LHAupFromPYTHIA8_swigregister = _pythia8.LHAupFromPYTHIA8_swigregister
//LHAupFromPYTHIA8_swigregister(LHAupFromPYTHIA8)
//
//class LHEF3FromPythia8(LHAup):
//    """
//A derived class with LHEF 3.0 information read from PYTHIA 8 itself, for
//output.
//"""
//    __swig_setmethods__ = {}
//    for _s in [LHAup]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, LHEF3FromPythia8, name, value)
//    __swig_getmethods__ = {}
//    for _s in [LHAup]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, LHEF3FromPythia8, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, eventPtrIn, settingsPtrIn, infoPtrIn, particleDataPtrIn, pDigitsIn=15, writeToFileIn=True):
//        """
//Constructor.
//"""
//        this = _pythia8.new_LHEF3FromPythia8(eventPtrIn, settingsPtrIn, infoPtrIn, particleDataPtrIn, pDigitsIn, writeToFileIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def setInit(self):
//        """
//Routine for reading, setting and printing the initialisation info.
//"""
//        return _pythia8.LHEF3FromPythia8_setInit(self)
//
//    def setEventPtr(self, evPtr):
//        """
//Routine for reading, setting and printing the next event.
//"""
//        return _pythia8.LHEF3FromPythia8_setEventPtr(self, evPtr)
//
//    def setEvent(self, arg2=0):
//        """
//"""
//        return _pythia8.LHEF3FromPythia8_setEvent(self, arg2)
//
//    def getEventString(self):
//        """
//"""
//        return _pythia8.LHEF3FromPythia8_getEventString(self)
//
//    def openLHEF(self, fileNameIn):
//        """
//Function to open the output file.
//"""
//        return _pythia8.LHEF3FromPythia8_openLHEF(self, fileNameIn)
//
//    def closeLHEF(self, updateInit=False):
//        """
//Function to close (and possibly update) the output file.
//"""
//        return _pythia8.LHEF3FromPythia8_closeLHEF(self, updateInit)
//    __swig_destroy__ = _pythia8.delete_LHEF3FromPythia8
//    __del__ = lambda self: None
//LHEF3FromPythia8_swigregister = _pythia8.LHEF3FromPythia8_swigregister
//LHEF3FromPythia8_swigregister(LHEF3FromPythia8)
//
//class MiniStringFragmentation(_object):
//    """
//The MiniStringFragmentation class contains the routines to fragment
//occasional low-mass colour singlet partonic systems, where the string
//approach is not directly applicable (for technical reasons).
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, MiniStringFragmentation, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, MiniStringFragmentation, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_MiniStringFragmentation()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, infoPtrIn, settings, particleDataPtrIn, rndmPtrIn, flavSelPtrIn, pTSelPtrIn, zSelPtrIn):
//        """
//Initialize and save pointers.
//"""
//        return _pythia8.MiniStringFragmentation_init(self, infoPtrIn, settings, particleDataPtrIn, rndmPtrIn, flavSelPtrIn, pTSelPtrIn, zSelPtrIn)
//
//    def fragment(self, iSub, colConfig, event, isDiff=False):
//        """
//Do the fragmentation: driver routine.
//"""
//        return _pythia8.MiniStringFragmentation_fragment(self, iSub, colConfig, event, isDiff)
//    __swig_destroy__ = _pythia8.delete_MiniStringFragmentation
//    __del__ = lambda self: None
//MiniStringFragmentation_swigregister = _pythia8.MiniStringFragmentation_swigregister
//MiniStringFragmentation_swigregister(MiniStringFragmentation)
//
//class PartonVertex(_object):
//    """
//List of all separate partonic subsystems.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, PartonVertex, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, PartonVertex, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_PartonVertex()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_PartonVertex
//    __del__ = lambda self: None
//
//    def initPtr(self, infoPtrIn, settingsPtrIn, rndmPtrIn):
//        """
//Initialize various pointers.
//(Separated from rest of init since not virtual.)
//"""
//        return _pythia8.PartonVertex_initPtr(self, infoPtrIn, settingsPtrIn, rndmPtrIn)
//
//    def init(self):
//        """
//Initialize a few parameters from Settings.
//"""
//        return _pythia8.PartonVertex_init(self)
//
//    def vertexBeam(self, iNow, iBeam, event):
//        """
//Select vertex for a Beam Remnant particle.
//"""
//        return _pythia8.PartonVertex_vertexBeam(self, iNow, iBeam, event)
//
//    def vertexMPI(self, iBeg, nAdd, bNowIn, event):
//        """
//Select vertex for an MPI.
//"""
//        return _pythia8.PartonVertex_vertexMPI(self, iBeg, nAdd, bNowIn, event)
//
//    def vertexFSR(self, iNow, event):
//        """
//Select vertex for an FSR branching.
//"""
//        return _pythia8.PartonVertex_vertexFSR(self, iNow, event)
//
//    def vertexISR(self, iNow, event):
//        """
//Select vertex for an ISR branching.
//"""
//        return _pythia8.PartonVertex_vertexISR(self, iNow, event)
//PartonVertex_swigregister = _pythia8.PartonVertex_swigregister
//PartonVertex_swigregister(PartonVertex)
//
//class ResonanceDecays(_object):
//    """
//The ResonanceDecays class handles the sequential decay of resonances
//that are part of the hard process (t, W, Z, H, SUSY,...).
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceDecays, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceDecays, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceDecays()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, infoPtrIn, particleDataPtrIn, rndmPtrIn):
//        """
//Store pointers to Info and Rndm for error messages and random numbers.
//"""
//        return _pythia8.ResonanceDecays_init(self, infoPtrIn, particleDataPtrIn, rndmPtrIn)
//
//    def next(self, process, iDecNow=0):
//        """
//Generate the next decay sequence.
//"""
//        return _pythia8.ResonanceDecays_next(self, process, iDecNow)
//    __swig_destroy__ = _pythia8.delete_ResonanceDecays
//    __del__ = lambda self: None
//ResonanceDecays_swigregister = _pythia8.ResonanceDecays_swigregister
//ResonanceDecays_swigregister(ResonanceDecays)
//
//class ResonanceS(ResonanceWidths):
//    """
//The ResonanceS class. (S a.k.a. DMmed(s=0), PDG id 54.)
//"""
//    __swig_setmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceS, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceS, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceS(idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ResonanceS
//    __del__ = lambda self: None
//ResonanceS_swigregister = _pythia8.ResonanceS_swigregister
//ResonanceS_swigregister(ResonanceS)
//
//class ResonanceZp(ResonanceWidths):
//    """
//The ResonanceZp class. (Zp a.k.a. DMmed(s=1), PDG id 55.)
//"""
//    __swig_setmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceZp, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceZp, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceZp(idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ResonanceZp
//    __del__ = lambda self: None
//ResonanceZp_swigregister = _pythia8.ResonanceZp_swigregister
//ResonanceZp_swigregister(ResonanceZp)
//
//class RHadrons(_object):
//    """
//The RHadrons class contains the routines for the production and decay
//of long-lived heavy coloured particles.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, RHadrons, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, RHadrons, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_RHadrons()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, infoPtrIn, settings, particleDataPtrIn, rndmPtrIn):
//        """
//Initialization of R-hadron handling.
//"""
//        return _pythia8.RHadrons_init(self, infoPtrIn, settings, particleDataPtrIn, rndmPtrIn)
//
//    def fragPtrs(self, flavSelPtrIn, zSelPtrIn):
//        """
//Pointers to flavours and z sent from HadronLevel.
//"""
//        return _pythia8.RHadrons_fragPtrs(self, flavSelPtrIn, zSelPtrIn)
//
//    def produce(self, colConfig, event):
//        """
//Produce R-hadrons.
//"""
//        return _pythia8.RHadrons_produce(self, colConfig, event)
//
//    def decay(self, event):
//        """
//Decay R-hadrons.
//"""
//        return _pythia8.RHadrons_decay(self, event)
//
//    def givesRHadron(self, id):
//        """
//Tell whether a given particle is supposed to form R-hadrons.
//"""
//        return _pythia8.RHadrons_givesRHadron(self, id)
//
//    def exist(self):
//        """
//Tell whether any R-hadrons have been formed.
//"""
//        return _pythia8.RHadrons_exist(self)
//
//    def trace(self, i):
//        """
//Tell whether a R-hadron production+decay happened, and trace down.
//"""
//        return _pythia8.RHadrons_trace(self, i)
//    __swig_destroy__ = _pythia8.delete_RHadrons
//    __del__ = lambda self: None
//RHadrons_swigregister = _pythia8.RHadrons_swigregister
//RHadrons_swigregister(RHadrons)
//
//class RopeDipoleEnd(_object):
//    """
//Define the end of a dipole, containing a pointer to the particle,
//and its index in the event record.
//Includes some methods for kinematics output.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, RopeDipoleEnd, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, RopeDipoleEnd, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_RopeDipoleEnd(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def getParticlePtr(self):
//        """
//Get a pointer to the particle.
//"""
//        return _pythia8.RopeDipoleEnd_getParticlePtr(self)
//
//    def getNe(self):
//        """
//Get the particle index in event record.
//"""
//        return _pythia8.RopeDipoleEnd_getNe(self)
//
//    def labrap(self):
//        """
//Output methods for (modified) rapidity.
//"""
//        return _pythia8.RopeDipoleEnd_labrap(self)
//
//    def rap(self, *args):
//        """
//"""
//        return _pythia8.RopeDipoleEnd_rap(self, *args)
//    __swig_destroy__ = _pythia8.delete_RopeDipoleEnd
//    __del__ = lambda self: None
//RopeDipoleEnd_swigregister = _pythia8.RopeDipoleEnd_swigregister
//RopeDipoleEnd_swigregister(RopeDipoleEnd)
//
//class OverlappingRopeDipole(_object):
//    """
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, OverlappingRopeDipole, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, OverlappingRopeDipole, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, d, m0, r):
//        """
//Constructor sets up coordinates in the rest frame of other dipole.
//"""
//        this = _pythia8.new_OverlappingRopeDipole(d, m0, r)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def overlap(self, y, ba, r0):
//        """
//Calculate the overlap at given y and b.
//"""
//        return _pythia8.OverlappingRopeDipole_overlap(self, y, ba, r0)
//
//    def hadronized(self):
//        """
//Has the dipole been hadronized?
//"""
//        return _pythia8.OverlappingRopeDipole_hadronized(self)
//    __swig_setmethods__["dir"] = _pythia8.OverlappingRopeDipole_dir_set
//    __swig_getmethods__["dir"] = _pythia8.OverlappingRopeDipole_dir_get
//    if _newclass:
//        dir = _swig_property(_pythia8.OverlappingRopeDipole_dir_get, _pythia8.OverlappingRopeDipole_dir_set)
//    __swig_setmethods__["y1"] = _pythia8.OverlappingRopeDipole_y1_set
//    __swig_getmethods__["y1"] = _pythia8.OverlappingRopeDipole_y1_get
//    if _newclass:
//        y1 = _swig_property(_pythia8.OverlappingRopeDipole_y1_get, _pythia8.OverlappingRopeDipole_y1_set)
//    __swig_setmethods__["y2"] = _pythia8.OverlappingRopeDipole_y2_set
//    __swig_getmethods__["y2"] = _pythia8.OverlappingRopeDipole_y2_get
//    if _newclass:
//        y2 = _swig_property(_pythia8.OverlappingRopeDipole_y2_get, _pythia8.OverlappingRopeDipole_y2_set)
//    __swig_setmethods__["b1"] = _pythia8.OverlappingRopeDipole_b1_set
//    __swig_getmethods__["b1"] = _pythia8.OverlappingRopeDipole_b1_get
//    if _newclass:
//        b1 = _swig_property(_pythia8.OverlappingRopeDipole_b1_get, _pythia8.OverlappingRopeDipole_b1_set)
//    __swig_setmethods__["b2"] = _pythia8.OverlappingRopeDipole_b2_set
//    __swig_getmethods__["b2"] = _pythia8.OverlappingRopeDipole_b2_get
//    if _newclass:
//        b2 = _swig_property(_pythia8.OverlappingRopeDipole_b2_get, _pythia8.OverlappingRopeDipole_b2_set)
//    __swig_destroy__ = _pythia8.delete_OverlappingRopeDipole
//    __del__ = lambda self: None
//OverlappingRopeDipole_swigregister = _pythia8.OverlappingRopeDipole_swigregister
//OverlappingRopeDipole_swigregister(OverlappingRopeDipole)
//
//class RopeDipole(_object):
//    """
//The RopeDipole class holds information about a colour dipole, as well as
//functionality to do shoving and to calculate effective string tension.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, RopeDipole, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, RopeDipole, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, d1In, d2In, iSubIn, infoPtrIn):
//        """
//The RopeDipole constructor makes sure that d1 is always the colored
//end and d2 the anti-colored.
//"""
//        this = _pythia8.new_RopeDipole(d1In, d2In, iSubIn, infoPtrIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def addExcitation(self, ylab, ex):
//        """
//Insert an excitation on dipole, if not already there.
//"""
//        return _pythia8.RopeDipole_addExcitation(self, ylab, ex)
//
//    def d1Ptr(self):
//        """
//Deep access to the RopeDipoleEnds (needed by OverlappingRopeDipole).
//"""
//        return _pythia8.RopeDipole_d1Ptr(self)
//
//    def d2Ptr(self):
//        """
//"""
//        return _pythia8.RopeDipole_d2Ptr(self)
//
//    def getDipoleRestFrame(self):
//        """
//Get the rotation matrix to go to dipole rest frame.
//"""
//        return _pythia8.RopeDipole_getDipoleRestFrame(self)
//
//    def getDipoleLabFrame(self):
//        """
//"""
//        return _pythia8.RopeDipole_getDipoleLabFrame(self)
//
//    def dipoleMomentum(self):
//        """
//Get the dipole momentum four-vector.
//"""
//        return _pythia8.RopeDipole_dipoleMomentum(self)
//
//    def bInterpolateDip(self, y, m0):
//        """
//Get the spatial point interpolated to given rapidity.
//In the dipole rest frame.
//"""
//        return _pythia8.RopeDipole_bInterpolateDip(self, y, m0)
//
//    def bInterpolateLab(self, y, m0):
//        """
//In the lab frame.
//"""
//        return _pythia8.RopeDipole_bInterpolateLab(self, y, m0)
//
//    def bInterpolate(self, y, rb, m0):
//        """
//Given a Lorentz matrix.
//"""
//        return _pythia8.RopeDipole_bInterpolate(self, y, rb, m0)
//
//    def getOverlaps(self, yfrac, m0, r0):
//        """
//Get the quantum numbers m,n characterizing all dipole overlaps
//at a given rapidity value.
//"""
//        return _pythia8.RopeDipole_getOverlaps(self, yfrac, m0, r0)
//
//    def addOverlappingDipole(self, d):
//        """
//Add an overlapping dipole.
//"""
//        return _pythia8.RopeDipole_addOverlappingDipole(self, d)
//
//    def maxRapidity(self, *args):
//        """
//Get the maximal and minimal boosted rapidity of the dipole.
//"""
//        return _pythia8.RopeDipole_maxRapidity(self, *args)
//
//    def minRapidity(self, *args):
//        """
//"""
//        return _pythia8.RopeDipole_minRapidity(self, *args)
//
//    def propagateInit(self, deltat):
//        """
//Propagate the dipole itself.
//"""
//        return _pythia8.RopeDipole_propagateInit(self, deltat)
//
//    def propagate(self, deltat, m0):
//        """
//Propagate both dipole ends as well as all excitations.
//"""
//        return _pythia8.RopeDipole_propagate(self, deltat, m0)
//
//    def splitMomentum(self, mom, p1, p2, frac=0.5):
//        """
//Redistribute momentum to two particles.
//"""
//        return _pythia8.RopeDipole_splitMomentum(self, mom, p1, p2, frac)
//
//    def excitationsToString(self, m0, event):
//        """
//Put gluon excitations on the dipole.
//"""
//        return _pythia8.RopeDipole_excitationsToString(self, m0, event)
//
//    def index(self):
//        """
//Get the (event colconfig) index.
//"""
//        return _pythia8.RopeDipole_index(self)
//
//    def recoil(self, pg, dummy=False):
//        """
//Recoil the dipole from adding a gluon. If the "dummy" option is set,
//the recoil will not be added, but only checked.
//Note: the gluon will not actually be added, only the recoil (if possible).
//"""
//        return _pythia8.RopeDipole_recoil(self, pg, dummy)
//
//    def hadronized(self, *args):
//        """
//Set dipole hadronized flag.
//"""
//        return _pythia8.RopeDipole_hadronized(self, *args)
//
//    def nExcitations(self):
//        """
//The number of excitations on the dipole.
//"""
//        return _pythia8.RopeDipole_nExcitations(self)
//    __swig_destroy__ = _pythia8.delete_RopeDipole
//    __del__ = lambda self: None
//RopeDipole_swigregister = _pythia8.RopeDipole_swigregister
//RopeDipole_swigregister(RopeDipole)
//
//class Ropewalk(_object):
//    """
//The Ropewalk class keeps track of all the strings making up ropes
//for shoving as well as flavour enhancement.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Ropewalk, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, Ropewalk, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Ropewalk()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, infoPtrIn, settings, rndmPtrIn):
//        """
//The Ropewalk init function sets parameters and pointers.
//"""
//        return _pythia8.Ropewalk_init(self, infoPtrIn, settings, rndmPtrIn)
//
//    def extractDipoles(self, event, colConfig):
//        """
//Extract all dipoles from an event.
//"""
//        return _pythia8.Ropewalk_extractDipoles(self, event, colConfig)
//
//    def calculateOverlaps(self):
//        """
//Calculate all overlaps of all dipoles and store as OverlappingRopeDipoles.
//"""
//        return _pythia8.Ropewalk_calculateOverlaps(self)
//
//    def getKappaHere(self, e1, e2, yfrac):
//        """
//Calculate the effective string tension a fraction yfrac in on the dipole
//given by indices e1 and e2.
//"""
//        return _pythia8.Ropewalk_getKappaHere(self, e1, e2, yfrac)
//
//    def multiplicity(self, p, q):
//        """
//The multiplicity of a colour state given its quantum numbers.
//"""
//        return _pythia8.Ropewalk_multiplicity(self, p, q)
//
//    def averageKappa(self):
//        """
//Calculate the average string tension of the event, in units of the default
//string tension (ie. 1 GeV/fm), using random walk in colour space.
//"""
//        return _pythia8.Ropewalk_averageKappa(self)
//
//    def select(self, m, n, rndm):
//        """
//Invoke the random walk and select a state.
//"""
//        return _pythia8.Ropewalk_select(self, m, n, rndm)
//
//    def shoveTheDipoles(self, event):
//        """
//Shove all dipoles in the event.
//"""
//        return _pythia8.Ropewalk_shoveTheDipoles(self, event)
//    __swig_destroy__ = _pythia8.delete_Ropewalk
//    __del__ = lambda self: None
//Ropewalk_swigregister = _pythia8.Ropewalk_swigregister
//Ropewalk_swigregister(Ropewalk)
//
//class RopeFragPars(_object):
//    """
//RopeFragPars recalculates fragmentation parameters according to a
//changed string tension. Helper class to FlavourRope.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, RopeFragPars, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, RopeFragPars, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_RopeFragPars()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, infoPtrIn, settings):
//        """
//The init function sets up initial parameters from settings.
//"""
//        return _pythia8.RopeFragPars_init(self, infoPtrIn, settings)
//
//    def getEffectiveParameters(self, h):
//        """
//Return parameters at given string tension, ordered by their
//name for easy insertion in settings.
//"""
//        return _pythia8.RopeFragPars_getEffectiveParameters(self, h)
//    __swig_destroy__ = _pythia8.delete_RopeFragPars
//    __del__ = lambda self: None
//RopeFragPars_swigregister = _pythia8.RopeFragPars_swigregister
//RopeFragPars_swigregister(RopeFragPars)
//
//class FlavourRope(_object):
//    """
//The FlavourRope class takes care of placing a string breakup in
//the event, and assigning the string breakup effective parameters.
//It is a UserHooks derived class, and one must make sure to add it
//to the UserHooksVector in the main program or somewhere else.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, FlavourRope, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, FlavourRope, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_FlavourRope()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, settingsPtrIn, rndmPtrIn, particleDataPtrIn, infoPtrIn, rwPtrIn):
//        """
//Initialize. Set pointers.
//"""
//        return _pythia8.FlavourRope_init(self, settingsPtrIn, rndmPtrIn, particleDataPtrIn, infoPtrIn, rwPtrIn)
//
//    def doChangeFragPar(self, flavPtr, zPtr, pTPtr, m2Had, iParton, endId):
//        """
//Change the fragmentation parameters.
//"""
//        return _pythia8.FlavourRope_doChangeFragPar(self, flavPtr, zPtr, pTPtr, m2Had, iParton, endId)
//
//    def setEnhancement(self, hIn):
//        """
//Set enhancement manually.
//"""
//        return _pythia8.FlavourRope_setEnhancement(self, hIn)
//
//    def setEventPtr(self, event):
//        """
//Set pointer to the event.
//"""
//        return _pythia8.FlavourRope_setEventPtr(self, event)
//    __swig_destroy__ = _pythia8.delete_FlavourRope
//    __del__ = lambda self: None
//FlavourRope_swigregister = _pythia8.FlavourRope_swigregister
//FlavourRope_swigregister(FlavourRope)
//
//class SUSYResonanceWidths(ResonanceWidths):
//    """
//"""
//    __swig_setmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SUSYResonanceWidths, name, value)
//    __swig_getmethods__ = {}
//    for _s in [ResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, SUSYResonanceWidths, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//"""
//        this = _pythia8.new_SUSYResonanceWidths()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_SUSYResonanceWidths
//    __del__ = lambda self: None
//SUSYResonanceWidths_swigregister = _pythia8.SUSYResonanceWidths_swigregister
//SUSYResonanceWidths_swigregister(SUSYResonanceWidths)
//
//class ResonanceSquark(SUSYResonanceWidths):
//    """
//The ResonanceSquark class handles the Squark resonances.
//"""
//    __swig_setmethods__ = {}
//    for _s in [SUSYResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceSquark, name, value)
//    __swig_getmethods__ = {}
//    for _s in [SUSYResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceSquark, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceSquark(idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ResonanceSquark
//    __del__ = lambda self: None
//ResonanceSquark_swigregister = _pythia8.ResonanceSquark_swigregister
//ResonanceSquark_swigregister(ResonanceSquark)
//
//class ResonanceGluino(SUSYResonanceWidths):
//    """
//The ResonanceGluino class handles the Gluino resonances.
//"""
//    __swig_setmethods__ = {}
//    for _s in [SUSYResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceGluino, name, value)
//    __swig_getmethods__ = {}
//    for _s in [SUSYResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceGluino, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceGluino(idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ResonanceGluino
//    __del__ = lambda self: None
//ResonanceGluino_swigregister = _pythia8.ResonanceGluino_swigregister
//ResonanceGluino_swigregister(ResonanceGluino)
//
//class ResonanceNeut(SUSYResonanceWidths):
//    """
//The ResonanceNeut class handles the Neutralino resonances.
//"""
//    __swig_setmethods__ = {}
//    for _s in [SUSYResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceNeut, name, value)
//    __swig_getmethods__ = {}
//    for _s in [SUSYResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceNeut, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceNeut(idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ResonanceNeut
//    __del__ = lambda self: None
//ResonanceNeut_swigregister = _pythia8.ResonanceNeut_swigregister
//ResonanceNeut_swigregister(ResonanceNeut)
//
//class ResonanceChar(SUSYResonanceWidths):
//    """
//The ResonanceChar class handles the Chargino resonances.
//"""
//    __swig_setmethods__ = {}
//    for _s in [SUSYResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceChar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [SUSYResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceChar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceChar(idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ResonanceChar
//    __del__ = lambda self: None
//ResonanceChar_swigregister = _pythia8.ResonanceChar_swigregister
//ResonanceChar_swigregister(ResonanceChar)
//
//class ResonanceSlepton(SUSYResonanceWidths):
//    """
//The ResonanceSlepton class handles the Slepton/Sneutrino resonances.
//"""
//    __swig_setmethods__ = {}
//    for _s in [SUSYResonanceWidths]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResonanceSlepton, name, value)
//    __swig_getmethods__ = {}
//    for _s in [SUSYResonanceWidths]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ResonanceSlepton, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idResIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResonanceSlepton(idResIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ResonanceSlepton
//    __del__ = lambda self: None
//ResonanceSlepton_swigregister = _pythia8.ResonanceSlepton_swigregister
//ResonanceSlepton_swigregister(ResonanceSlepton)
//
//class TauDecays(_object):
//    """
//TauDecays class.
//This class decays tau leptons, with helicity information.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, TauDecays, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, TauDecays, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor and destructor.
//"""
//        this = _pythia8.new_TauDecays()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_TauDecays
//    __del__ = lambda self: None
//
//    def init(self, infoPtrIn, settingsPtrIn, particleDataPtrIn, rndmPtrIn, couplingsPtrIn):
//        """
//Initializer.
//"""
//        return _pythia8.TauDecays_init(self, infoPtrIn, settingsPtrIn, particleDataPtrIn, rndmPtrIn, couplingsPtrIn)
//
//    def decay(self, iDec, event):
//        """
//Decay a tau or correlated tau pair.
//"""
//        return _pythia8.TauDecays_decay(self, iDec, event)
//
//    def internalMechanism(self, event):
//        """
//Determine internal or external polarization and correlation mechanism.
//"""
//        return _pythia8.TauDecays_internalMechanism(self, event)
//
//    def externalMechanism(self, event):
//        """
//"""
//        return _pythia8.TauDecays_externalMechanism(self, event)
//
//    def createChildren(self, parent):
//        """
//Choose a decay channel for a particle.
//"""
//        return _pythia8.TauDecays_createChildren(self, parent)
//
//    def isotropicDecay(self, p):
//        """
//Perform an N-body isotropic decay.
//"""
//        return _pythia8.TauDecays_isotropicDecay(self, p)
//
//    def writeDecay(self, event, p):
//        """
//Write the decay to event record.
//"""
//        return _pythia8.TauDecays_writeDecay(self, event, p)
//TauDecays_swigregister = _pythia8.TauDecays_swigregister
//TauDecays_swigregister(TauDecays)
//
//class Sphericity(_object):
//    """
//Sphericity class.
//This class performs (optionally modified) sphericity analysis on an event.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sphericity, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, Sphericity, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, powerIn=2., selectIn=2):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sphericity(powerIn, selectIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def analyze(self, event):
//        """
//Analyze event.
//"""
//        return _pythia8.Sphericity_analyze(self, event)
//
//    def sphericity(self):
//        """
//Return info on results of analysis.
//"""
//        return _pythia8.Sphericity_sphericity(self)
//
//    def aplanarity(self):
//        """
//"""
//        return _pythia8.Sphericity_aplanarity(self)
//
//    def eigenValue(self, i):
//        """
//"""
//        return _pythia8.Sphericity_eigenValue(self, i)
//
//    def eventAxis(self, i):
//        """
//"""
//        return _pythia8.Sphericity_eventAxis(self, i)
//
//    def nError(self):
//        """
//Tell how many events could not be analyzed.
//"""
//        return _pythia8.Sphericity_nError(self)
//
//    def __str__(self):
//        return _pythia8.Sphericity___str__(self)
//    __swig_destroy__ = _pythia8.delete_Sphericity
//    __del__ = lambda self: None
//Sphericity_swigregister = _pythia8.Sphericity_swigregister
//Sphericity_swigregister(Sphericity)
//
//class Thrust(_object):
//    """
//Thrust class.
//This class performs thrust analysis on an event.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Thrust, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, Thrust, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, selectIn=2):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Thrust(selectIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def analyze(self, event):
//        """
//Analyze event.
//"""
//        return _pythia8.Thrust_analyze(self, event)
//
//    def thrust(self):
//        """
//Return info on results of analysis.
//"""
//        return _pythia8.Thrust_thrust(self)
//
//    def tMajor(self):
//        """
//"""
//        return _pythia8.Thrust_tMajor(self)
//
//    def tMinor(self):
//        """
//"""
//        return _pythia8.Thrust_tMinor(self)
//
//    def oblateness(self):
//        """
//"""
//        return _pythia8.Thrust_oblateness(self)
//
//    def eventAxis(self, i):
//        """
//"""
//        return _pythia8.Thrust_eventAxis(self, i)
//
//    def nError(self):
//        """
//Tell how many events could not be analyzed.
//"""
//        return _pythia8.Thrust_nError(self)
//
//    def __str__(self):
//        return _pythia8.Thrust___str__(self)
//    __swig_destroy__ = _pythia8.delete_Thrust
//    __del__ = lambda self: None
//Thrust_swigregister = _pythia8.Thrust_swigregister
//Thrust_swigregister(Thrust)
//
//class SingleClusterJet(_object):
//    """
//SingleClusterJet class.
//Simple helper class to ClusterJet for a jet and its contents.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SingleClusterJet, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, SingleClusterJet, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, pJetIn=0., motherIn=0):
//        """
//Constructors.
//"""
//        this = _pythia8.new_SingleClusterJet(pJetIn, motherIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["pJet"] = _pythia8.SingleClusterJet_pJet_set
//    __swig_getmethods__["pJet"] = _pythia8.SingleClusterJet_pJet_get
//    if _newclass:
//        pJet = _swig_property(_pythia8.SingleClusterJet_pJet_get, _pythia8.SingleClusterJet_pJet_set)
//    __swig_setmethods__["mother"] = _pythia8.SingleClusterJet_mother_set
//    __swig_getmethods__["mother"] = _pythia8.SingleClusterJet_mother_get
//    if _newclass:
//        mother = _swig_property(_pythia8.SingleClusterJet_mother_get, _pythia8.SingleClusterJet_mother_set)
//    __swig_setmethods__["daughter"] = _pythia8.SingleClusterJet_daughter_set
//    __swig_getmethods__["daughter"] = _pythia8.SingleClusterJet_daughter_get
//    if _newclass:
//        daughter = _swig_property(_pythia8.SingleClusterJet_daughter_get, _pythia8.SingleClusterJet_daughter_set)
//    __swig_setmethods__["multiplicity"] = _pythia8.SingleClusterJet_multiplicity_set
//    __swig_getmethods__["multiplicity"] = _pythia8.SingleClusterJet_multiplicity_get
//    if _newclass:
//        multiplicity = _swig_property(_pythia8.SingleClusterJet_multiplicity_get, _pythia8.SingleClusterJet_multiplicity_set)
//    __swig_setmethods__["isAssigned"] = _pythia8.SingleClusterJet_isAssigned_set
//    __swig_getmethods__["isAssigned"] = _pythia8.SingleClusterJet_isAssigned_get
//    if _newclass:
//        isAssigned = _swig_property(_pythia8.SingleClusterJet_isAssigned_get, _pythia8.SingleClusterJet_isAssigned_set)
//    __swig_setmethods__["pAbs"] = _pythia8.SingleClusterJet_pAbs_set
//    __swig_getmethods__["pAbs"] = _pythia8.SingleClusterJet_pAbs_get
//    if _newclass:
//        pAbs = _swig_property(_pythia8.SingleClusterJet_pAbs_get, _pythia8.SingleClusterJet_pAbs_set)
//    __swig_setmethods__["pTemp"] = _pythia8.SingleClusterJet_pTemp_set
//    __swig_getmethods__["pTemp"] = _pythia8.SingleClusterJet_pTemp_get
//    if _newclass:
//        pTemp = _swig_property(_pythia8.SingleClusterJet_pTemp_get, _pythia8.SingleClusterJet_pTemp_set)
//    __swig_destroy__ = _pythia8.delete_SingleClusterJet
//    __del__ = lambda self: None
//SingleClusterJet_swigregister = _pythia8.SingleClusterJet_swigregister
//SingleClusterJet_swigregister(SingleClusterJet)
//
//
//def dist2Fun(measure, j1, j2):
//    """
//Namespace function declarations; friend of SingleClusterJet.
//Distance measures (Lund, JADE, Durham) with friend.
//"""
//    return _pythia8.dist2Fun(measure, j1, j2)
//dist2Fun = _pythia8.dist2Fun
//class ClusterJet(_object):
//    """
//ClusterJet class.
//This class performs a jet clustering according to different
//distance measures: Lund, JADE or Durham.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ClusterJet, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, ClusterJet, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ClusterJet(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def analyze(self, event, yScaleIn, pTscaleIn, nJetMinIn=1, nJetMaxIn=0):
//        """
//Analyze event.
//"""
//        return _pythia8.ClusterJet_analyze(self, event, yScaleIn, pTscaleIn, nJetMinIn, nJetMaxIn)
//
//    def size(self):
//        """
//Return info on jets produced.
//"""
//        return _pythia8.ClusterJet_size(self)
//
//    def p(self, i):
//        """
//"""
//        return _pythia8.ClusterJet_p(self, i)
//
//    def mult(self, i):
//        """
//"""
//        return _pythia8.ClusterJet_mult(self, i)
//
//    def jetAssignment(self, i):
//        """
//Return belonging of particle to one of the jets (-1 if none).
//"""
//        return _pythia8.ClusterJet_jetAssignment(self, i)
//
//    def distanceSize(self):
//        """
//Return info on clustering values.
//"""
//        return _pythia8.ClusterJet_distanceSize(self)
//
//    def distance(self, i):
//        """
//"""
//        return _pythia8.ClusterJet_distance(self, i)
//
//    def nError(self):
//        """
//Tell how many events could not be analyzed.
//"""
//        return _pythia8.ClusterJet_nError(self)
//
//    def __str__(self):
//        return _pythia8.ClusterJet___str__(self)
//    __swig_destroy__ = _pythia8.delete_ClusterJet
//    __del__ = lambda self: None
//ClusterJet_swigregister = _pythia8.ClusterJet_swigregister
//ClusterJet_swigregister(ClusterJet)
//
//class SingleCell(_object):
//    """
//SingleCell class.
//Simple helper class to CellJet for a cell and its contents.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SingleCell, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, SingleCell, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, iCellIn=0, etaCellIn=0., phiCellIn=0., eTcellIn=0., multiplicityIn=0):
//        """
//Constructor.
//"""
//        this = _pythia8.new_SingleCell(iCellIn, etaCellIn, phiCellIn, eTcellIn, multiplicityIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["iCell"] = _pythia8.SingleCell_iCell_set
//    __swig_getmethods__["iCell"] = _pythia8.SingleCell_iCell_get
//    if _newclass:
//        iCell = _swig_property(_pythia8.SingleCell_iCell_get, _pythia8.SingleCell_iCell_set)
//    __swig_setmethods__["etaCell"] = _pythia8.SingleCell_etaCell_set
//    __swig_getmethods__["etaCell"] = _pythia8.SingleCell_etaCell_get
//    if _newclass:
//        etaCell = _swig_property(_pythia8.SingleCell_etaCell_get, _pythia8.SingleCell_etaCell_set)
//    __swig_setmethods__["phiCell"] = _pythia8.SingleCell_phiCell_set
//    __swig_getmethods__["phiCell"] = _pythia8.SingleCell_phiCell_get
//    if _newclass:
//        phiCell = _swig_property(_pythia8.SingleCell_phiCell_get, _pythia8.SingleCell_phiCell_set)
//    __swig_setmethods__["eTcell"] = _pythia8.SingleCell_eTcell_set
//    __swig_getmethods__["eTcell"] = _pythia8.SingleCell_eTcell_get
//    if _newclass:
//        eTcell = _swig_property(_pythia8.SingleCell_eTcell_get, _pythia8.SingleCell_eTcell_set)
//    __swig_setmethods__["multiplicity"] = _pythia8.SingleCell_multiplicity_set
//    __swig_getmethods__["multiplicity"] = _pythia8.SingleCell_multiplicity_get
//    if _newclass:
//        multiplicity = _swig_property(_pythia8.SingleCell_multiplicity_get, _pythia8.SingleCell_multiplicity_set)
//    __swig_setmethods__["canBeSeed"] = _pythia8.SingleCell_canBeSeed_set
//    __swig_getmethods__["canBeSeed"] = _pythia8.SingleCell_canBeSeed_get
//    if _newclass:
//        canBeSeed = _swig_property(_pythia8.SingleCell_canBeSeed_get, _pythia8.SingleCell_canBeSeed_set)
//    __swig_setmethods__["isUsed"] = _pythia8.SingleCell_isUsed_set
//    __swig_getmethods__["isUsed"] = _pythia8.SingleCell_isUsed_get
//    if _newclass:
//        isUsed = _swig_property(_pythia8.SingleCell_isUsed_get, _pythia8.SingleCell_isUsed_set)
//    __swig_setmethods__["isAssigned"] = _pythia8.SingleCell_isAssigned_set
//    __swig_getmethods__["isAssigned"] = _pythia8.SingleCell_isAssigned_get
//    if _newclass:
//        isAssigned = _swig_property(_pythia8.SingleCell_isAssigned_get, _pythia8.SingleCell_isAssigned_set)
//    __swig_destroy__ = _pythia8.delete_SingleCell
//    __del__ = lambda self: None
//SingleCell_swigregister = _pythia8.SingleCell_swigregister
//SingleCell_swigregister(SingleCell)
//
//class SingleCellJet(_object):
//    """
//SingleCellJet class.
//Simple helper class to CellJet for a jet and its contents.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SingleCellJet, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, SingleCellJet, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, eTjetIn=0., etaCenterIn=0., phiCenterIn=0., etaWeightedIn=0., phiWeightedIn=0., multiplicityIn=0, pMassiveIn=0.):
//        """
//Constructor.
//"""
//        this = _pythia8.new_SingleCellJet(eTjetIn, etaCenterIn, phiCenterIn, etaWeightedIn, phiWeightedIn, multiplicityIn, pMassiveIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["eTjet"] = _pythia8.SingleCellJet_eTjet_set
//    __swig_getmethods__["eTjet"] = _pythia8.SingleCellJet_eTjet_get
//    if _newclass:
//        eTjet = _swig_property(_pythia8.SingleCellJet_eTjet_get, _pythia8.SingleCellJet_eTjet_set)
//    __swig_setmethods__["etaCenter"] = _pythia8.SingleCellJet_etaCenter_set
//    __swig_getmethods__["etaCenter"] = _pythia8.SingleCellJet_etaCenter_get
//    if _newclass:
//        etaCenter = _swig_property(_pythia8.SingleCellJet_etaCenter_get, _pythia8.SingleCellJet_etaCenter_set)
//    __swig_setmethods__["phiCenter"] = _pythia8.SingleCellJet_phiCenter_set
//    __swig_getmethods__["phiCenter"] = _pythia8.SingleCellJet_phiCenter_get
//    if _newclass:
//        phiCenter = _swig_property(_pythia8.SingleCellJet_phiCenter_get, _pythia8.SingleCellJet_phiCenter_set)
//    __swig_setmethods__["etaWeighted"] = _pythia8.SingleCellJet_etaWeighted_set
//    __swig_getmethods__["etaWeighted"] = _pythia8.SingleCellJet_etaWeighted_get
//    if _newclass:
//        etaWeighted = _swig_property(_pythia8.SingleCellJet_etaWeighted_get, _pythia8.SingleCellJet_etaWeighted_set)
//    __swig_setmethods__["phiWeighted"] = _pythia8.SingleCellJet_phiWeighted_set
//    __swig_getmethods__["phiWeighted"] = _pythia8.SingleCellJet_phiWeighted_get
//    if _newclass:
//        phiWeighted = _swig_property(_pythia8.SingleCellJet_phiWeighted_get, _pythia8.SingleCellJet_phiWeighted_set)
//    __swig_setmethods__["multiplicity"] = _pythia8.SingleCellJet_multiplicity_set
//    __swig_getmethods__["multiplicity"] = _pythia8.SingleCellJet_multiplicity_get
//    if _newclass:
//        multiplicity = _swig_property(_pythia8.SingleCellJet_multiplicity_get, _pythia8.SingleCellJet_multiplicity_set)
//    __swig_setmethods__["pMassive"] = _pythia8.SingleCellJet_pMassive_set
//    __swig_getmethods__["pMassive"] = _pythia8.SingleCellJet_pMassive_get
//    if _newclass:
//        pMassive = _swig_property(_pythia8.SingleCellJet_pMassive_get, _pythia8.SingleCellJet_pMassive_set)
//    __swig_destroy__ = _pythia8.delete_SingleCellJet
//    __del__ = lambda self: None
//SingleCellJet_swigregister = _pythia8.SingleCellJet_swigregister
//SingleCellJet_swigregister(SingleCellJet)
//
//class CellJet(_object):
//    """
//CellJet class.
//This class performs a cone jet search in (eta, phi, E_T) space.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, CellJet, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, CellJet, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, etaMaxIn=5., nEtaIn=50, nPhiIn=32, selectIn=2, smearIn=0, resolutionIn=0.5, upperCutIn=2., thresholdIn=0., rndmPtrIn=None):
//        """
//Constructor.
//"""
//        this = _pythia8.new_CellJet(etaMaxIn, nEtaIn, nPhiIn, selectIn, smearIn, resolutionIn, upperCutIn, thresholdIn, rndmPtrIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def analyze(self, event, eTjetMinIn=20., coneRadiusIn=0.7, eTseedIn=1.5):
//        """
//Analyze event.
//"""
//        return _pythia8.CellJet_analyze(self, event, eTjetMinIn, coneRadiusIn, eTseedIn)
//
//    def size(self):
//        """
//Return info on results of analysis.
//"""
//        return _pythia8.CellJet_size(self)
//
//    def eT(self, i):
//        """
//"""
//        return _pythia8.CellJet_eT(self, i)
//
//    def etaCenter(self, i):
//        """
//"""
//        return _pythia8.CellJet_etaCenter(self, i)
//
//    def phiCenter(self, i):
//        """
//"""
//        return _pythia8.CellJet_phiCenter(self, i)
//
//    def etaWeighted(self, i):
//        """
//"""
//        return _pythia8.CellJet_etaWeighted(self, i)
//
//    def phiWeighted(self, i):
//        """
//"""
//        return _pythia8.CellJet_phiWeighted(self, i)
//
//    def multiplicity(self, i):
//        """
//"""
//        return _pythia8.CellJet_multiplicity(self, i)
//
//    def pMassless(self, i):
//        """
//"""
//        return _pythia8.CellJet_pMassless(self, i)
//
//    def pMassive(self, i):
//        """
//"""
//        return _pythia8.CellJet_pMassive(self, i)
//
//    def m(self, i):
//        """
//"""
//        return _pythia8.CellJet_m(self, i)
//
//    def nError(self):
//        """
//Tell how many events could not be analyzed: so far never.
//"""
//        return _pythia8.CellJet_nError(self)
//
//    def __str__(self):
//        return _pythia8.CellJet___str__(self)
//    __swig_destroy__ = _pythia8.delete_CellJet
//    __del__ = lambda self: None
//CellJet_swigregister = _pythia8.CellJet_swigregister
//CellJet_swigregister(CellJet)
//
//class SlowJetHook(_object):
//    """
//SlowJetHook class.
//Base class, used to derive your own class with your selection criteria.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SlowJetHook, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, SlowJetHook, name)
//
//    def __init__(self, *args, **kwargs):
//        raise AttributeError("No constructor defined - class is abstract")
//    __repr__ = _swig_repr
//    __swig_destroy__ = _pythia8.delete_SlowJetHook
//    __del__ = lambda self: None
//
//    def include(self, iSel, event, pSel, mSel):
//        """
//Method to be overloaded.
//It will be called for all final-state particles, one at a time, and
//should return true if the particle should be analyzed, false if not.
//The particle is in location iSel of the event record.
//If you wish you can also modify the four-momentum and mass that will
// be used in the analysis, without affecting the event record itself,
//by changing pSel and mSel. Remember to respect E^2 - p^2 = m^2.
//"""
//        return _pythia8.SlowJetHook_include(self, iSel, event, pSel, mSel)
//SlowJetHook_swigregister = _pythia8.SlowJetHook_swigregister
//SlowJetHook_swigregister(SlowJetHook)
//
//class SingleSlowJet(_object):
//    """
//SingleSlowJet class.
//Simple helper class to SlowJet for a jet and its contents.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SingleSlowJet, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, SingleSlowJet, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_SingleSlowJet(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["p"] = _pythia8.SingleSlowJet_p_set
//    __swig_getmethods__["p"] = _pythia8.SingleSlowJet_p_get
//    if _newclass:
//        p = _swig_property(_pythia8.SingleSlowJet_p_get, _pythia8.SingleSlowJet_p_set)
//    __swig_setmethods__["pT2"] = _pythia8.SingleSlowJet_pT2_set
//    __swig_getmethods__["pT2"] = _pythia8.SingleSlowJet_pT2_get
//    if _newclass:
//        pT2 = _swig_property(_pythia8.SingleSlowJet_pT2_get, _pythia8.SingleSlowJet_pT2_set)
//    __swig_setmethods__["y"] = _pythia8.SingleSlowJet_y_set
//    __swig_getmethods__["y"] = _pythia8.SingleSlowJet_y_get
//    if _newclass:
//        y = _swig_property(_pythia8.SingleSlowJet_y_get, _pythia8.SingleSlowJet_y_set)
//    __swig_setmethods__["phi"] = _pythia8.SingleSlowJet_phi_set
//    __swig_getmethods__["phi"] = _pythia8.SingleSlowJet_phi_get
//    if _newclass:
//        phi = _swig_property(_pythia8.SingleSlowJet_phi_get, _pythia8.SingleSlowJet_phi_set)
//    __swig_setmethods__["mult"] = _pythia8.SingleSlowJet_mult_set
//    __swig_getmethods__["mult"] = _pythia8.SingleSlowJet_mult_get
//    if _newclass:
//        mult = _swig_property(_pythia8.SingleSlowJet_mult_get, _pythia8.SingleSlowJet_mult_set)
//    __swig_setmethods__["idx"] = _pythia8.SingleSlowJet_idx_set
//    __swig_getmethods__["idx"] = _pythia8.SingleSlowJet_idx_get
//    if _newclass:
//        idx = _swig_property(_pythia8.SingleSlowJet_idx_get, _pythia8.SingleSlowJet_idx_set)
//    __swig_destroy__ = _pythia8.delete_SingleSlowJet
//    __del__ = lambda self: None
//SingleSlowJet_swigregister = _pythia8.SingleSlowJet_swigregister
//SingleSlowJet_swigregister(SingleSlowJet)
//
//class SlowJet(_object):
//    """
//SlowJet class.
//This class performs a recombination jet search in (y, phi, pT) space.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SlowJet, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, SlowJet, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, powerIn, Rin, pTjetMinIn=0., etaMaxIn=25., selectIn=2, massSetIn=2, sjHookPtrIn=None, useFJcoreIn=True, useStandardRin=True):
//        """
//Constructor.
//"""
//        this = _pythia8.new_SlowJet(powerIn, Rin, pTjetMinIn, etaMaxIn, selectIn, massSetIn, sjHookPtrIn, useFJcoreIn, useStandardRin)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_SlowJet
//    __del__ = lambda self: None
//
//    def analyze(self, event):
//        """
//Analyze event, all in one go.
//"""
//        return _pythia8.SlowJet_analyze(self, event)
//
//    def setup(self, event):
//        """
//Set up list of particles to analyze, and initial distances.
//"""
//        return _pythia8.SlowJet_setup(self, event)
//
//    def doStep(self):
//        """
//Do one recombination step, possibly giving a jet.
//"""
//        return _pythia8.SlowJet_doStep(self)
//
//    def doNSteps(self, nStep):
//        """
//Do several recombinations steps, if possible.
//"""
//        return _pythia8.SlowJet_doNSteps(self, nStep)
//
//    def stopAtN(self, nStop):
//        """
//Do recombinations until fixed numbers of clusters and jets remain.
//"""
//        return _pythia8.SlowJet_stopAtN(self, nStop)
//
//    def sizeOrig(self):
//        """
//Return info on jet (+cluster) results of analysis.
//"""
//        return _pythia8.SlowJet_sizeOrig(self)
//
//    def sizeJet(self):
//        """
//"""
//        return _pythia8.SlowJet_sizeJet(self)
//
//    def sizeAll(self):
//        """
//"""
//        return _pythia8.SlowJet_sizeAll(self)
//
//    def pT(self, i):
//        """
//"""
//        return _pythia8.SlowJet_pT(self, i)
//
//    def y(self, i):
//        """
//"""
//        return _pythia8.SlowJet_y(self, i)
//
//    def phi(self, i):
//        """
//"""
//        return _pythia8.SlowJet_phi(self, i)
//
//    def p(self, i):
//        """
//"""
//        return _pythia8.SlowJet_p(self, i)
//
//    def m(self, i):
//        """
//"""
//        return _pythia8.SlowJet_m(self, i)
//
//    def multiplicity(self, i):
//        """
//"""
//        return _pythia8.SlowJet_multiplicity(self, i)
//
//    def iNext(self):
//        """
//Return info on next step to be taken.
//"""
//        return _pythia8.SlowJet_iNext(self)
//
//    def jNext(self):
//        """
//"""
//        return _pythia8.SlowJet_jNext(self)
//
//    def dNext(self):
//        """
//"""
//        return _pythia8.SlowJet_dNext(self)
//
//    def constituents(self, j):
//        """
//Give a list of all particles in the jet.
//"""
//        return _pythia8.SlowJet_constituents(self, j)
//
//    def clusConstituents(self, j):
//        """
//Give a list of all particles in the cluster.
//"""
//        return _pythia8.SlowJet_clusConstituents(self, j)
//
//    def jetAssignment(self, i):
//        """
//Give the index of the jet that the particle i of the event record
//belongs to. Returns -1 if particle i is not found in a jet.
//"""
//        return _pythia8.SlowJet_jetAssignment(self, i)
//
//    def removeJet(self, i):
//        """
//Remove a jet.
//"""
//        return _pythia8.SlowJet_removeJet(self, i)
//
//    def __str__(self):
//        return _pythia8.SlowJet___str__(self)
//SlowJet_swigregister = _pythia8.SlowJet_swigregister
//SlowJet_swigregister(SlowJet)
//
//class ResolvedParton(_object):
//    """
//This class holds info on a parton resolved inside the incoming beam,
//i.e. either an initiator (part of a hard or a multiparton interaction)
//or a remnant (part of the beam remnant treatment).
//The companion code is -1 from onset and for g, is -2 for an unmatched
//sea quark, is >= 0 for a matched sea quark, with the number giving the
//companion position, and is -3 for a valence quark.
//Rescattering partons properly do not belong here, but bookkeeping is
//simpler with them, so they are stored with companion code -10.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ResolvedParton, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, ResolvedParton, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, iPosIn=0, idIn=0, xIn=0., companionIn=-1):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ResolvedParton(iPosIn, idIn, xIn, companionIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def update(self, iPosIn, idIn, xIn):
//        """
//"""
//        return _pythia8.ResolvedParton_update(self, iPosIn, idIn, xIn)
//
//    def cols(self, colIn=0, acolIn=0):
//        """
//"""
//        return _pythia8.ResolvedParton_cols(self, colIn, acolIn)
//
//    def scalePT(self, factorIn):
//        """
//"""
//        return _pythia8.ResolvedParton_scalePT(self, factorIn)
//
//    def scaleX(self, factorIn):
//        """
//"""
//        return _pythia8.ResolvedParton_scaleX(self, factorIn)
//
//    def iPos(self, *args):
//        """
//Get info on initiator or remnant parton.
//"""
//        return _pythia8.ResolvedParton_iPos(self, *args)
//
//    def id(self, *args):
//        """
//"""
//        return _pythia8.ResolvedParton_id(self, *args)
//
//    def x(self, *args):
//        """
//"""
//        return _pythia8.ResolvedParton_x(self, *args)
//
//    def companion(self, *args):
//        """
//"""
//        return _pythia8.ResolvedParton_companion(self, *args)
//
//    def isValence(self):
//        """
//"""
//        return _pythia8.ResolvedParton_isValence(self)
//
//    def isUnmatched(self):
//        """
//"""
//        return _pythia8.ResolvedParton_isUnmatched(self)
//
//    def isCompanion(self):
//        """
//"""
//        return _pythia8.ResolvedParton_isCompanion(self)
//
//    def isFromBeam(self):
//        """
//"""
//        return _pythia8.ResolvedParton_isFromBeam(self)
//
//    def xqCompanion(self, *args):
//        """
//"""
//        return _pythia8.ResolvedParton_xqCompanion(self, *args)
//
//    def p(self, *args):
//        """
//"""
//        return _pythia8.ResolvedParton_p(self, *args)
//
//    def px(self, *args):
//        """
//"""
//        return _pythia8.ResolvedParton_px(self, *args)
//
//    def py(self, *args):
//        """
//"""
//        return _pythia8.ResolvedParton_py(self, *args)
//
//    def pz(self, *args):
//        """
//"""
//        return _pythia8.ResolvedParton_pz(self, *args)
//
//    def e(self, *args):
//        """
//"""
//        return _pythia8.ResolvedParton_e(self, *args)
//
//    def m(self, *args):
//        """
//"""
//        return _pythia8.ResolvedParton_m(self, *args)
//
//    def pT(self):
//        """
//"""
//        return _pythia8.ResolvedParton_pT(self)
//
//    def mT2(self):
//        """
//"""
//        return _pythia8.ResolvedParton_mT2(self)
//
//    def pPos(self):
//        """
//"""
//        return _pythia8.ResolvedParton_pPos(self)
//
//    def pNeg(self):
//        """
//"""
//        return _pythia8.ResolvedParton_pNeg(self)
//
//    def col(self, *args):
//        """
//"""
//        return _pythia8.ResolvedParton_col(self, *args)
//
//    def acol(self, *args):
//        """
//"""
//        return _pythia8.ResolvedParton_acol(self, *args)
//
//    def pTfactor(self):
//        """
//"""
//        return _pythia8.ResolvedParton_pTfactor(self)
//
//    def hasCol(self):
//        """
//"""
//        return _pythia8.ResolvedParton_hasCol(self)
//
//    def hasAcol(self):
//        """
//"""
//        return _pythia8.ResolvedParton_hasAcol(self)
//    __swig_destroy__ = _pythia8.delete_ResolvedParton
//    __del__ = lambda self: None
//ResolvedParton_swigregister = _pythia8.ResolvedParton_swigregister
//ResolvedParton_swigregister(ResolvedParton)
//
//class BeamParticle(_object):
//    """
//This class holds info on a beam particle in the evolution of
//initial-state radiation and multiparton interactions.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, BeamParticle, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, BeamParticle, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_BeamParticle()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, idIn, pzIn, eIn, mIn, infoPtrIn, settings, particleDataPtrIn, rndmPtrIn, pdfInPtr, pdfHardInPtr, isUnresolvedIn, flavSelPtrIn):
//        """
//Initialize data on a beam particle and save pointers.
//"""
//        return _pythia8.BeamParticle_init(self, idIn, pzIn, eIn, mIn, infoPtrIn, settings, particleDataPtrIn, rndmPtrIn, pdfInPtr, pdfHardInPtr, isUnresolvedIn, flavSelPtrIn)
//
//    def initPDFPtr(self, pdfInPtr, pdfHardInPtr):
//        """
//Initialize only the two pdf pointers.
//"""
//        return _pythia8.BeamParticle_initPDFPtr(self, pdfInPtr, pdfHardInPtr)
//
//    def initUnres(self, pdfUnresInPtr):
//        """
//Initialize additional PDF pointer for unresolved beam.
//"""
//        return _pythia8.BeamParticle_initUnres(self, pdfUnresInPtr)
//
//    def newValenceContent(self):
//        """
//For mesons like pi0 valence content varies from event to event.
//"""
//        return _pythia8.BeamParticle_newValenceContent(self)
//
//    def newPzE(self, pzIn, eIn):
//        """
//Set new pZ and E, but keep the rest the same.
//"""
//        return _pythia8.BeamParticle_newPzE(self, pzIn, eIn)
//
//    def newM(self, mIn):
//        """
//Set new mass. Used with photons when virtuality is sampled.
//"""
//        return _pythia8.BeamParticle_newM(self, mIn)
//
//    def id(self):
//        """
//Member functions for output.
//"""
//        return _pythia8.BeamParticle_id(self)
//
//    def idVMD(self):
//        """
//"""
//        return _pythia8.BeamParticle_idVMD(self)
//
//    def p(self):
//        """
//"""
//        return _pythia8.BeamParticle_p(self)
//
//    def px(self):
//        """
//"""
//        return _pythia8.BeamParticle_px(self)
//
//    def py(self):
//        """
//"""
//        return _pythia8.BeamParticle_py(self)
//
//    def pz(self):
//        """
//"""
//        return _pythia8.BeamParticle_pz(self)
//
//    def e(self):
//        """
//"""
//        return _pythia8.BeamParticle_e(self)
//
//    def m(self):
//        """
//"""
//        return _pythia8.BeamParticle_m(self)
//
//    def mVMD(self):
//        """
//"""
//        return _pythia8.BeamParticle_mVMD(self)
//
//    def scaleVMD(self):
//        """
//"""
//        return _pythia8.BeamParticle_scaleVMD(self)
//
//    def isLepton(self):
//        """
//"""
//        return _pythia8.BeamParticle_isLepton(self)
//
//    def isUnresolved(self):
//        """
//"""
//        return _pythia8.BeamParticle_isUnresolved(self)
//
//    def isHadron(self):
//        """
//As hadrons here we only count those we know how to handle remnants for.
//"""
//        return _pythia8.BeamParticle_isHadron(self)
//
//    def isMeson(self):
//        """
//"""
//        return _pythia8.BeamParticle_isMeson(self)
//
//    def isBaryon(self):
//        """
//"""
//        return _pythia8.BeamParticle_isBaryon(self)
//
//    def isGamma(self):
//        """
//"""
//        return _pythia8.BeamParticle_isGamma(self)
//
//    def hasResGamma(self):
//        """
//"""
//        return _pythia8.BeamParticle_hasResGamma(self)
//
//    def hasVMDstate(self):
//        """
//"""
//        return _pythia8.BeamParticle_hasVMDstate(self)
//
//    def xMax(self, iSkip=-1):
//        """
//Maximum x remaining after previous MPI and ISR, plus safety margin.
//"""
//        return _pythia8.BeamParticle_xMax(self, iSkip)
//
//    def xfHard(self, idIn, x, Q2):
//        """
//Special hard-process parton distributions (can agree with standard ones).
//"""
//        return _pythia8.BeamParticle_xfHard(self, idIn, x, Q2)
//
//    def xfMax(self, idIn, x, Q2):
//        """
//Overestimate for PDFs. Same as normal except photons inside leptons.
//"""
//        return _pythia8.BeamParticle_xfMax(self, idIn, x, Q2)
//
//    def xfFlux(self, idIn, x, Q2):
//        """
//Accurate and approximated photon flux and PDFs.
//"""
//        return _pythia8.BeamParticle_xfFlux(self, idIn, x, Q2)
//
//    def xfApprox(self, idIn, x, Q2):
//        """
//"""
//        return _pythia8.BeamParticle_xfApprox(self, idIn, x, Q2)
//
//    def xfGamma(self, idIn, x, Q2):
//        """
//"""
//        return _pythia8.BeamParticle_xfGamma(self, idIn, x, Q2)
//
//    def xfSame(self, idIn, x, Q2):
//        """
//Do not sample the x_gamma value to get correct cross section with
//possible second call.
//"""
//        return _pythia8.BeamParticle_xfSame(self, idIn, x, Q2)
//
//    def xf(self, idIn, x, Q2):
//        """
//Standard parton distributions.
//"""
//        return _pythia8.BeamParticle_xf(self, idIn, x, Q2)
//
//    def xfVal(self, idIn, x, Q2):
//        """
//Ditto, split into valence and sea parts (where gluon counts as sea).
//"""
//        return _pythia8.BeamParticle_xfVal(self, idIn, x, Q2)
//
//    def xfSea(self, idIn, x, Q2):
//        """
//"""
//        return _pythia8.BeamParticle_xfSea(self, idIn, x, Q2)
//
//    def xfMPI(self, idIn, x, Q2):
//        """
//Rescaled parton distributions, as needed for MPI and ISR.
//For ISR also allow split valence/sea, and only return relevant part.
//"""
//        return _pythia8.BeamParticle_xfMPI(self, idIn, x, Q2)
//
//    def xfISR(self, indexMPI, idIn, x, Q2):
//        """
//"""
//        return _pythia8.BeamParticle_xfISR(self, indexMPI, idIn, x, Q2)
//
//    def insideBounds(self, x, Q2):
//        """
//Check whether x and Q2 values fall inside the fit bounds (LHAPDF6 only).
//"""
//        return _pythia8.BeamParticle_insideBounds(self, x, Q2)
//
//    def alphaS(self, Q2):
//        """
//Access the running alpha_s of a PDF set (LHAPDF6 only).
//"""
//        return _pythia8.BeamParticle_alphaS(self, Q2)
//
//    def mQuarkPDF(self, idIn):
//        """
//Return quark masses used in the PDF fit (LHAPDF6 only).
//"""
//        return _pythia8.BeamParticle_mQuarkPDF(self, idIn)
//
//    def nMembers(self):
//        """
//Return number of members in PDF family (LHAPDF6 only).
//"""
//        return _pythia8.BeamParticle_nMembers(self)
//
//    def calcPDFEnvelope(self, *args):
//        """
//"""
//        return _pythia8.BeamParticle_calcPDFEnvelope(self, *args)
//
//    def getPDFEnvelope(self):
//        """
//"""
//        return _pythia8.BeamParticle_getPDFEnvelope(self)
//
//    def pickValSeaComp(self):
//        """
//Decide whether chosen quark is valence, sea or companion.
//"""
//        return _pythia8.BeamParticle_pickValSeaComp(self)
//
//    def initBeamKind(self):
//        """
//Initialize kind of incoming beam particle.
//"""
//        return _pythia8.BeamParticle_initBeamKind(self)
//
//    def size(self):
//        """
//Total number of partons extracted from beam, and initiators only.
//"""
//        return _pythia8.BeamParticle_size(self)
//
//    def sizeInit(self):
//        """
//"""
//        return _pythia8.BeamParticle_sizeInit(self)
//
//    def clear(self):
//        """
//Clear list of resolved partons.
//"""
//        return _pythia8.BeamParticle_clear(self)
//
//    def resetGamma(self):
//        """
//Reset variables related to photon beam.
//"""
//        return _pythia8.BeamParticle_resetGamma(self)
//
//    def resetGammaInLepton(self):
//        """
//Reset variables related to photon beam inside a lepton.
//"""
//        return _pythia8.BeamParticle_resetGammaInLepton(self)
//
//    def append(self, iPos, idIn, x, companion=-1):
//        """
//Add a resolved parton to list.
//"""
//        return _pythia8.BeamParticle_append(self, iPos, idIn, x, companion)
//
//    def popBack(self):
//        """
//Remove the last particle from the beam. Reset companion code if needed.
//"""
//        return _pythia8.BeamParticle_popBack(self)
//
//    def nValenceKinds(self):
//        """
//How many different flavours, and how many quarks of given flavour.
//"""
//        return _pythia8.BeamParticle_nValenceKinds(self)
//
//    def nValence(self, idIn):
//        """
//"""
//        return _pythia8.BeamParticle_nValence(self, idIn)
//
//    def isUnresolvedLepton(self):
//        """
//Test whether a lepton is to be considered as unresolved.
//"""
//        return _pythia8.BeamParticle_isUnresolvedLepton(self)
//
//    def remnantFlavours(self, event, isDIS=False):
//        """
//Add extra remnant flavours to make valence and sea come out right.
//"""
//        return _pythia8.BeamParticle_remnantFlavours(self, event, isDIS)
//
//    def remnantColours(self, event, colFrom, colTo):
//        """
//Correlate all initiators and remnants to make a colour singlet.
//"""
//        return _pythia8.BeamParticle_remnantColours(self, event, colFrom, colTo)
//
//    def xRemnant(self, i):
//        """
//Pick unrescaled x of remnant parton (valence or sea).
//"""
//        return _pythia8.BeamParticle_xRemnant(self, i)
//
//    def hasJunction(self):
//        """
//Tell whether a junction has been resolved, and its junction colours.
//"""
//        return _pythia8.BeamParticle_hasJunction(self)
//
//    def junctionCol(self, *args):
//        """
//"""
//        return _pythia8.BeamParticle_junctionCol(self, *args)
//
//    def pickGluon(self, mDiff):
//        """
//For a diffractive system, decide whether to kick out gluon or quark.
//"""
//        return _pythia8.BeamParticle_pickGluon(self, mDiff)
//
//    def pickValence(self):
//        """
//Pick a valence quark at random, and provide the remaining flavour.
//"""
//        return _pythia8.BeamParticle_pickValence(self)
//
//    def pickRemnant(self):
//        """
//"""
//        return _pythia8.BeamParticle_pickRemnant(self)
//
//    def zShare(self, mDiff, m1, m2):
//        """
//Share lightcone momentum between two remnants in a diffractive system.
//At the same time generate a relative pT for the two.
//"""
//        return _pythia8.BeamParticle_zShare(self, mDiff, m1, m2)
//
//    def pxShare(self):
//        """
//"""
//        return _pythia8.BeamParticle_pxShare(self)
//
//    def pyShare(self):
//        """
//"""
//        return _pythia8.BeamParticle_pyShare(self)
//
//    def remnantFlavoursNew(self, event):
//        """
//Add extra remnant flavours to make valence and sea come out right.
//"""
//        return _pythia8.BeamParticle_remnantFlavoursNew(self, event)
//
//    def findColSetup(self, event):
//        """
//Find the colour setup of the removed partons from the scatterings.
//"""
//        return _pythia8.BeamParticle_findColSetup(self, event)
//
//    def setInitialCol(self, event):
//        """
//Set initial colours.
//"""
//        return _pythia8.BeamParticle_setInitialCol(self, event)
//
//    def updateCol(self, colourChanges):
//        """
//Update colours.
//"""
//        return _pythia8.BeamParticle_updateCol(self, colourChanges)
//
//    def getColUpdates(self):
//        """
//"""
//        return _pythia8.BeamParticle_getColUpdates(self)
//
//    def gammaInitiatorIsVal(self, *args):
//        """
//"""
//        return _pythia8.BeamParticle_gammaInitiatorIsVal(self, *args)
//
//    def getGammaValFlavour(self):
//        """
//"""
//        return _pythia8.BeamParticle_getGammaValFlavour(self)
//
//    def gammaValSeaComp(self, iResolved):
//        """
//"""
//        return _pythia8.BeamParticle_gammaValSeaComp(self, iResolved)
//
//    def posVal(self, iPosValIn):
//        """
//"""
//        return _pythia8.BeamParticle_posVal(self, iPosValIn)
//
//    def gamVal(self, *args):
//        """
//"""
//        return _pythia8.BeamParticle_gamVal(self, *args)
//
//    def resolvedGamma(self, *args):
//        """
//"""
//        return _pythia8.BeamParticle_resolvedGamma(self, *args)
//
//    def setGammaMode(self, gammaModeIn):
//        """
//"""
//        return _pythia8.BeamParticle_setGammaMode(self, gammaModeIn)
//
//    def getGammaMode(self):
//        """
//"""
//        return _pythia8.BeamParticle_getGammaMode(self)
//
//    def isResolvedUnresolved(self):
//        """
//"""
//        return _pythia8.BeamParticle_isResolvedUnresolved(self)
//
//    def setVMDstate(self, isVMDIn, idIn, mIn, scaleIn, reassignState=False):
//        """
//Set state of VMD inside gamma.
//"""
//        return _pythia8.BeamParticle_setVMDstate(self, isVMDIn, idIn, mIn, scaleIn, reassignState)
//
//    def pT2gamma2qqbar(self, *args):
//        """
//"""
//        return _pythia8.BeamParticle_pT2gamma2qqbar(self, *args)
//
//    def pTMPI(self, pTminMPIin):
//        """
//Store the pT value for the latest MPI.
//"""
//        return _pythia8.BeamParticle_pTMPI(self, pTminMPIin)
//
//    def roomFor1Remnant(self, *args):
//        """
//"""
//        return _pythia8.BeamParticle_roomFor1Remnant(self, *args)
//
//    def roomFor2Remnants(self, id1, x1, eCM):
//        """
//"""
//        return _pythia8.BeamParticle_roomFor2Remnants(self, id1, x1, eCM)
//
//    def roomForRemnants(self, beamOther):
//        """
//"""
//        return _pythia8.BeamParticle_roomForRemnants(self, beamOther)
//
//    def remnantMass(self, idIn):
//        """
//Evaluate the remnant mass with initiator idIn.
//"""
//        return _pythia8.BeamParticle_remnantMass(self, idIn)
//
//    def gammaPDFxDependence(self, flavour, x):
//        """
//Functions to approximate pdfs for ISR.
//"""
//        return _pythia8.BeamParticle_gammaPDFxDependence(self, flavour, x)
//
//    def gammaPDFRefScale(self, flavour):
//        """
//"""
//        return _pythia8.BeamParticle_gammaPDFRefScale(self, flavour)
//
//    def xIntegratedPDFs(self, Q2):
//        """
//"""
//        return _pythia8.BeamParticle_xIntegratedPDFs(self, Q2)
//
//    def xGammaPDF(self):
//        """
//Save the x_gamma value after latest PDF call or set it later if ND.
//"""
//        return _pythia8.BeamParticle_xGammaPDF(self)
//
//    def newGammaKTPhi(self, kTIn, phiIn):
//        """
//"""
//        return _pythia8.BeamParticle_newGammaKTPhi(self, kTIn, phiIn)
//
//    def Q2minPDF(self):
//        """
//Get the kinematic limits for photons emitted by the beam.
//"""
//        return _pythia8.BeamParticle_Q2minPDF(self)
//
//    def xGammaMin(self):
//        """
//"""
//        return _pythia8.BeamParticle_xGammaMin(self)
//
//    def xGammaHadr(self):
//        """
//"""
//        return _pythia8.BeamParticle_xGammaHadr(self)
//
//    def gammaFluxNorm(self):
//        """
//"""
//        return _pythia8.BeamParticle_gammaFluxNorm(self)
//
//    def xGamma(self, *args):
//        """
//Get the kinematics related photons form lepton beams.
//"""
//        return _pythia8.BeamParticle_xGamma(self, *args)
//
//    def Q2Gamma(self, *args):
//        """
//"""
//        return _pythia8.BeamParticle_Q2Gamma(self, *args)
//
//    def gammaKTx(self):
//        """
//"""
//        return _pythia8.BeamParticle_gammaKTx(self)
//
//    def gammaKTy(self):
//        """
//"""
//        return _pythia8.BeamParticle_gammaKTy(self)
//
//    def gammaKT(self):
//        """
//"""
//        return _pythia8.BeamParticle_gammaKT(self)
//
//    def gammaPhi(self):
//        """
//"""
//        return _pythia8.BeamParticle_gammaPhi(self)
//
//    def xPom(self, xpom=-1.0):
//        """
//Keep track of pomeron momentum fraction.
//"""
//        return _pythia8.BeamParticle_xPom(self, xpom)
//
//    def sampleXgamma(self, xMinIn):
//        """
//Sample x and Q2 for emitted photons according to flux.
//"""
//        return _pythia8.BeamParticle_sampleXgamma(self, xMinIn)
//
//    def sampleQ2gamma(self, Q2min):
//        """
//"""
//        return _pythia8.BeamParticle_sampleQ2gamma(self, Q2min)
//
//    def __str__(self):
//        return _pythia8.BeamParticle___str__(self)
//
//    def __getitem__(self, i):
//        return _pythia8.BeamParticle___getitem__(self, i)
//    __swig_destroy__ = _pythia8.delete_BeamParticle
//    __del__ = lambda self: None
//BeamParticle_swigregister = _pythia8.BeamParticle_swigregister
//BeamParticle_swigregister(BeamParticle)
//
//class BoseEinsteinHadron(_object):
//    """
//The BoseEinsteinHadron class is a simple container for studied hadrons.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, BoseEinsteinHadron, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, BoseEinsteinHadron, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_BoseEinsteinHadron(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["id"] = _pythia8.BoseEinsteinHadron_id_set
//    __swig_getmethods__["id"] = _pythia8.BoseEinsteinHadron_id_get
//    if _newclass:
//        id = _swig_property(_pythia8.BoseEinsteinHadron_id_get, _pythia8.BoseEinsteinHadron_id_set)
//    __swig_setmethods__["iPos"] = _pythia8.BoseEinsteinHadron_iPos_set
//    __swig_getmethods__["iPos"] = _pythia8.BoseEinsteinHadron_iPos_get
//    if _newclass:
//        iPos = _swig_property(_pythia8.BoseEinsteinHadron_iPos_get, _pythia8.BoseEinsteinHadron_iPos_set)
//    __swig_setmethods__["p"] = _pythia8.BoseEinsteinHadron_p_set
//    __swig_getmethods__["p"] = _pythia8.BoseEinsteinHadron_p_get
//    if _newclass:
//        p = _swig_property(_pythia8.BoseEinsteinHadron_p_get, _pythia8.BoseEinsteinHadron_p_set)
//    __swig_setmethods__["pShift"] = _pythia8.BoseEinsteinHadron_pShift_set
//    __swig_getmethods__["pShift"] = _pythia8.BoseEinsteinHadron_pShift_get
//    if _newclass:
//        pShift = _swig_property(_pythia8.BoseEinsteinHadron_pShift_get, _pythia8.BoseEinsteinHadron_pShift_set)
//    __swig_setmethods__["pComp"] = _pythia8.BoseEinsteinHadron_pComp_set
//    __swig_getmethods__["pComp"] = _pythia8.BoseEinsteinHadron_pComp_get
//    if _newclass:
//        pComp = _swig_property(_pythia8.BoseEinsteinHadron_pComp_get, _pythia8.BoseEinsteinHadron_pComp_set)
//    __swig_setmethods__["m2"] = _pythia8.BoseEinsteinHadron_m2_set
//    __swig_getmethods__["m2"] = _pythia8.BoseEinsteinHadron_m2_get
//    if _newclass:
//        m2 = _swig_property(_pythia8.BoseEinsteinHadron_m2_get, _pythia8.BoseEinsteinHadron_m2_set)
//    __swig_destroy__ = _pythia8.delete_BoseEinsteinHadron
//    __del__ = lambda self: None
//BoseEinsteinHadron_swigregister = _pythia8.BoseEinsteinHadron_swigregister
//BoseEinsteinHadron_swigregister(BoseEinsteinHadron)
//
//class BoseEinstein(_object):
//    """
//The BoseEinstein class shifts the momenta of identical particles relative
//to each other, to simulate Bose-Einstein effects to some approximation.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, BoseEinstein, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, BoseEinstein, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_BoseEinstein()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, infoPtrIn, settings, particleData):
//        """
//Find settings. Precalculate table used to find momentum shifts.
//"""
//        return _pythia8.BoseEinstein_init(self, infoPtrIn, settings, particleData)
//
//    def shiftEvent(self, event):
//        """
//Perform Bose-Einstein corrections on an event.
//"""
//        return _pythia8.BoseEinstein_shiftEvent(self, event)
//    __swig_destroy__ = _pythia8.delete_BoseEinstein
//    __del__ = lambda self: None
//BoseEinstein_swigregister = _pythia8.BoseEinstein_swigregister
//BoseEinstein_swigregister(BoseEinstein)
//
//class ColourTracing(_object):
//    """
//ColourTracing class. It is used to trace colours within the event record.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ColourTracing, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, ColourTracing, name)
//    __repr__ = _swig_repr
//
//    def init(self, infoPtrIn):
//        """
//"""
//        return _pythia8.ColourTracing_init(self, infoPtrIn)
//
//    def setupColList(self, event):
//        """
//Setup the colour lists.
//"""
//        return _pythia8.ColourTracing_setupColList(self, event)
//
//    def traceFromAcol(self, indxCol, event, iJun, iCol, iParton):
//        """
//Trace a colour line, from a colour, from an anticolour, or in loop.
//"""
//        return _pythia8.ColourTracing_traceFromAcol(self, indxCol, event, iJun, iCol, iParton)
//
//    def traceFromCol(self, indxCol, event, iJun, iCol, iParton):
//        """
//"""
//        return _pythia8.ColourTracing_traceFromCol(self, indxCol, event, iJun, iCol, iParton)
//
//    def traceInLoop(self, event, iParton):
//        """
//"""
//        return _pythia8.ColourTracing_traceInLoop(self, event, iParton)
//
//    def finished(self):
//        """
//"""
//        return _pythia8.ColourTracing_finished(self)
//
//    def colFinished(self):
//        """
//"""
//        return _pythia8.ColourTracing_colFinished(self)
//
//    def getJunChains(self, event):
//        """
//Get junction chains where the junctions are directly connected.
//"""
//        return _pythia8.ColourTracing_getJunChains(self, event)
//
//    def __init__(self):
//        this = _pythia8.new_ColourTracing()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ColourTracing
//    __del__ = lambda self: None
//ColourTracing_swigregister = _pythia8.ColourTracing_swigregister
//ColourTracing_swigregister(ColourTracing)
//
//class GammaKinematics(_object):
//    """
//Class to sample the virtuality and transverse momentum of emitted photons.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, GammaKinematics, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, GammaKinematics, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_GammaKinematics()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, infoPtrIn, settingsPtrIn, rndmPtrIn, beamAPtrIn, beamBPtrIn):
//        """
//Sample the trial or final event kinematics.
//"""
//        return _pythia8.GammaKinematics_init(self, infoPtrIn, settingsPtrIn, rndmPtrIn, beamAPtrIn, beamBPtrIn)
//
//    def sampleKTgamma(self, nonDiff=False):
//        """
//"""
//        return _pythia8.GammaKinematics_sampleKTgamma(self, nonDiff)
//
//    def deriveKin(self, xGamma, Q2gamma, m2beam, eCM2):
//        """
//"""
//        return _pythia8.GammaKinematics_deriveKin(self, xGamma, Q2gamma, m2beam, eCM2)
//
//    def finalize(self):
//        """
//"""
//        return _pythia8.GammaKinematics_finalize(self)
//
//    def fluxWeight(self):
//        """
//"""
//        return _pythia8.GammaKinematics_fluxWeight(self)
//
//    def calcNewSHat(self, sHatOld):
//        """
//Calculate and return rescaled sHat according to the process.
//"""
//        return _pythia8.GammaKinematics_calcNewSHat(self, sHatOld)
//
//    def getQ2gamma1(self):
//        """
//Methods to pass along the sampled values.
//"""
//        return _pythia8.GammaKinematics_getQ2gamma1(self)
//
//    def getQ2gamma2(self):
//        """
//"""
//        return _pythia8.GammaKinematics_getQ2gamma2(self)
//
//    def getQ2min1(self):
//        """
//"""
//        return _pythia8.GammaKinematics_getQ2min1(self)
//
//    def getQ2min2(self):
//        """
//"""
//        return _pythia8.GammaKinematics_getQ2min2(self)
//
//    def getPhi1(self):
//        """
//"""
//        return _pythia8.GammaKinematics_getPhi1(self)
//
//    def getPhi2(self):
//        """
//"""
//        return _pythia8.GammaKinematics_getPhi2(self)
//
//    def getKT1(self):
//        """
//"""
//        return _pythia8.GammaKinematics_getKT1(self)
//
//    def getKT2(self):
//        """
//"""
//        return _pythia8.GammaKinematics_getKT2(self)
//
//    def eCMsub(self):
//        """
//"""
//        return _pythia8.GammaKinematics_eCMsub(self)
//    __swig_destroy__ = _pythia8.delete_GammaKinematics
//    __del__ = lambda self: None
//GammaKinematics_swigregister = _pythia8.GammaKinematics_swigregister
//GammaKinematics_swigregister(GammaKinematics)
//
//class HardProcess(_object):
//    """
//Declaration of hard process class
//This class holds information on the desired hard 2->2 process
//for the merging.
//This class is a container class for History class use.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HardProcess, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, HardProcess, name)
//    __repr__ = _swig_repr
//    __swig_setmethods__["hardIncoming1"] = _pythia8.HardProcess_hardIncoming1_set
//    __swig_getmethods__["hardIncoming1"] = _pythia8.HardProcess_hardIncoming1_get
//    if _newclass:
//        hardIncoming1 = _swig_property(_pythia8.HardProcess_hardIncoming1_get, _pythia8.HardProcess_hardIncoming1_set)
//    __swig_setmethods__["hardIncoming2"] = _pythia8.HardProcess_hardIncoming2_set
//    __swig_getmethods__["hardIncoming2"] = _pythia8.HardProcess_hardIncoming2_get
//    if _newclass:
//        hardIncoming2 = _swig_property(_pythia8.HardProcess_hardIncoming2_get, _pythia8.HardProcess_hardIncoming2_set)
//    __swig_setmethods__["hardOutgoing1"] = _pythia8.HardProcess_hardOutgoing1_set
//    __swig_getmethods__["hardOutgoing1"] = _pythia8.HardProcess_hardOutgoing1_get
//    if _newclass:
//        hardOutgoing1 = _swig_property(_pythia8.HardProcess_hardOutgoing1_get, _pythia8.HardProcess_hardOutgoing1_set)
//    __swig_setmethods__["hardOutgoing2"] = _pythia8.HardProcess_hardOutgoing2_set
//    __swig_getmethods__["hardOutgoing2"] = _pythia8.HardProcess_hardOutgoing2_get
//    if _newclass:
//        hardOutgoing2 = _swig_property(_pythia8.HardProcess_hardOutgoing2_get, _pythia8.HardProcess_hardOutgoing2_set)
//    __swig_setmethods__["hardIntermediate"] = _pythia8.HardProcess_hardIntermediate_set
//    __swig_getmethods__["hardIntermediate"] = _pythia8.HardProcess_hardIntermediate_get
//    if _newclass:
//        hardIntermediate = _swig_property(_pythia8.HardProcess_hardIntermediate_get, _pythia8.HardProcess_hardIntermediate_set)
//    __swig_setmethods__["state"] = _pythia8.HardProcess_state_set
//    __swig_getmethods__["state"] = _pythia8.HardProcess_state_get
//    if _newclass:
//        state = _swig_property(_pythia8.HardProcess_state_get, _pythia8.HardProcess_state_set)
//    __swig_setmethods__["PosOutgoing1"] = _pythia8.HardProcess_PosOutgoing1_set
//    __swig_getmethods__["PosOutgoing1"] = _pythia8.HardProcess_PosOutgoing1_get
//    if _newclass:
//        PosOutgoing1 = _swig_property(_pythia8.HardProcess_PosOutgoing1_get, _pythia8.HardProcess_PosOutgoing1_set)
//    __swig_setmethods__["PosOutgoing2"] = _pythia8.HardProcess_PosOutgoing2_set
//    __swig_getmethods__["PosOutgoing2"] = _pythia8.HardProcess_PosOutgoing2_get
//    if _newclass:
//        PosOutgoing2 = _swig_property(_pythia8.HardProcess_PosOutgoing2_get, _pythia8.HardProcess_PosOutgoing2_set)
//    __swig_setmethods__["PosIntermediate"] = _pythia8.HardProcess_PosIntermediate_set
//    __swig_getmethods__["PosIntermediate"] = _pythia8.HardProcess_PosIntermediate_get
//    if _newclass:
//        PosIntermediate = _swig_property(_pythia8.HardProcess_PosIntermediate_get, _pythia8.HardProcess_PosIntermediate_set)
//    __swig_setmethods__["tms"] = _pythia8.HardProcess_tms_set
//    __swig_getmethods__["tms"] = _pythia8.HardProcess_tms_get
//    if _newclass:
//        tms = _swig_property(_pythia8.HardProcess_tms_get, _pythia8.HardProcess_tms_set)
//    __swig_destroy__ = _pythia8.delete_HardProcess
//    __del__ = lambda self: None
//
//    def __init__(self, *args):
//        """
//Constructor with path to LHE file
//"""
//        this = _pythia8.new_HardProcess(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initOnProcess(self, process, particleData):
//        """
//Constructor with core process input
//"""
//        return _pythia8.HardProcess_initOnProcess(self, process, particleData)
//
//    def initOnLHEF(self, LHEfile, particleData):
//        """
//Constructor with path to LHE file input
//"""
//        return _pythia8.HardProcess_initOnLHEF(self, LHEfile, particleData)
//
//    def translateLHEFString(self, LHEpath):
//        """
//Function to access the LHE file and read relevant information
//"""
//        return _pythia8.HardProcess_translateLHEFString(self, LHEpath)
//
//    def translateProcessString(self, process):
//        """
//Function to translate the process string (in MG/ME notation)
//"""
//        return _pythia8.HardProcess_translateProcessString(self, process)
//
//    def clear(self):
//        """
//Function to clear hard process information
//"""
//        return _pythia8.HardProcess_clear(self)
//
//    def allowCandidates(self, iPos, Pos1, Pos2, event):
//        """
//Function to check whether the sets of candidates Pos1, Pos2, together
//with the proposed candidate iPos give an allowed hard process state
//"""
//        return _pythia8.HardProcess_allowCandidates(self, iPos, Pos1, Pos2, event)
//
//    def storeCandidates(self, event, process):
//        """
//Function to identify the hard subprocess in the current event
//"""
//        return _pythia8.HardProcess_storeCandidates(self, event, process)
//
//    def matchesAnyOutgoing(self, iPos, event):
//        """
//Function to check if the particle event[iPos] matches any of
//the stored outgoing particles of the hard subprocess
//"""
//        return _pythia8.HardProcess_matchesAnyOutgoing(self, iPos, event)
//
//    def findOtherCandidates(self, iPos, event, doReplace):
//        """
//Function to check if instead of the particle event[iCandidate], another
//particle could serve as part of the hard process. Assumes that iCandidate
//is already stored as part of the hard process.
//"""
//        return _pythia8.HardProcess_findOtherCandidates(self, iPos, event, doReplace)
//
//    def exchangeCandidates(self, candidates1, candidates2, further1, further2):
//        """
//Function to exchange a stored hard process candidate with another choice.
//"""
//        return _pythia8.HardProcess_exchangeCandidates(self, candidates1, candidates2, further1, further2)
//
//    def nQuarksOut(self):
//        """
//Function to get the number of coloured final state partons in the
//hard process
//"""
//        return _pythia8.HardProcess_nQuarksOut(self)
//
//    def nLeptonOut(self):
//        """
//Function to get the number of uncoloured final state particles in the
//hard process
//"""
//        return _pythia8.HardProcess_nLeptonOut(self)
//
//    def nBosonsOut(self):
//        """
//Function to get the number of electroweak final state bosons in the
//hard process
//"""
//        return _pythia8.HardProcess_nBosonsOut(self)
//
//    def nQuarksIn(self):
//        """
//Function to get the number of coloured initial state partons in the
//hard process
//"""
//        return _pythia8.HardProcess_nQuarksIn(self)
//
//    def nLeptonIn(self):
//        """
//Function to get the number of uncoloured initial state particles in the
//hard process
//"""
//        return _pythia8.HardProcess_nLeptonIn(self)
//
//    def hasResInCurrent(self):
//        """
//Function to report if a resonace decay was found in the 2->2 sub-process
//of the  current state
//"""
//        return _pythia8.HardProcess_hasResInCurrent(self)
//
//    def nResInCurrent(self):
//        """
//Function to report the number of resonace decays in the 2->2 sub-process
//of the  current state
//"""
//        return _pythia8.HardProcess_nResInCurrent(self)
//
//    def hasResInProc(self):
//        """
//Function to report if a resonace decay was found in the 2->2 hard process
//"""
//        return _pythia8.HardProcess_hasResInProc(self)
//
//    def listCandidates(self):
//        """
//Function to print the hard process candidates in the
//Matrix element state (for debug)
//"""
//        return _pythia8.HardProcess_listCandidates(self)
//
//    def __str__(self):
//        return _pythia8.HardProcess___str__(self)
//HardProcess_swigregister = _pythia8.HardProcess_swigregister
//HardProcess_swigregister(HardProcess)
//
//class MergingHooks(_object):
//    """
//MergingHooks is base class for user input to the merging procedure.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, MergingHooks, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, MergingHooks, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        if self.__class__ == MergingHooks:
//            _self = None
//        else:
//            _self = self
//        this = _pythia8.new_MergingHooks(_self, )
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_MergingHooks
//    __del__ = lambda self: None
//
//    def tmsDefinition(self, event):
//        return _pythia8.MergingHooks_tmsDefinition(self, event)
//
//    def dampenIfFailCuts(self, inEvent):
//        return _pythia8.MergingHooks_dampenIfFailCuts(self, inEvent)
//
//    def canCutOnRecState(self):
//        return _pythia8.MergingHooks_canCutOnRecState(self)
//
//    def doCutOnRecState(self, event):
//        return _pythia8.MergingHooks_doCutOnRecState(self, event)
//
//    def canVetoTrialEmission(self):
//        return _pythia8.MergingHooks_canVetoTrialEmission(self)
//
//    def doVetoTrialEmission(self, arg0, arg1):
//        return _pythia8.MergingHooks_doVetoTrialEmission(self, arg0, arg1)
//
//    def hardProcessME(self, inEvent):
//        return _pythia8.MergingHooks_hardProcessME(self, inEvent)
//
//    def init(self):
//        return _pythia8.MergingHooks_init(self)
//
//    def initPtr(self, settingsPtrIn, infoPtrIn, particleDataPtrIn, partonSystemsPtrIn):
//        return _pythia8.MergingHooks_initPtr(self, settingsPtrIn, infoPtrIn, particleDataPtrIn, partonSystemsPtrIn)
//
//    def tmsCut(self):
//        return _pythia8.MergingHooks_tmsCut(self)
//
//    def tms(self, *args):
//        return _pythia8.MergingHooks_tms(self, *args)
//
//    def dRijMS(self):
//        return _pythia8.MergingHooks_dRijMS(self)
//
//    def pTiMS(self):
//        return _pythia8.MergingHooks_pTiMS(self)
//
//    def QijMS(self):
//        return _pythia8.MergingHooks_QijMS(self)
//
//    def nMaxJets(self):
//        return _pythia8.MergingHooks_nMaxJets(self)
//
//    def nMaxJetsNLO(self):
//        return _pythia8.MergingHooks_nMaxJetsNLO(self)
//
//    def getProcessString(self):
//        return _pythia8.MergingHooks_getProcessString(self)
//
//    def nHardOutPartons(self):
//        return _pythia8.MergingHooks_nHardOutPartons(self)
//
//    def nHardOutLeptons(self):
//        return _pythia8.MergingHooks_nHardOutLeptons(self)
//
//    def nHardOutBosons(self):
//        return _pythia8.MergingHooks_nHardOutBosons(self)
//
//    def nHardInPartons(self):
//        return _pythia8.MergingHooks_nHardInPartons(self)
//
//    def nHardInLeptons(self):
//        return _pythia8.MergingHooks_nHardInLeptons(self)
//
//    def nResInCurrent(self):
//        return _pythia8.MergingHooks_nResInCurrent(self)
//
//    def doUserMerging(self):
//        return _pythia8.MergingHooks_doUserMerging(self)
//
//    def doMGMerging(self):
//        return _pythia8.MergingHooks_doMGMerging(self)
//
//    def doKTMerging(self):
//        return _pythia8.MergingHooks_doKTMerging(self)
//
//    def doPTLundMerging(self):
//        return _pythia8.MergingHooks_doPTLundMerging(self)
//
//    def doCutBasedMerging(self):
//        return _pythia8.MergingHooks_doCutBasedMerging(self)
//
//    def doCKKWLMerging(self):
//        return _pythia8.MergingHooks_doCKKWLMerging(self)
//
//    def doUMEPSTree(self):
//        return _pythia8.MergingHooks_doUMEPSTree(self)
//
//    def doUMEPSSubt(self):
//        return _pythia8.MergingHooks_doUMEPSSubt(self)
//
//    def doUMEPSMerging(self):
//        return _pythia8.MergingHooks_doUMEPSMerging(self)
//
//    def doNL3Tree(self):
//        return _pythia8.MergingHooks_doNL3Tree(self)
//
//    def doNL3Loop(self):
//        return _pythia8.MergingHooks_doNL3Loop(self)
//
//    def doNL3Subt(self):
//        return _pythia8.MergingHooks_doNL3Subt(self)
//
//    def doNL3Merging(self):
//        return _pythia8.MergingHooks_doNL3Merging(self)
//
//    def doUNLOPSTree(self):
//        return _pythia8.MergingHooks_doUNLOPSTree(self)
//
//    def doUNLOPSLoop(self):
//        return _pythia8.MergingHooks_doUNLOPSLoop(self)
//
//    def doUNLOPSSubt(self):
//        return _pythia8.MergingHooks_doUNLOPSSubt(self)
//
//    def doUNLOPSSubtNLO(self):
//        return _pythia8.MergingHooks_doUNLOPSSubtNLO(self)
//
//    def doUNLOPSMerging(self):
//        return _pythia8.MergingHooks_doUNLOPSMerging(self)
//
//    def nRecluster(self):
//        return _pythia8.MergingHooks_nRecluster(self)
//
//    def nRequested(self):
//        return _pythia8.MergingHooks_nRequested(self)
//
//    def isFirstEmission(self, event):
//        return _pythia8.MergingHooks_isFirstEmission(self, event)
//
//    def hasEffectiveG2EW(self):
//        return _pythia8.MergingHooks_hasEffectiveG2EW(self)
//
//    def allowEffectiveVertex(self, arg2, out):
//        return _pythia8.MergingHooks_allowEffectiveVertex(self, arg2, out)
//
//    def bareEvent(self, inputEventIn, storeInputEvent):
//        return _pythia8.MergingHooks_bareEvent(self, inputEventIn, storeInputEvent)
//
//    def reattachResonanceDecays(self, process):
//        return _pythia8.MergingHooks_reattachResonanceDecays(self, process)
//
//    def isInHard(self, iPos, event):
//        return _pythia8.MergingHooks_isInHard(self, iPos, event)
//
//    def getNumberOfClusteringSteps(self, event, resetNjetMax=False):
//        return _pythia8.MergingHooks_getNumberOfClusteringSteps(self, event, resetNjetMax)
//
//    def orderHistories(self, doOrderHistoriesIn):
//        return _pythia8.MergingHooks_orderHistories(self, doOrderHistoriesIn)
//
//    def allowCutOnRecState(self, doCutOnRecStateIn):
//        return _pythia8.MergingHooks_allowCutOnRecState(self, doCutOnRecStateIn)
//
//    def doWeakClustering(self, doWeakClusteringIn):
//        return _pythia8.MergingHooks_doWeakClustering(self, doWeakClusteringIn)
//
//    def checkAgainstCut(self, particle):
//        return _pythia8.MergingHooks_checkAgainstCut(self, particle)
//
//    def rhoms(self, event, withColour):
//        return _pythia8.MergingHooks_rhoms(self, event, withColour)
//
//    def kTms(self, event):
//        return _pythia8.MergingHooks_kTms(self, event)
//
//    def cutbasedms(self, event):
//        return _pythia8.MergingHooks_cutbasedms(self, event)
//
//    def doIgnoreEmissions(self, doIgnoreIn):
//        return _pythia8.MergingHooks_doIgnoreEmissions(self, doIgnoreIn)
//
//    def canVetoEmission(self):
//        return _pythia8.MergingHooks_canVetoEmission(self)
//
//    def doVetoEmission(self, arg0):
//        return _pythia8.MergingHooks_doVetoEmission(self, arg0)
//    __swig_setmethods__["useShowerPluginSave"] = _pythia8.MergingHooks_useShowerPluginSave_set
//    __swig_getmethods__["useShowerPluginSave"] = _pythia8.MergingHooks_useShowerPluginSave_get
//    if _newclass:
//        useShowerPluginSave = _swig_property(_pythia8.MergingHooks_useShowerPluginSave_get, _pythia8.MergingHooks_useShowerPluginSave_set)
//
//    def useShowerPlugin(self):
//        return _pythia8.MergingHooks_useShowerPlugin(self)
//
//    def includeWGTinXSEC(self):
//        return _pythia8.MergingHooks_includeWGTinXSEC(self)
//
//    def nHardNow(self):
//        return _pythia8.MergingHooks_nHardNow(self)
//
//    def tmsHardNow(self):
//        return _pythia8.MergingHooks_tmsHardNow(self)
//
//    def nJetsNow(self):
//        return _pythia8.MergingHooks_nJetsNow(self)
//
//    def tmsNow(self, *args):
//        return _pythia8.MergingHooks_tmsNow(self, *args)
//
//    def setHardProcessPtr(self, hardProcIn):
//        return _pythia8.MergingHooks_setHardProcessPtr(self, hardProcIn)
//    __swig_setmethods__["useOwnHardProcess"] = _pythia8.MergingHooks_useOwnHardProcess_set
//    __swig_getmethods__["useOwnHardProcess"] = _pythia8.MergingHooks_useOwnHardProcess_get
//    if _newclass:
//        useOwnHardProcess = _swig_property(_pythia8.MergingHooks_useOwnHardProcess_get, _pythia8.MergingHooks_useOwnHardProcess_set)
//    __swig_setmethods__["hardProcess"] = _pythia8.MergingHooks_hardProcess_set
//    __swig_getmethods__["hardProcess"] = _pythia8.MergingHooks_hardProcess_get
//    if _newclass:
//        hardProcess = _swig_property(_pythia8.MergingHooks_hardProcess_get, _pythia8.MergingHooks_hardProcess_set)
//    __swig_setmethods__["infoPtr"] = _pythia8.MergingHooks_infoPtr_set
//    __swig_getmethods__["infoPtr"] = _pythia8.MergingHooks_infoPtr_get
//    if _newclass:
//        infoPtr = _swig_property(_pythia8.MergingHooks_infoPtr_get, _pythia8.MergingHooks_infoPtr_set)
//    __swig_setmethods__["settingsPtr"] = _pythia8.MergingHooks_settingsPtr_set
//    __swig_getmethods__["settingsPtr"] = _pythia8.MergingHooks_settingsPtr_get
//    if _newclass:
//        settingsPtr = _swig_property(_pythia8.MergingHooks_settingsPtr_get, _pythia8.MergingHooks_settingsPtr_set)
//    __swig_setmethods__["particleDataPtr"] = _pythia8.MergingHooks_particleDataPtr_set
//    __swig_getmethods__["particleDataPtr"] = _pythia8.MergingHooks_particleDataPtr_get
//    if _newclass:
//        particleDataPtr = _swig_property(_pythia8.MergingHooks_particleDataPtr_get, _pythia8.MergingHooks_particleDataPtr_set)
//    __swig_setmethods__["partonSystemsPtr"] = _pythia8.MergingHooks_partonSystemsPtr_set
//    __swig_getmethods__["partonSystemsPtr"] = _pythia8.MergingHooks_partonSystemsPtr_get
//    if _newclass:
//        partonSystemsPtr = _swig_property(_pythia8.MergingHooks_partonSystemsPtr_get, _pythia8.MergingHooks_partonSystemsPtr_set)
//    __swig_setmethods__["showers"] = _pythia8.MergingHooks_showers_set
//    __swig_getmethods__["showers"] = _pythia8.MergingHooks_showers_get
//    if _newclass:
//        showers = _swig_property(_pythia8.MergingHooks_showers_get, _pythia8.MergingHooks_showers_set)
//
//    def setShowerPointer(self, psIn):
//        return _pythia8.MergingHooks_setShowerPointer(self, psIn)
//    __swig_setmethods__["AlphaS_FSRSave"] = _pythia8.MergingHooks_AlphaS_FSRSave_set
//    __swig_getmethods__["AlphaS_FSRSave"] = _pythia8.MergingHooks_AlphaS_FSRSave_get
//    if _newclass:
//        AlphaS_FSRSave = _swig_property(_pythia8.MergingHooks_AlphaS_FSRSave_get, _pythia8.MergingHooks_AlphaS_FSRSave_set)
//    __swig_setmethods__["AlphaS_ISRSave"] = _pythia8.MergingHooks_AlphaS_ISRSave_set
//    __swig_getmethods__["AlphaS_ISRSave"] = _pythia8.MergingHooks_AlphaS_ISRSave_get
//    if _newclass:
//        AlphaS_ISRSave = _swig_property(_pythia8.MergingHooks_AlphaS_ISRSave_get, _pythia8.MergingHooks_AlphaS_ISRSave_set)
//    __swig_setmethods__["AlphaEM_FSRSave"] = _pythia8.MergingHooks_AlphaEM_FSRSave_set
//    __swig_getmethods__["AlphaEM_FSRSave"] = _pythia8.MergingHooks_AlphaEM_FSRSave_get
//    if _newclass:
//        AlphaEM_FSRSave = _swig_property(_pythia8.MergingHooks_AlphaEM_FSRSave_get, _pythia8.MergingHooks_AlphaEM_FSRSave_set)
//    __swig_setmethods__["AlphaEM_ISRSave"] = _pythia8.MergingHooks_AlphaEM_ISRSave_set
//    __swig_getmethods__["AlphaEM_ISRSave"] = _pythia8.MergingHooks_AlphaEM_ISRSave_get
//    if _newclass:
//        AlphaEM_ISRSave = _swig_property(_pythia8.MergingHooks_AlphaEM_ISRSave_get, _pythia8.MergingHooks_AlphaEM_ISRSave_set)
//    __swig_setmethods__["lheInputFile"] = _pythia8.MergingHooks_lheInputFile_set
//    __swig_getmethods__["lheInputFile"] = _pythia8.MergingHooks_lheInputFile_get
//    if _newclass:
//        lheInputFile = _swig_property(_pythia8.MergingHooks_lheInputFile_get, _pythia8.MergingHooks_lheInputFile_set)
//    __swig_setmethods__["doUserMergingSave"] = _pythia8.MergingHooks_doUserMergingSave_set
//    __swig_getmethods__["doUserMergingSave"] = _pythia8.MergingHooks_doUserMergingSave_get
//    if _newclass:
//        doUserMergingSave = _swig_property(_pythia8.MergingHooks_doUserMergingSave_get, _pythia8.MergingHooks_doUserMergingSave_set)
//    __swig_setmethods__["doMGMergingSave"] = _pythia8.MergingHooks_doMGMergingSave_set
//    __swig_getmethods__["doMGMergingSave"] = _pythia8.MergingHooks_doMGMergingSave_get
//    if _newclass:
//        doMGMergingSave = _swig_property(_pythia8.MergingHooks_doMGMergingSave_get, _pythia8.MergingHooks_doMGMergingSave_set)
//    __swig_setmethods__["doKTMergingSave"] = _pythia8.MergingHooks_doKTMergingSave_set
//    __swig_getmethods__["doKTMergingSave"] = _pythia8.MergingHooks_doKTMergingSave_get
//    if _newclass:
//        doKTMergingSave = _swig_property(_pythia8.MergingHooks_doKTMergingSave_get, _pythia8.MergingHooks_doKTMergingSave_set)
//    __swig_setmethods__["doPTLundMergingSave"] = _pythia8.MergingHooks_doPTLundMergingSave_set
//    __swig_getmethods__["doPTLundMergingSave"] = _pythia8.MergingHooks_doPTLundMergingSave_get
//    if _newclass:
//        doPTLundMergingSave = _swig_property(_pythia8.MergingHooks_doPTLundMergingSave_get, _pythia8.MergingHooks_doPTLundMergingSave_set)
//    __swig_setmethods__["doCutBasedMergingSave"] = _pythia8.MergingHooks_doCutBasedMergingSave_set
//    __swig_getmethods__["doCutBasedMergingSave"] = _pythia8.MergingHooks_doCutBasedMergingSave_get
//    if _newclass:
//        doCutBasedMergingSave = _swig_property(_pythia8.MergingHooks_doCutBasedMergingSave_get, _pythia8.MergingHooks_doCutBasedMergingSave_set)
//    __swig_setmethods__["includeMassiveSave"] = _pythia8.MergingHooks_includeMassiveSave_set
//    __swig_getmethods__["includeMassiveSave"] = _pythia8.MergingHooks_includeMassiveSave_get
//    if _newclass:
//        includeMassiveSave = _swig_property(_pythia8.MergingHooks_includeMassiveSave_get, _pythia8.MergingHooks_includeMassiveSave_set)
//    __swig_setmethods__["enforceStrongOrderingSave"] = _pythia8.MergingHooks_enforceStrongOrderingSave_set
//    __swig_getmethods__["enforceStrongOrderingSave"] = _pythia8.MergingHooks_enforceStrongOrderingSave_get
//    if _newclass:
//        enforceStrongOrderingSave = _swig_property(_pythia8.MergingHooks_enforceStrongOrderingSave_get, _pythia8.MergingHooks_enforceStrongOrderingSave_set)
//    __swig_setmethods__["orderInRapiditySave"] = _pythia8.MergingHooks_orderInRapiditySave_set
//    __swig_getmethods__["orderInRapiditySave"] = _pythia8.MergingHooks_orderInRapiditySave_get
//    if _newclass:
//        orderInRapiditySave = _swig_property(_pythia8.MergingHooks_orderInRapiditySave_get, _pythia8.MergingHooks_orderInRapiditySave_set)
//    __swig_setmethods__["pickByFullPSave"] = _pythia8.MergingHooks_pickByFullPSave_set
//    __swig_getmethods__["pickByFullPSave"] = _pythia8.MergingHooks_pickByFullPSave_get
//    if _newclass:
//        pickByFullPSave = _swig_property(_pythia8.MergingHooks_pickByFullPSave_get, _pythia8.MergingHooks_pickByFullPSave_set)
//    __swig_setmethods__["pickByPoPT2Save"] = _pythia8.MergingHooks_pickByPoPT2Save_set
//    __swig_getmethods__["pickByPoPT2Save"] = _pythia8.MergingHooks_pickByPoPT2Save_get
//    if _newclass:
//        pickByPoPT2Save = _swig_property(_pythia8.MergingHooks_pickByPoPT2Save_get, _pythia8.MergingHooks_pickByPoPT2Save_set)
//    __swig_setmethods__["includeRedundantSave"] = _pythia8.MergingHooks_includeRedundantSave_set
//    __swig_getmethods__["includeRedundantSave"] = _pythia8.MergingHooks_includeRedundantSave_get
//    if _newclass:
//        includeRedundantSave = _swig_property(_pythia8.MergingHooks_includeRedundantSave_get, _pythia8.MergingHooks_includeRedundantSave_set)
//    __swig_setmethods__["pickBySumPTSave"] = _pythia8.MergingHooks_pickBySumPTSave_set
//    __swig_getmethods__["pickBySumPTSave"] = _pythia8.MergingHooks_pickBySumPTSave_get
//    if _newclass:
//        pickBySumPTSave = _swig_property(_pythia8.MergingHooks_pickBySumPTSave_get, _pythia8.MergingHooks_pickBySumPTSave_set)
//    __swig_setmethods__["allowColourShufflingSave"] = _pythia8.MergingHooks_allowColourShufflingSave_set
//    __swig_getmethods__["allowColourShufflingSave"] = _pythia8.MergingHooks_allowColourShufflingSave_get
//    if _newclass:
//        allowColourShufflingSave = _swig_property(_pythia8.MergingHooks_allowColourShufflingSave_get, _pythia8.MergingHooks_allowColourShufflingSave_set)
//    __swig_setmethods__["resetHardQRenSave"] = _pythia8.MergingHooks_resetHardQRenSave_set
//    __swig_getmethods__["resetHardQRenSave"] = _pythia8.MergingHooks_resetHardQRenSave_get
//    if _newclass:
//        resetHardQRenSave = _swig_property(_pythia8.MergingHooks_resetHardQRenSave_get, _pythia8.MergingHooks_resetHardQRenSave_set)
//    __swig_setmethods__["resetHardQFacSave"] = _pythia8.MergingHooks_resetHardQFacSave_set
//    __swig_getmethods__["resetHardQFacSave"] = _pythia8.MergingHooks_resetHardQFacSave_get
//    if _newclass:
//        resetHardQFacSave = _swig_property(_pythia8.MergingHooks_resetHardQFacSave_get, _pythia8.MergingHooks_resetHardQFacSave_set)
//    __swig_setmethods__["unorderedScalePrescipSave"] = _pythia8.MergingHooks_unorderedScalePrescipSave_set
//    __swig_getmethods__["unorderedScalePrescipSave"] = _pythia8.MergingHooks_unorderedScalePrescipSave_get
//    if _newclass:
//        unorderedScalePrescipSave = _swig_property(_pythia8.MergingHooks_unorderedScalePrescipSave_get, _pythia8.MergingHooks_unorderedScalePrescipSave_set)
//    __swig_setmethods__["unorderedASscalePrescipSave"] = _pythia8.MergingHooks_unorderedASscalePrescipSave_set
//    __swig_getmethods__["unorderedASscalePrescipSave"] = _pythia8.MergingHooks_unorderedASscalePrescipSave_get
//    if _newclass:
//        unorderedASscalePrescipSave = _swig_property(_pythia8.MergingHooks_unorderedASscalePrescipSave_get, _pythia8.MergingHooks_unorderedASscalePrescipSave_set)
//    __swig_setmethods__["unorderedPDFscalePrescipSave"] = _pythia8.MergingHooks_unorderedPDFscalePrescipSave_set
//    __swig_getmethods__["unorderedPDFscalePrescipSave"] = _pythia8.MergingHooks_unorderedPDFscalePrescipSave_get
//    if _newclass:
//        unorderedPDFscalePrescipSave = _swig_property(_pythia8.MergingHooks_unorderedPDFscalePrescipSave_get, _pythia8.MergingHooks_unorderedPDFscalePrescipSave_set)
//    __swig_setmethods__["incompleteScalePrescipSave"] = _pythia8.MergingHooks_incompleteScalePrescipSave_set
//    __swig_getmethods__["incompleteScalePrescipSave"] = _pythia8.MergingHooks_incompleteScalePrescipSave_get
//    if _newclass:
//        incompleteScalePrescipSave = _swig_property(_pythia8.MergingHooks_incompleteScalePrescipSave_get, _pythia8.MergingHooks_incompleteScalePrescipSave_set)
//    __swig_setmethods__["ktTypeSave"] = _pythia8.MergingHooks_ktTypeSave_set
//    __swig_getmethods__["ktTypeSave"] = _pythia8.MergingHooks_ktTypeSave_get
//    if _newclass:
//        ktTypeSave = _swig_property(_pythia8.MergingHooks_ktTypeSave_get, _pythia8.MergingHooks_ktTypeSave_set)
//    __swig_setmethods__["nReclusterSave"] = _pythia8.MergingHooks_nReclusterSave_set
//    __swig_getmethods__["nReclusterSave"] = _pythia8.MergingHooks_nReclusterSave_get
//    if _newclass:
//        nReclusterSave = _swig_property(_pythia8.MergingHooks_nReclusterSave_get, _pythia8.MergingHooks_nReclusterSave_set)
//    __swig_setmethods__["nQuarksMergeSave"] = _pythia8.MergingHooks_nQuarksMergeSave_set
//    __swig_getmethods__["nQuarksMergeSave"] = _pythia8.MergingHooks_nQuarksMergeSave_get
//    if _newclass:
//        nQuarksMergeSave = _swig_property(_pythia8.MergingHooks_nQuarksMergeSave_get, _pythia8.MergingHooks_nQuarksMergeSave_set)
//    __swig_setmethods__["nRequestedSave"] = _pythia8.MergingHooks_nRequestedSave_set
//    __swig_getmethods__["nRequestedSave"] = _pythia8.MergingHooks_nRequestedSave_get
//    if _newclass:
//        nRequestedSave = _swig_property(_pythia8.MergingHooks_nRequestedSave_get, _pythia8.MergingHooks_nRequestedSave_set)
//    __swig_setmethods__["scaleSeparationFactorSave"] = _pythia8.MergingHooks_scaleSeparationFactorSave_set
//    __swig_getmethods__["scaleSeparationFactorSave"] = _pythia8.MergingHooks_scaleSeparationFactorSave_get
//    if _newclass:
//        scaleSeparationFactorSave = _swig_property(_pythia8.MergingHooks_scaleSeparationFactorSave_get, _pythia8.MergingHooks_scaleSeparationFactorSave_set)
//    __swig_setmethods__["nonJoinedNormSave"] = _pythia8.MergingHooks_nonJoinedNormSave_set
//    __swig_getmethods__["nonJoinedNormSave"] = _pythia8.MergingHooks_nonJoinedNormSave_get
//    if _newclass:
//        nonJoinedNormSave = _swig_property(_pythia8.MergingHooks_nonJoinedNormSave_get, _pythia8.MergingHooks_nonJoinedNormSave_set)
//    __swig_setmethods__["fsrInRecNormSave"] = _pythia8.MergingHooks_fsrInRecNormSave_set
//    __swig_getmethods__["fsrInRecNormSave"] = _pythia8.MergingHooks_fsrInRecNormSave_get
//    if _newclass:
//        fsrInRecNormSave = _swig_property(_pythia8.MergingHooks_fsrInRecNormSave_get, _pythia8.MergingHooks_fsrInRecNormSave_set)
//    __swig_setmethods__["herwigAcollFSRSave"] = _pythia8.MergingHooks_herwigAcollFSRSave_set
//    __swig_getmethods__["herwigAcollFSRSave"] = _pythia8.MergingHooks_herwigAcollFSRSave_get
//    if _newclass:
//        herwigAcollFSRSave = _swig_property(_pythia8.MergingHooks_herwigAcollFSRSave_get, _pythia8.MergingHooks_herwigAcollFSRSave_set)
//    __swig_setmethods__["herwigAcollISRSave"] = _pythia8.MergingHooks_herwigAcollISRSave_set
//    __swig_getmethods__["herwigAcollISRSave"] = _pythia8.MergingHooks_herwigAcollISRSave_get
//    if _newclass:
//        herwigAcollISRSave = _swig_property(_pythia8.MergingHooks_herwigAcollISRSave_get, _pythia8.MergingHooks_herwigAcollISRSave_set)
//    __swig_setmethods__["pT0ISRSave"] = _pythia8.MergingHooks_pT0ISRSave_set
//    __swig_getmethods__["pT0ISRSave"] = _pythia8.MergingHooks_pT0ISRSave_get
//    if _newclass:
//        pT0ISRSave = _swig_property(_pythia8.MergingHooks_pT0ISRSave_get, _pythia8.MergingHooks_pT0ISRSave_set)
//    __swig_setmethods__["pTcutSave"] = _pythia8.MergingHooks_pTcutSave_set
//    __swig_getmethods__["pTcutSave"] = _pythia8.MergingHooks_pTcutSave_get
//    if _newclass:
//        pTcutSave = _swig_property(_pythia8.MergingHooks_pTcutSave_get, _pythia8.MergingHooks_pTcutSave_set)
//    __swig_setmethods__["doNL3TreeSave"] = _pythia8.MergingHooks_doNL3TreeSave_set
//    __swig_getmethods__["doNL3TreeSave"] = _pythia8.MergingHooks_doNL3TreeSave_get
//    if _newclass:
//        doNL3TreeSave = _swig_property(_pythia8.MergingHooks_doNL3TreeSave_get, _pythia8.MergingHooks_doNL3TreeSave_set)
//    __swig_setmethods__["doNL3LoopSave"] = _pythia8.MergingHooks_doNL3LoopSave_set
//    __swig_getmethods__["doNL3LoopSave"] = _pythia8.MergingHooks_doNL3LoopSave_get
//    if _newclass:
//        doNL3LoopSave = _swig_property(_pythia8.MergingHooks_doNL3LoopSave_get, _pythia8.MergingHooks_doNL3LoopSave_set)
//    __swig_setmethods__["doNL3SubtSave"] = _pythia8.MergingHooks_doNL3SubtSave_set
//    __swig_getmethods__["doNL3SubtSave"] = _pythia8.MergingHooks_doNL3SubtSave_get
//    if _newclass:
//        doNL3SubtSave = _swig_property(_pythia8.MergingHooks_doNL3SubtSave_get, _pythia8.MergingHooks_doNL3SubtSave_set)
//    __swig_setmethods__["doUNLOPSTreeSave"] = _pythia8.MergingHooks_doUNLOPSTreeSave_set
//    __swig_getmethods__["doUNLOPSTreeSave"] = _pythia8.MergingHooks_doUNLOPSTreeSave_get
//    if _newclass:
//        doUNLOPSTreeSave = _swig_property(_pythia8.MergingHooks_doUNLOPSTreeSave_get, _pythia8.MergingHooks_doUNLOPSTreeSave_set)
//    __swig_setmethods__["doUNLOPSLoopSave"] = _pythia8.MergingHooks_doUNLOPSLoopSave_set
//    __swig_getmethods__["doUNLOPSLoopSave"] = _pythia8.MergingHooks_doUNLOPSLoopSave_get
//    if _newclass:
//        doUNLOPSLoopSave = _swig_property(_pythia8.MergingHooks_doUNLOPSLoopSave_get, _pythia8.MergingHooks_doUNLOPSLoopSave_set)
//    __swig_setmethods__["doUNLOPSSubtSave"] = _pythia8.MergingHooks_doUNLOPSSubtSave_set
//    __swig_getmethods__["doUNLOPSSubtSave"] = _pythia8.MergingHooks_doUNLOPSSubtSave_get
//    if _newclass:
//        doUNLOPSSubtSave = _swig_property(_pythia8.MergingHooks_doUNLOPSSubtSave_get, _pythia8.MergingHooks_doUNLOPSSubtSave_set)
//    __swig_setmethods__["doUNLOPSSubtNLOSave"] = _pythia8.MergingHooks_doUNLOPSSubtNLOSave_set
//    __swig_getmethods__["doUNLOPSSubtNLOSave"] = _pythia8.MergingHooks_doUNLOPSSubtNLOSave_get
//    if _newclass:
//        doUNLOPSSubtNLOSave = _swig_property(_pythia8.MergingHooks_doUNLOPSSubtNLOSave_get, _pythia8.MergingHooks_doUNLOPSSubtNLOSave_set)
//    __swig_setmethods__["doUMEPSTreeSave"] = _pythia8.MergingHooks_doUMEPSTreeSave_set
//    __swig_getmethods__["doUMEPSTreeSave"] = _pythia8.MergingHooks_doUMEPSTreeSave_get
//    if _newclass:
//        doUMEPSTreeSave = _swig_property(_pythia8.MergingHooks_doUMEPSTreeSave_get, _pythia8.MergingHooks_doUMEPSTreeSave_set)
//    __swig_setmethods__["doUMEPSSubtSave"] = _pythia8.MergingHooks_doUMEPSSubtSave_set
//    __swig_getmethods__["doUMEPSSubtSave"] = _pythia8.MergingHooks_doUMEPSSubtSave_get
//    if _newclass:
//        doUMEPSSubtSave = _swig_property(_pythia8.MergingHooks_doUMEPSSubtSave_get, _pythia8.MergingHooks_doUMEPSSubtSave_set)
//    __swig_setmethods__["doEstimateXSection"] = _pythia8.MergingHooks_doEstimateXSection_set
//    __swig_getmethods__["doEstimateXSection"] = _pythia8.MergingHooks_doEstimateXSection_get
//    if _newclass:
//        doEstimateXSection = _swig_property(_pythia8.MergingHooks_doEstimateXSection_get, _pythia8.MergingHooks_doEstimateXSection_set)
//    __swig_setmethods__["applyVeto"] = _pythia8.MergingHooks_applyVeto_set
//    __swig_getmethods__["applyVeto"] = _pythia8.MergingHooks_applyVeto_get
//    if _newclass:
//        applyVeto = _swig_property(_pythia8.MergingHooks_applyVeto_get, _pythia8.MergingHooks_applyVeto_set)
//    __swig_setmethods__["inputEvent"] = _pythia8.MergingHooks_inputEvent_set
//    __swig_getmethods__["inputEvent"] = _pythia8.MergingHooks_inputEvent_get
//    if _newclass:
//        inputEvent = _swig_property(_pythia8.MergingHooks_inputEvent_get, _pythia8.MergingHooks_inputEvent_set)
//    __swig_setmethods__["resonances"] = _pythia8.MergingHooks_resonances_set
//    __swig_getmethods__["resonances"] = _pythia8.MergingHooks_resonances_get
//    if _newclass:
//        resonances = _swig_property(_pythia8.MergingHooks_resonances_get, _pythia8.MergingHooks_resonances_set)
//    __swig_setmethods__["doRemoveDecayProducts"] = _pythia8.MergingHooks_doRemoveDecayProducts_set
//    __swig_getmethods__["doRemoveDecayProducts"] = _pythia8.MergingHooks_doRemoveDecayProducts_get
//    if _newclass:
//        doRemoveDecayProducts = _swig_property(_pythia8.MergingHooks_doRemoveDecayProducts_get, _pythia8.MergingHooks_doRemoveDecayProducts_set)
//    __swig_setmethods__["muMISave"] = _pythia8.MergingHooks_muMISave_set
//    __swig_getmethods__["muMISave"] = _pythia8.MergingHooks_muMISave_get
//    if _newclass:
//        muMISave = _swig_property(_pythia8.MergingHooks_muMISave_get, _pythia8.MergingHooks_muMISave_set)
//    __swig_setmethods__["kFactor0jSave"] = _pythia8.MergingHooks_kFactor0jSave_set
//    __swig_getmethods__["kFactor0jSave"] = _pythia8.MergingHooks_kFactor0jSave_get
//    if _newclass:
//        kFactor0jSave = _swig_property(_pythia8.MergingHooks_kFactor0jSave_get, _pythia8.MergingHooks_kFactor0jSave_set)
//    __swig_setmethods__["kFactor1jSave"] = _pythia8.MergingHooks_kFactor1jSave_set
//    __swig_getmethods__["kFactor1jSave"] = _pythia8.MergingHooks_kFactor1jSave_get
//    if _newclass:
//        kFactor1jSave = _swig_property(_pythia8.MergingHooks_kFactor1jSave_get, _pythia8.MergingHooks_kFactor1jSave_set)
//    __swig_setmethods__["kFactor2jSave"] = _pythia8.MergingHooks_kFactor2jSave_set
//    __swig_getmethods__["kFactor2jSave"] = _pythia8.MergingHooks_kFactor2jSave_get
//    if _newclass:
//        kFactor2jSave = _swig_property(_pythia8.MergingHooks_kFactor2jSave_get, _pythia8.MergingHooks_kFactor2jSave_set)
//    __swig_setmethods__["tmsValueSave"] = _pythia8.MergingHooks_tmsValueSave_set
//    __swig_getmethods__["tmsValueSave"] = _pythia8.MergingHooks_tmsValueSave_get
//    if _newclass:
//        tmsValueSave = _swig_property(_pythia8.MergingHooks_tmsValueSave_get, _pythia8.MergingHooks_tmsValueSave_set)
//    __swig_setmethods__["tmsValueNow"] = _pythia8.MergingHooks_tmsValueNow_set
//    __swig_getmethods__["tmsValueNow"] = _pythia8.MergingHooks_tmsValueNow_get
//    if _newclass:
//        tmsValueNow = _swig_property(_pythia8.MergingHooks_tmsValueNow_get, _pythia8.MergingHooks_tmsValueNow_set)
//    __swig_setmethods__["DparameterSave"] = _pythia8.MergingHooks_DparameterSave_set
//    __swig_getmethods__["DparameterSave"] = _pythia8.MergingHooks_DparameterSave_get
//    if _newclass:
//        DparameterSave = _swig_property(_pythia8.MergingHooks_DparameterSave_get, _pythia8.MergingHooks_DparameterSave_set)
//    __swig_setmethods__["nJetMaxSave"] = _pythia8.MergingHooks_nJetMaxSave_set
//    __swig_getmethods__["nJetMaxSave"] = _pythia8.MergingHooks_nJetMaxSave_get
//    if _newclass:
//        nJetMaxSave = _swig_property(_pythia8.MergingHooks_nJetMaxSave_get, _pythia8.MergingHooks_nJetMaxSave_set)
//    __swig_setmethods__["nJetMaxNLOSave"] = _pythia8.MergingHooks_nJetMaxNLOSave_set
//    __swig_getmethods__["nJetMaxNLOSave"] = _pythia8.MergingHooks_nJetMaxNLOSave_get
//    if _newclass:
//        nJetMaxNLOSave = _swig_property(_pythia8.MergingHooks_nJetMaxNLOSave_get, _pythia8.MergingHooks_nJetMaxNLOSave_set)
//    __swig_setmethods__["processSave"] = _pythia8.MergingHooks_processSave_set
//    __swig_getmethods__["processSave"] = _pythia8.MergingHooks_processSave_get
//    if _newclass:
//        processSave = _swig_property(_pythia8.MergingHooks_processSave_get, _pythia8.MergingHooks_processSave_set)
//    __swig_setmethods__["tmsListSave"] = _pythia8.MergingHooks_tmsListSave_set
//    __swig_getmethods__["tmsListSave"] = _pythia8.MergingHooks_tmsListSave_get
//    if _newclass:
//        tmsListSave = _swig_property(_pythia8.MergingHooks_tmsListSave_get, _pythia8.MergingHooks_tmsListSave_set)
//    __swig_setmethods__["doOrderHistoriesSave"] = _pythia8.MergingHooks_doOrderHistoriesSave_set
//    __swig_getmethods__["doOrderHistoriesSave"] = _pythia8.MergingHooks_doOrderHistoriesSave_get
//    if _newclass:
//        doOrderHistoriesSave = _swig_property(_pythia8.MergingHooks_doOrderHistoriesSave_get, _pythia8.MergingHooks_doOrderHistoriesSave_set)
//    __swig_setmethods__["doCutOnRecStateSave"] = _pythia8.MergingHooks_doCutOnRecStateSave_set
//    __swig_getmethods__["doCutOnRecStateSave"] = _pythia8.MergingHooks_doCutOnRecStateSave_get
//    if _newclass:
//        doCutOnRecStateSave = _swig_property(_pythia8.MergingHooks_doCutOnRecStateSave_get, _pythia8.MergingHooks_doCutOnRecStateSave_set)
//    __swig_setmethods__["doWeakClusteringSave"] = _pythia8.MergingHooks_doWeakClusteringSave_set
//    __swig_getmethods__["doWeakClusteringSave"] = _pythia8.MergingHooks_doWeakClusteringSave_get
//    if _newclass:
//        doWeakClusteringSave = _swig_property(_pythia8.MergingHooks_doWeakClusteringSave_get, _pythia8.MergingHooks_doWeakClusteringSave_set)
//    __swig_setmethods__["doSQCDClusteringSave"] = _pythia8.MergingHooks_doSQCDClusteringSave_set
//    __swig_getmethods__["doSQCDClusteringSave"] = _pythia8.MergingHooks_doSQCDClusteringSave_get
//    if _newclass:
//        doSQCDClusteringSave = _swig_property(_pythia8.MergingHooks_doSQCDClusteringSave_get, _pythia8.MergingHooks_doSQCDClusteringSave_set)
//    __swig_setmethods__["muFSave"] = _pythia8.MergingHooks_muFSave_set
//    __swig_getmethods__["muFSave"] = _pythia8.MergingHooks_muFSave_get
//    if _newclass:
//        muFSave = _swig_property(_pythia8.MergingHooks_muFSave_get, _pythia8.MergingHooks_muFSave_set)
//    __swig_setmethods__["muRSave"] = _pythia8.MergingHooks_muRSave_set
//    __swig_getmethods__["muRSave"] = _pythia8.MergingHooks_muRSave_get
//    if _newclass:
//        muRSave = _swig_property(_pythia8.MergingHooks_muRSave_get, _pythia8.MergingHooks_muRSave_set)
//    __swig_setmethods__["muFinMESave"] = _pythia8.MergingHooks_muFinMESave_set
//    __swig_getmethods__["muFinMESave"] = _pythia8.MergingHooks_muFinMESave_get
//    if _newclass:
//        muFinMESave = _swig_property(_pythia8.MergingHooks_muFinMESave_get, _pythia8.MergingHooks_muFinMESave_set)
//    __swig_setmethods__["muRinMESave"] = _pythia8.MergingHooks_muRinMESave_set
//    __swig_getmethods__["muRinMESave"] = _pythia8.MergingHooks_muRinMESave_get
//    if _newclass:
//        muRinMESave = _swig_property(_pythia8.MergingHooks_muRinMESave_get, _pythia8.MergingHooks_muRinMESave_set)
//    __swig_setmethods__["doIgnoreEmissionsSave"] = _pythia8.MergingHooks_doIgnoreEmissionsSave_set
//    __swig_getmethods__["doIgnoreEmissionsSave"] = _pythia8.MergingHooks_doIgnoreEmissionsSave_get
//    if _newclass:
//        doIgnoreEmissionsSave = _swig_property(_pythia8.MergingHooks_doIgnoreEmissionsSave_get, _pythia8.MergingHooks_doIgnoreEmissionsSave_set)
//    __swig_setmethods__["doIgnoreStepSave"] = _pythia8.MergingHooks_doIgnoreStepSave_set
//    __swig_getmethods__["doIgnoreStepSave"] = _pythia8.MergingHooks_doIgnoreStepSave_get
//    if _newclass:
//        doIgnoreStepSave = _swig_property(_pythia8.MergingHooks_doIgnoreStepSave_get, _pythia8.MergingHooks_doIgnoreStepSave_set)
//    __swig_setmethods__["pTsave"] = _pythia8.MergingHooks_pTsave_set
//    __swig_getmethods__["pTsave"] = _pythia8.MergingHooks_pTsave_get
//    if _newclass:
//        pTsave = _swig_property(_pythia8.MergingHooks_pTsave_get, _pythia8.MergingHooks_pTsave_set)
//    __swig_setmethods__["weightCKKWL1Save"] = _pythia8.MergingHooks_weightCKKWL1Save_set
//    __swig_getmethods__["weightCKKWL1Save"] = _pythia8.MergingHooks_weightCKKWL1Save_get
//    if _newclass:
//        weightCKKWL1Save = _swig_property(_pythia8.MergingHooks_weightCKKWL1Save_get, _pythia8.MergingHooks_weightCKKWL1Save_set)
//    __swig_setmethods__["weightCKKWL2Save"] = _pythia8.MergingHooks_weightCKKWL2Save_set
//    __swig_getmethods__["weightCKKWL2Save"] = _pythia8.MergingHooks_weightCKKWL2Save_get
//    if _newclass:
//        weightCKKWL2Save = _swig_property(_pythia8.MergingHooks_weightCKKWL2Save_get, _pythia8.MergingHooks_weightCKKWL2Save_set)
//    __swig_setmethods__["nMinMPISave"] = _pythia8.MergingHooks_nMinMPISave_set
//    __swig_getmethods__["nMinMPISave"] = _pythia8.MergingHooks_nMinMPISave_get
//    if _newclass:
//        nMinMPISave = _swig_property(_pythia8.MergingHooks_nMinMPISave_get, _pythia8.MergingHooks_nMinMPISave_set)
//    __swig_setmethods__["weightCKKWLSave"] = _pythia8.MergingHooks_weightCKKWLSave_set
//    __swig_getmethods__["weightCKKWLSave"] = _pythia8.MergingHooks_weightCKKWLSave_get
//    if _newclass:
//        weightCKKWLSave = _swig_property(_pythia8.MergingHooks_weightCKKWLSave_get, _pythia8.MergingHooks_weightCKKWLSave_set)
//    __swig_setmethods__["weightFIRSTSave"] = _pythia8.MergingHooks_weightFIRSTSave_set
//    __swig_getmethods__["weightFIRSTSave"] = _pythia8.MergingHooks_weightFIRSTSave_get
//    if _newclass:
//        weightFIRSTSave = _swig_property(_pythia8.MergingHooks_weightFIRSTSave_get, _pythia8.MergingHooks_weightFIRSTSave_set)
//    __swig_setmethods__["nJetMaxLocal"] = _pythia8.MergingHooks_nJetMaxLocal_set
//    __swig_getmethods__["nJetMaxLocal"] = _pythia8.MergingHooks_nJetMaxLocal_get
//    if _newclass:
//        nJetMaxLocal = _swig_property(_pythia8.MergingHooks_nJetMaxLocal_get, _pythia8.MergingHooks_nJetMaxLocal_set)
//    __swig_setmethods__["nJetMaxNLOLocal"] = _pythia8.MergingHooks_nJetMaxNLOLocal_set
//    __swig_getmethods__["nJetMaxNLOLocal"] = _pythia8.MergingHooks_nJetMaxNLOLocal_get
//    if _newclass:
//        nJetMaxNLOLocal = _swig_property(_pythia8.MergingHooks_nJetMaxNLOLocal_get, _pythia8.MergingHooks_nJetMaxNLOLocal_set)
//    __swig_setmethods__["hasJetMaxLocal"] = _pythia8.MergingHooks_hasJetMaxLocal_set
//    __swig_getmethods__["hasJetMaxLocal"] = _pythia8.MergingHooks_hasJetMaxLocal_get
//    if _newclass:
//        hasJetMaxLocal = _swig_property(_pythia8.MergingHooks_hasJetMaxLocal_get, _pythia8.MergingHooks_hasJetMaxLocal_set)
//    __swig_setmethods__["includeWGTinXSECSave"] = _pythia8.MergingHooks_includeWGTinXSECSave_set
//    __swig_getmethods__["includeWGTinXSECSave"] = _pythia8.MergingHooks_includeWGTinXSECSave_get
//    if _newclass:
//        includeWGTinXSECSave = _swig_property(_pythia8.MergingHooks_includeWGTinXSECSave_get, _pythia8.MergingHooks_includeWGTinXSECSave_set)
//    __swig_setmethods__["nHardNowSave"] = _pythia8.MergingHooks_nHardNowSave_set
//    __swig_getmethods__["nHardNowSave"] = _pythia8.MergingHooks_nHardNowSave_get
//    if _newclass:
//        nHardNowSave = _swig_property(_pythia8.MergingHooks_nHardNowSave_get, _pythia8.MergingHooks_nHardNowSave_set)
//    __swig_setmethods__["nJetNowSave"] = _pythia8.MergingHooks_nJetNowSave_set
//    __swig_getmethods__["nJetNowSave"] = _pythia8.MergingHooks_nJetNowSave_get
//    if _newclass:
//        nJetNowSave = _swig_property(_pythia8.MergingHooks_nJetNowSave_get, _pythia8.MergingHooks_nJetNowSave_set)
//    __swig_setmethods__["tmsHardNowSave"] = _pythia8.MergingHooks_tmsHardNowSave_set
//    __swig_getmethods__["tmsHardNowSave"] = _pythia8.MergingHooks_tmsHardNowSave_get
//    if _newclass:
//        tmsHardNowSave = _swig_property(_pythia8.MergingHooks_tmsHardNowSave_get, _pythia8.MergingHooks_tmsHardNowSave_set)
//    __swig_setmethods__["tmsNowSave"] = _pythia8.MergingHooks_tmsNowSave_set
//    __swig_getmethods__["tmsNowSave"] = _pythia8.MergingHooks_tmsNowSave_get
//    if _newclass:
//        tmsNowSave = _swig_property(_pythia8.MergingHooks_tmsNowSave_get, _pythia8.MergingHooks_tmsNowSave_set)
//
//    def storeHardProcessCandidates(self, event):
//        return _pythia8.MergingHooks_storeHardProcessCandidates(self, event)
//
//    def setLHEInputFile(self, lheFile):
//        return _pythia8.MergingHooks_setLHEInputFile(self, lheFile)
//
//    def AlphaS_FSR(self):
//        return _pythia8.MergingHooks_AlphaS_FSR(self)
//
//    def AlphaS_ISR(self):
//        return _pythia8.MergingHooks_AlphaS_ISR(self)
//
//    def AlphaEM_FSR(self):
//        return _pythia8.MergingHooks_AlphaEM_FSR(self)
//
//    def AlphaEM_ISR(self):
//        return _pythia8.MergingHooks_AlphaEM_ISR(self)
//
//    def includeMassive(self):
//        return _pythia8.MergingHooks_includeMassive(self)
//
//    def enforceStrongOrdering(self):
//        return _pythia8.MergingHooks_enforceStrongOrdering(self)
//
//    def orderInRapidity(self):
//        return _pythia8.MergingHooks_orderInRapidity(self)
//
//    def pickByFull(self):
//        return _pythia8.MergingHooks_pickByFull(self)
//
//    def pickByPoPT2(self):
//        return _pythia8.MergingHooks_pickByPoPT2(self)
//
//    def includeRedundant(self):
//        return _pythia8.MergingHooks_includeRedundant(self)
//
//    def pickBySumPT(self):
//        return _pythia8.MergingHooks_pickBySumPT(self)
//
//    def unorderedScalePrescip(self):
//        return _pythia8.MergingHooks_unorderedScalePrescip(self)
//
//    def unorderedASscalePrescip(self):
//        return _pythia8.MergingHooks_unorderedASscalePrescip(self)
//
//    def unorderedPDFscalePrescip(self):
//        return _pythia8.MergingHooks_unorderedPDFscalePrescip(self)
//
//    def incompleteScalePrescip(self):
//        return _pythia8.MergingHooks_incompleteScalePrescip(self)
//
//    def allowColourShuffling(self):
//        return _pythia8.MergingHooks_allowColourShuffling(self)
//
//    def resetHardQRen(self):
//        return _pythia8.MergingHooks_resetHardQRen(self)
//
//    def resetHardQFac(self):
//        return _pythia8.MergingHooks_resetHardQFac(self)
//
//    def scaleSeparationFactor(self):
//        return _pythia8.MergingHooks_scaleSeparationFactor(self)
//
//    def nonJoinedNorm(self):
//        return _pythia8.MergingHooks_nonJoinedNorm(self)
//
//    def fsrInRecNorm(self):
//        return _pythia8.MergingHooks_fsrInRecNorm(self)
//
//    def herwigAcollFSR(self):
//        return _pythia8.MergingHooks_herwigAcollFSR(self)
//
//    def herwigAcollISR(self):
//        return _pythia8.MergingHooks_herwigAcollISR(self)
//
//    def pT0ISR(self):
//        return _pythia8.MergingHooks_pT0ISR(self)
//
//    def pTcut(self):
//        return _pythia8.MergingHooks_pTcut(self)
//
//    def muMI(self, *args):
//        return _pythia8.MergingHooks_muMI(self, *args)
//
//    def kFactor(self, njet=0):
//        return _pythia8.MergingHooks_kFactor(self, njet)
//
//    def k1Factor(self, njet=0):
//        return _pythia8.MergingHooks_k1Factor(self, njet)
//
//    def getOrderHistories(self):
//        return _pythia8.MergingHooks_getOrderHistories(self)
//
//    def getAllowCutOnRecState(self):
//        return _pythia8.MergingHooks_getAllowCutOnRecState(self)
//
//    def getDoWeakClustering(self):
//        return _pythia8.MergingHooks_getDoWeakClustering(self)
//
//    def doSQCDClustering(self):
//        return _pythia8.MergingHooks_doSQCDClustering(self)
//
//    def muF(self):
//        return _pythia8.MergingHooks_muF(self)
//
//    def muR(self):
//        return _pythia8.MergingHooks_muR(self)
//
//    def muFinME(self):
//        return _pythia8.MergingHooks_muFinME(self)
//
//    def muRinME(self):
//        return _pythia8.MergingHooks_muRinME(self)
//
//    def doIgnoreStep(self, doIgnoreIn):
//        return _pythia8.MergingHooks_doIgnoreStep(self, doIgnoreIn)
//
//    def canVetoStep(self):
//        return _pythia8.MergingHooks_canVetoStep(self)
//
//    def storeWeights(self, weight):
//        return _pythia8.MergingHooks_storeWeights(self, weight)
//
//    def doVetoStep(self, process, event, doResonance=False):
//        return _pythia8.MergingHooks_doVetoStep(self, process, event, doResonance)
//
//    def setShowerStartingScales(self, isTrial, doMergeFirstEmm, pTscaleIn, event, pTmaxFSRIn, limitPTmaxFSRin, pTmaxISRIn, limitPTmaxISRin, pTmaxMPIIn, limitPTmaxMPIin):
//        return _pythia8.MergingHooks_setShowerStartingScales(self, isTrial, doMergeFirstEmm, pTscaleIn, event, pTmaxFSRIn, limitPTmaxFSRin, pTmaxISRIn, limitPTmaxISRin, pTmaxMPIIn, limitPTmaxMPIin)
//    __swig_setmethods__["stopScaleSave"] = _pythia8.MergingHooks_stopScaleSave_set
//    __swig_getmethods__["stopScaleSave"] = _pythia8.MergingHooks_stopScaleSave_get
//    if _newclass:
//        stopScaleSave = _swig_property(_pythia8.MergingHooks_stopScaleSave_get, _pythia8.MergingHooks_stopScaleSave_set)
//
//    def setShowerStoppingScale(self, scale=0.):
//        return _pythia8.MergingHooks_setShowerStoppingScale(self, scale)
//
//    def getShowerStoppingScale(self):
//        return _pythia8.MergingHooks_getShowerStoppingScale(self)
//
//    def nMinMPI(self, *args):
//        return _pythia8.MergingHooks_nMinMPI(self, *args)
//
//    def kTdurham(self, RadAfterBranch, EmtAfterBranch, Type, D):
//        return _pythia8.MergingHooks_kTdurham(self, RadAfterBranch, EmtAfterBranch, Type, D)
//
//    def rhoPythia(self, event, rad, emt, rec, ShowerType):
//        return _pythia8.MergingHooks_rhoPythia(self, event, rad, emt, rec, ShowerType)
//
//    def findColour(self, col, iExclude1, iExclude2, event, type, isHardIn):
//        return _pythia8.MergingHooks_findColour(self, col, iExclude1, iExclude2, event, type, isHardIn)
//
//    def deltaRij(self, jet1, jet2):
//        return _pythia8.MergingHooks_deltaRij(self, jet1, jet2)
//
//    def getWeightNLO(self):
//        return _pythia8.MergingHooks_getWeightNLO(self)
//
//    def getWeightCKKWL(self):
//        return _pythia8.MergingHooks_getWeightCKKWL(self)
//
//    def getWeightFIRST(self):
//        return _pythia8.MergingHooks_getWeightFIRST(self)
//
//    def setWeightCKKWL(self, weightIn):
//        return _pythia8.MergingHooks_setWeightCKKWL(self, weightIn)
//
//    def setWeightFIRST(self, weightIn):
//        return _pythia8.MergingHooks_setWeightFIRST(self, weightIn)
//
//    def setEventVetoInfo(self, nJetNowIn, tmsNowIn):
//        return _pythia8.MergingHooks_setEventVetoInfo(self, nJetNowIn, tmsNowIn)
//
//    def setHardProcessInfo(self, nHardNowIn, tmsHardNowIn):
//        return _pythia8.MergingHooks_setHardProcessInfo(self, nHardNowIn, tmsHardNowIn)
//    def __disown__(self):
//        self.this.disown()
//        _pythia8.disown_MergingHooks(self)
//        return weakref_proxy(self)
//MergingHooks_swigregister = _pythia8.MergingHooks_swigregister
//MergingHooks_swigregister(MergingHooks)
//
//class InBeam(_object):
//    """
//InBeam is a simple helper class for partons and their flux in a beam.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, InBeam, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, InBeam, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idIn=0):
//        """
//Constructor.
//"""
//        this = _pythia8.new_InBeam(idIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["id"] = _pythia8.InBeam_id_set
//    __swig_getmethods__["id"] = _pythia8.InBeam_id_get
//    if _newclass:
//        id = _swig_property(_pythia8.InBeam_id_get, _pythia8.InBeam_id_set)
//    __swig_setmethods__["pdf"] = _pythia8.InBeam_pdf_set
//    __swig_getmethods__["pdf"] = _pythia8.InBeam_pdf_get
//    if _newclass:
//        pdf = _swig_property(_pythia8.InBeam_pdf_get, _pythia8.InBeam_pdf_set)
//    __swig_destroy__ = _pythia8.delete_InBeam
//    __del__ = lambda self: None
//InBeam_swigregister = _pythia8.InBeam_swigregister
//InBeam_swigregister(InBeam)
//
//class InPair(_object):
//    """
//InPair is a simple helper class for colliding parton pairs and their flux.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, InPair, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, InPair, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idAIn=0, idBIn=0):
//        """
//Constructor.
//"""
//        this = _pythia8.new_InPair(idAIn, idBIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["idA"] = _pythia8.InPair_idA_set
//    __swig_getmethods__["idA"] = _pythia8.InPair_idA_get
//    if _newclass:
//        idA = _swig_property(_pythia8.InPair_idA_get, _pythia8.InPair_idA_set)
//    __swig_setmethods__["idB"] = _pythia8.InPair_idB_set
//    __swig_getmethods__["idB"] = _pythia8.InPair_idB_get
//    if _newclass:
//        idB = _swig_property(_pythia8.InPair_idB_get, _pythia8.InPair_idB_set)
//    __swig_setmethods__["pdfA"] = _pythia8.InPair_pdfA_set
//    __swig_getmethods__["pdfA"] = _pythia8.InPair_pdfA_get
//    if _newclass:
//        pdfA = _swig_property(_pythia8.InPair_pdfA_get, _pythia8.InPair_pdfA_set)
//    __swig_setmethods__["pdfB"] = _pythia8.InPair_pdfB_set
//    __swig_getmethods__["pdfB"] = _pythia8.InPair_pdfB_get
//    if _newclass:
//        pdfB = _swig_property(_pythia8.InPair_pdfB_get, _pythia8.InPair_pdfB_set)
//    __swig_setmethods__["pdfSigma"] = _pythia8.InPair_pdfSigma_set
//    __swig_getmethods__["pdfSigma"] = _pythia8.InPair_pdfSigma_get
//    if _newclass:
//        pdfSigma = _swig_property(_pythia8.InPair_pdfSigma_get, _pythia8.InPair_pdfSigma_set)
//    __swig_destroy__ = _pythia8.delete_InPair
//    __del__ = lambda self: None
//InPair_swigregister = _pythia8.InPair_swigregister
//InPair_swigregister(InPair)
//
//class SigmaProcess(_object):
//    """
//SigmaProcess is the base class for cross section calculations.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SigmaProcess, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, SigmaProcess, name)
//    __repr__ = _swig_repr
//    __swig_destroy__ = _pythia8.delete_SigmaProcess
//    __del__ = lambda self: None
//
//    def init(self, infoPtrIn, settingsPtrIn, particleDataPtrIn, rndmPtrIn, beamAPtrIn, beamBPtrIn, couplings, sigmaTotPtrIn=None, slhaInterfacePtrIn=None):
//        """
//Perform simple initialization and store pointers.
//"""
//        return _pythia8.SigmaProcess_init(self, infoPtrIn, settingsPtrIn, particleDataPtrIn, rndmPtrIn, beamAPtrIn, beamBPtrIn, couplings, sigmaTotPtrIn, slhaInterfacePtrIn)
//
//    def setLHAPtr(self, lhaUpPtrIn):
//        """
//Store or replace Les Houches pointer.
//"""
//        return _pythia8.SigmaProcess_setLHAPtr(self, lhaUpPtrIn)
//
//    def initProc(self):
//        """
//Initialize process. Only used for some processes.
//"""
//        return _pythia8.SigmaProcess_initProc(self)
//
//    def initFlux(self):
//        """
//Set up allowed flux of incoming partons. Default is no flux.
//"""
//        return _pythia8.SigmaProcess_initFlux(self)
//
//    def set1Kin(self, arg0, arg1, arg2):
//        """
//Input and complement kinematics for resolved 2 -> 1 process.
//Usage: set1Kin( x1in, x2in, sHin).
//"""
//        return _pythia8.SigmaProcess_set1Kin(self, arg0, arg1, arg2)
//
//    def set2Kin(self, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7):
//        """
//Input and complement kinematics for resolved 2 -> 2 process.
//Usage: set2Kin( x1in, x2in, sHin, tHin, m3in, m4in, runBW3in, runBW4in).
//"""
//        return _pythia8.SigmaProcess_set2Kin(self, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
//
//    def set2KinMPI(self, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9):
//        """
//Ditto, but for Multiparton Interactions applications, so different input.
//Usage: set2KinMPI( x1in, x2in, sHin, tHin, uHin,
//                  alpSin, alpEMin, needMasses, m3in, m4in)
//"""
//        return _pythia8.SigmaProcess_set2KinMPI(self, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
//
//    def set3Kin(self, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11):
//        """
//Input and complement kinematics for resolved 2 -> 3 process.
//Usage: set3Kin( x1in, x2in, sHin, p3prel, p4prel, p5prel,
//                m3in, m4in, m5in, runBW3in, runBW4in, runBW5in);
//"""
//        return _pythia8.SigmaProcess_set3Kin(self, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.SigmaProcess_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigma for unresolved, sigmaHat(sHat) for 2 -> 1 processes,
//d(sigmaHat)/d(tHat) for (resolved) 2 -> 2 processes, and |M|^2 for
//2 -> 3 processes. Answer in "native" units, either mb or GeV^-2.
//"""
//        return _pythia8.SigmaProcess_sigmaHat(self)
//
//    def sigmaHatWrap(self, id1in=0, id2in=0):
//        """
//Wrapper to sigmaHat, to (a) store current incoming flavours and
//(b) convert from GeV^-2 to mb where required.
//For 2 -> 1/2 also (c) convert from from |M|^2 to d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.SigmaProcess_sigmaHatWrap(self, id1in, id2in)
//
//    def sigmaPDF(self, initPS=False, samexGamma=False, useNewXvalues=False, x1New=0., x2New=0.):
//        """
//Convolute above with parton flux and K factor. Sum over open channels.
//Possibly different PDF in initialization phase or no sampling for x_gamma
//(photons in leptons).
//"""
//        return _pythia8.SigmaProcess_sigmaPDF(self, initPS, samexGamma, useNewXvalues, x1New, x2New)
//
//    def pickInState(self, id1in=0, id2in=0):
//        """
//Select incoming parton channel and extract parton densities (resolved).
//"""
//        return _pythia8.SigmaProcess_pickInState(self, id1in, id2in)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.SigmaProcess_setIdColAcol(self)
//
//    def final2KinMPI(self, arg0=0, arg1=0, arg2=0., arg3=0., arg4=0., arg5=0.):
//        """
//Perform kinematics for a Multiparton Interaction, in its rest frame.
//"""
//        return _pythia8.SigmaProcess_final2KinMPI(self, arg0, arg1, arg2, arg3, arg4, arg5)
//
//    def weightDecayFlav(self, arg0):
//        """
//Evaluate weight for simultaneous flavours (only gamma*/Z0 gamma*/Z0).
//Usage: weightDecayFlav( process).
//"""
//        return _pythia8.SigmaProcess_weightDecayFlav(self, arg0)
//
//    def weightDecay(self, arg0, arg1, arg2):
//        """
//Evaluate weight for decay angular configuration.
//Usage: weightDecay( process, iResBeg, iResEnd), where
//iResBeg <= i < iResEnd is range of sister partons to test decays of.
//"""
//        return _pythia8.SigmaProcess_weightDecay(self, arg0, arg1, arg2)
//
//    def setScale(self):
//        """
//Set scale, when that is missing for an external LHA process.
//"""
//        return _pythia8.SigmaProcess_setScale(self)
//
//    def name(self):
//        """
//Process name and code, and the number of final-state particles.
//"""
//        return _pythia8.SigmaProcess_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.SigmaProcess_code(self)
//
//    def nFinal(self):
//        """
//"""
//        return _pythia8.SigmaProcess_nFinal(self)
//
//    def inFlux(self):
//        """
//Need to know which incoming partons to set up interaction for.
//"""
//        return _pythia8.SigmaProcess_inFlux(self)
//
//    def convert2mb(self):
//        """
//Need to know whether to convert cross section answer from GeV^-2 to mb.
//"""
//        return _pythia8.SigmaProcess_convert2mb(self)
//
//    def convertM2(self):
//        """
//For 2 -> 2 process optional conversion from |M|^2 to d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.SigmaProcess_convertM2(self)
//
//    def isLHA(self):
//        """
//Special treatment needed for Les Houches processes.
//"""
//        return _pythia8.SigmaProcess_isLHA(self)
//
//    def isNonDiff(self):
//        """
//Special treatment needed for elastic and diffractive processes.
//"""
//        return _pythia8.SigmaProcess_isNonDiff(self)
//
//    def isResolved(self):
//        """
//"""
//        return _pythia8.SigmaProcess_isResolved(self)
//
//    def isDiffA(self):
//        """
//"""
//        return _pythia8.SigmaProcess_isDiffA(self)
//
//    def isDiffB(self):
//        """
//"""
//        return _pythia8.SigmaProcess_isDiffB(self)
//
//    def isDiffC(self):
//        """
//"""
//        return _pythia8.SigmaProcess_isDiffC(self)
//
//    def isSUSY(self):
//        """
//Special treatment needed for SUSY processes.
//"""
//        return _pythia8.SigmaProcess_isSUSY(self)
//
//    def allowNegativeSigma(self):
//        """
//Special treatment needed if negative cross sections allowed.
//"""
//        return _pythia8.SigmaProcess_allowNegativeSigma(self)
//
//    def id3Mass(self):
//        """
//Flavours in 2 -> 2/3 processes where masses needed from beginning.
//(For a light quark masses will be used in the final kinematics,
//but not at the matrix-element level. For a gluon no masses at all.)
//"""
//        return _pythia8.SigmaProcess_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.SigmaProcess_id4Mass(self)
//
//    def id5Mass(self):
//        """
//"""
//        return _pythia8.SigmaProcess_id5Mass(self)
//
//    def resonanceA(self):
//        """
//Special treatment needed if process contains an s-channel resonance.
//"""
//        return _pythia8.SigmaProcess_resonanceA(self)
//
//    def resonanceB(self):
//        """
//"""
//        return _pythia8.SigmaProcess_resonanceB(self)
//
//    def isSChannel(self):
//        """
//2 -> 2 and 2 -> 3 processes only through s-channel exchange.
//"""
//        return _pythia8.SigmaProcess_isSChannel(self)
//
//    def idSChannel(self):
//        """
//NOAM: Insert an intermediate resonance in 2 -> 1 -> 2 (or 3) listings.
//"""
//        return _pythia8.SigmaProcess_idSChannel(self)
//
//    def isQCD3body(self):
//        """
//QCD 2 -> 3 processes need special phase space selection machinery.
//"""
//        return _pythia8.SigmaProcess_isQCD3body(self)
//
//    def idTchan1(self):
//        """
//Special treatment in 2 -> 3 with two massive propagators.
//"""
//        return _pythia8.SigmaProcess_idTchan1(self)
//
//    def idTchan2(self):
//        """
//"""
//        return _pythia8.SigmaProcess_idTchan2(self)
//
//    def tChanFracPow1(self):
//        """
//"""
//        return _pythia8.SigmaProcess_tChanFracPow1(self)
//
//    def tChanFracPow2(self):
//        """
//"""
//        return _pythia8.SigmaProcess_tChanFracPow2(self)
//
//    def useMirrorWeight(self):
//        """
//"""
//        return _pythia8.SigmaProcess_useMirrorWeight(self)
//
//    def gmZmode(self):
//        """
//Special process-specific gamma*/Z0 choice if >=0 (e.g. f fbar -> H0 Z0).
//"""
//        return _pythia8.SigmaProcess_gmZmode(self)
//
//    def swappedTU(self):
//        """
//Tell whether tHat and uHat are swapped (= same as swap 3 and 4).
//"""
//        return _pythia8.SigmaProcess_swappedTU(self)
//
//    def id(self, i):
//        """
//Give back particle properties: flavours, colours, masses, or all.
//"""
//        return _pythia8.SigmaProcess_id(self, i)
//
//    def col(self, i):
//        """
//"""
//        return _pythia8.SigmaProcess_col(self, i)
//
//    def acol(self, i):
//        """
//"""
//        return _pythia8.SigmaProcess_acol(self, i)
//
//    def m(self, i):
//        """
//"""
//        return _pythia8.SigmaProcess_m(self, i)
//
//    def getParton(self, i):
//        """
//"""
//        return _pythia8.SigmaProcess_getParton(self, i)
//
//    def Q2Ren(self):
//        """
//Give back couplings and parton densities.
//Not all known for nondiffractive.
//"""
//        return _pythia8.SigmaProcess_Q2Ren(self)
//
//    def alphaEMRen(self):
//        """
//"""
//        return _pythia8.SigmaProcess_alphaEMRen(self)
//
//    def alphaSRen(self):
//        """
//"""
//        return _pythia8.SigmaProcess_alphaSRen(self)
//
//    def Q2Fac(self):
//        """
//"""
//        return _pythia8.SigmaProcess_Q2Fac(self)
//
//    def pdf1(self):
//        """
//"""
//        return _pythia8.SigmaProcess_pdf1(self)
//
//    def pdf2(self):
//        """
//"""
//        return _pythia8.SigmaProcess_pdf2(self)
//
//    def thetaMPI(self):
//        """
//Give back angles; relevant only for multipe-interactions processes.
//"""
//        return _pythia8.SigmaProcess_thetaMPI(self)
//
//    def phiMPI(self):
//        """
//"""
//        return _pythia8.SigmaProcess_phiMPI(self)
//
//    def sHBetaMPI(self):
//        """
//"""
//        return _pythia8.SigmaProcess_sHBetaMPI(self)
//
//    def pT2MPI(self):
//        """
//"""
//        return _pythia8.SigmaProcess_pT2MPI(self)
//
//    def pTMPIFin(self):
//        """
//"""
//        return _pythia8.SigmaProcess_pTMPIFin(self)
//
//    def saveKin(self):
//        """
//Save and load kinematics for trial interactions
//"""
//        return _pythia8.SigmaProcess_saveKin(self)
//
//    def loadKin(self):
//        """
//"""
//        return _pythia8.SigmaProcess_loadKin(self)
//
//    def swapKin(self):
//        """
//"""
//        return _pythia8.SigmaProcess_swapKin(self)
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        if self.__class__ == SigmaProcess:
//            _self = None
//        else:
//            _self = self
//        this = _pythia8.new_SigmaProcess(_self, )
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["infoPtr"] = _pythia8.SigmaProcess_infoPtr_set
//    __swig_getmethods__["infoPtr"] = _pythia8.SigmaProcess_infoPtr_get
//    if _newclass:
//        infoPtr = _swig_property(_pythia8.SigmaProcess_infoPtr_get, _pythia8.SigmaProcess_infoPtr_set)
//    __swig_setmethods__["settingsPtr"] = _pythia8.SigmaProcess_settingsPtr_set
//    __swig_getmethods__["settingsPtr"] = _pythia8.SigmaProcess_settingsPtr_get
//    if _newclass:
//        settingsPtr = _swig_property(_pythia8.SigmaProcess_settingsPtr_get, _pythia8.SigmaProcess_settingsPtr_set)
//    __swig_setmethods__["particleDataPtr"] = _pythia8.SigmaProcess_particleDataPtr_set
//    __swig_getmethods__["particleDataPtr"] = _pythia8.SigmaProcess_particleDataPtr_get
//    if _newclass:
//        particleDataPtr = _swig_property(_pythia8.SigmaProcess_particleDataPtr_get, _pythia8.SigmaProcess_particleDataPtr_set)
//    __swig_setmethods__["rndmPtr"] = _pythia8.SigmaProcess_rndmPtr_set
//    __swig_getmethods__["rndmPtr"] = _pythia8.SigmaProcess_rndmPtr_get
//    if _newclass:
//        rndmPtr = _swig_property(_pythia8.SigmaProcess_rndmPtr_get, _pythia8.SigmaProcess_rndmPtr_set)
//    __swig_setmethods__["beamAPtr"] = _pythia8.SigmaProcess_beamAPtr_set
//    __swig_getmethods__["beamAPtr"] = _pythia8.SigmaProcess_beamAPtr_get
//    if _newclass:
//        beamAPtr = _swig_property(_pythia8.SigmaProcess_beamAPtr_get, _pythia8.SigmaProcess_beamAPtr_set)
//    __swig_setmethods__["beamBPtr"] = _pythia8.SigmaProcess_beamBPtr_set
//    __swig_getmethods__["beamBPtr"] = _pythia8.SigmaProcess_beamBPtr_get
//    if _newclass:
//        beamBPtr = _swig_property(_pythia8.SigmaProcess_beamBPtr_get, _pythia8.SigmaProcess_beamBPtr_set)
//    __swig_setmethods__["couplingsPtr"] = _pythia8.SigmaProcess_couplingsPtr_set
//    __swig_getmethods__["couplingsPtr"] = _pythia8.SigmaProcess_couplingsPtr_get
//    if _newclass:
//        couplingsPtr = _swig_property(_pythia8.SigmaProcess_couplingsPtr_get, _pythia8.SigmaProcess_couplingsPtr_set)
//    __swig_setmethods__["sigmaTotPtr"] = _pythia8.SigmaProcess_sigmaTotPtr_set
//    __swig_getmethods__["sigmaTotPtr"] = _pythia8.SigmaProcess_sigmaTotPtr_get
//    if _newclass:
//        sigmaTotPtr = _swig_property(_pythia8.SigmaProcess_sigmaTotPtr_get, _pythia8.SigmaProcess_sigmaTotPtr_set)
//    __swig_setmethods__["slhaPtr"] = _pythia8.SigmaProcess_slhaPtr_set
//    __swig_getmethods__["slhaPtr"] = _pythia8.SigmaProcess_slhaPtr_get
//    if _newclass:
//        slhaPtr = _swig_property(_pythia8.SigmaProcess_slhaPtr_get, _pythia8.SigmaProcess_slhaPtr_set)
//    __swig_setmethods__["lhaUpPtr"] = _pythia8.SigmaProcess_lhaUpPtr_set
//    __swig_getmethods__["lhaUpPtr"] = _pythia8.SigmaProcess_lhaUpPtr_get
//    if _newclass:
//        lhaUpPtr = _swig_property(_pythia8.SigmaProcess_lhaUpPtr_get, _pythia8.SigmaProcess_lhaUpPtr_set)
//    __swig_setmethods__["nQuarkIn"] = _pythia8.SigmaProcess_nQuarkIn_set
//    __swig_getmethods__["nQuarkIn"] = _pythia8.SigmaProcess_nQuarkIn_get
//    if _newclass:
//        nQuarkIn = _swig_property(_pythia8.SigmaProcess_nQuarkIn_get, _pythia8.SigmaProcess_nQuarkIn_set)
//    __swig_setmethods__["renormScale1"] = _pythia8.SigmaProcess_renormScale1_set
//    __swig_getmethods__["renormScale1"] = _pythia8.SigmaProcess_renormScale1_get
//    if _newclass:
//        renormScale1 = _swig_property(_pythia8.SigmaProcess_renormScale1_get, _pythia8.SigmaProcess_renormScale1_set)
//    __swig_setmethods__["renormScale2"] = _pythia8.SigmaProcess_renormScale2_set
//    __swig_getmethods__["renormScale2"] = _pythia8.SigmaProcess_renormScale2_get
//    if _newclass:
//        renormScale2 = _swig_property(_pythia8.SigmaProcess_renormScale2_get, _pythia8.SigmaProcess_renormScale2_set)
//    __swig_setmethods__["renormScale3"] = _pythia8.SigmaProcess_renormScale3_set
//    __swig_getmethods__["renormScale3"] = _pythia8.SigmaProcess_renormScale3_get
//    if _newclass:
//        renormScale3 = _swig_property(_pythia8.SigmaProcess_renormScale3_get, _pythia8.SigmaProcess_renormScale3_set)
//    __swig_setmethods__["renormScale3VV"] = _pythia8.SigmaProcess_renormScale3VV_set
//    __swig_getmethods__["renormScale3VV"] = _pythia8.SigmaProcess_renormScale3VV_get
//    if _newclass:
//        renormScale3VV = _swig_property(_pythia8.SigmaProcess_renormScale3VV_get, _pythia8.SigmaProcess_renormScale3VV_set)
//    __swig_setmethods__["factorScale1"] = _pythia8.SigmaProcess_factorScale1_set
//    __swig_getmethods__["factorScale1"] = _pythia8.SigmaProcess_factorScale1_get
//    if _newclass:
//        factorScale1 = _swig_property(_pythia8.SigmaProcess_factorScale1_get, _pythia8.SigmaProcess_factorScale1_set)
//    __swig_setmethods__["factorScale2"] = _pythia8.SigmaProcess_factorScale2_set
//    __swig_getmethods__["factorScale2"] = _pythia8.SigmaProcess_factorScale2_get
//    if _newclass:
//        factorScale2 = _swig_property(_pythia8.SigmaProcess_factorScale2_get, _pythia8.SigmaProcess_factorScale2_set)
//    __swig_setmethods__["factorScale3"] = _pythia8.SigmaProcess_factorScale3_set
//    __swig_getmethods__["factorScale3"] = _pythia8.SigmaProcess_factorScale3_get
//    if _newclass:
//        factorScale3 = _swig_property(_pythia8.SigmaProcess_factorScale3_get, _pythia8.SigmaProcess_factorScale3_set)
//    __swig_setmethods__["factorScale3VV"] = _pythia8.SigmaProcess_factorScale3VV_set
//    __swig_getmethods__["factorScale3VV"] = _pythia8.SigmaProcess_factorScale3VV_get
//    if _newclass:
//        factorScale3VV = _swig_property(_pythia8.SigmaProcess_factorScale3VV_get, _pythia8.SigmaProcess_factorScale3VV_set)
//    __swig_setmethods__["Kfactor"] = _pythia8.SigmaProcess_Kfactor_set
//    __swig_getmethods__["Kfactor"] = _pythia8.SigmaProcess_Kfactor_get
//    if _newclass:
//        Kfactor = _swig_property(_pythia8.SigmaProcess_Kfactor_get, _pythia8.SigmaProcess_Kfactor_set)
//    __swig_setmethods__["mcME"] = _pythia8.SigmaProcess_mcME_set
//    __swig_getmethods__["mcME"] = _pythia8.SigmaProcess_mcME_get
//    if _newclass:
//        mcME = _swig_property(_pythia8.SigmaProcess_mcME_get, _pythia8.SigmaProcess_mcME_set)
//    __swig_setmethods__["mbME"] = _pythia8.SigmaProcess_mbME_set
//    __swig_getmethods__["mbME"] = _pythia8.SigmaProcess_mbME_get
//    if _newclass:
//        mbME = _swig_property(_pythia8.SigmaProcess_mbME_get, _pythia8.SigmaProcess_mbME_set)
//    __swig_setmethods__["mmuME"] = _pythia8.SigmaProcess_mmuME_set
//    __swig_getmethods__["mmuME"] = _pythia8.SigmaProcess_mmuME_get
//    if _newclass:
//        mmuME = _swig_property(_pythia8.SigmaProcess_mmuME_get, _pythia8.SigmaProcess_mmuME_set)
//    __swig_setmethods__["mtauME"] = _pythia8.SigmaProcess_mtauME_set
//    __swig_getmethods__["mtauME"] = _pythia8.SigmaProcess_mtauME_get
//    if _newclass:
//        mtauME = _swig_property(_pythia8.SigmaProcess_mtauME_get, _pythia8.SigmaProcess_mtauME_set)
//    __swig_setmethods__["renormMultFac"] = _pythia8.SigmaProcess_renormMultFac_set
//    __swig_getmethods__["renormMultFac"] = _pythia8.SigmaProcess_renormMultFac_get
//    if _newclass:
//        renormMultFac = _swig_property(_pythia8.SigmaProcess_renormMultFac_get, _pythia8.SigmaProcess_renormMultFac_set)
//    __swig_setmethods__["renormFixScale"] = _pythia8.SigmaProcess_renormFixScale_set
//    __swig_getmethods__["renormFixScale"] = _pythia8.SigmaProcess_renormFixScale_get
//    if _newclass:
//        renormFixScale = _swig_property(_pythia8.SigmaProcess_renormFixScale_get, _pythia8.SigmaProcess_renormFixScale_set)
//    __swig_setmethods__["factorMultFac"] = _pythia8.SigmaProcess_factorMultFac_set
//    __swig_getmethods__["factorMultFac"] = _pythia8.SigmaProcess_factorMultFac_get
//    if _newclass:
//        factorMultFac = _swig_property(_pythia8.SigmaProcess_factorMultFac_get, _pythia8.SigmaProcess_factorMultFac_set)
//    __swig_setmethods__["factorFixScale"] = _pythia8.SigmaProcess_factorFixScale_set
//    __swig_getmethods__["factorFixScale"] = _pythia8.SigmaProcess_factorFixScale_get
//    if _newclass:
//        factorFixScale = _swig_property(_pythia8.SigmaProcess_factorFixScale_get, _pythia8.SigmaProcess_factorFixScale_set)
//    __swig_setmethods__["higgsH1parity"] = _pythia8.SigmaProcess_higgsH1parity_set
//    __swig_getmethods__["higgsH1parity"] = _pythia8.SigmaProcess_higgsH1parity_get
//    if _newclass:
//        higgsH1parity = _swig_property(_pythia8.SigmaProcess_higgsH1parity_get, _pythia8.SigmaProcess_higgsH1parity_set)
//    __swig_setmethods__["higgsH2parity"] = _pythia8.SigmaProcess_higgsH2parity_set
//    __swig_getmethods__["higgsH2parity"] = _pythia8.SigmaProcess_higgsH2parity_get
//    if _newclass:
//        higgsH2parity = _swig_property(_pythia8.SigmaProcess_higgsH2parity_get, _pythia8.SigmaProcess_higgsH2parity_set)
//    __swig_setmethods__["higgsA3parity"] = _pythia8.SigmaProcess_higgsA3parity_set
//    __swig_getmethods__["higgsA3parity"] = _pythia8.SigmaProcess_higgsA3parity_get
//    if _newclass:
//        higgsA3parity = _swig_property(_pythia8.SigmaProcess_higgsA3parity_get, _pythia8.SigmaProcess_higgsA3parity_set)
//    __swig_setmethods__["higgsH1eta"] = _pythia8.SigmaProcess_higgsH1eta_set
//    __swig_getmethods__["higgsH1eta"] = _pythia8.SigmaProcess_higgsH1eta_get
//    if _newclass:
//        higgsH1eta = _swig_property(_pythia8.SigmaProcess_higgsH1eta_get, _pythia8.SigmaProcess_higgsH1eta_set)
//    __swig_setmethods__["higgsH2eta"] = _pythia8.SigmaProcess_higgsH2eta_set
//    __swig_getmethods__["higgsH2eta"] = _pythia8.SigmaProcess_higgsH2eta_get
//    if _newclass:
//        higgsH2eta = _swig_property(_pythia8.SigmaProcess_higgsH2eta_get, _pythia8.SigmaProcess_higgsH2eta_set)
//    __swig_setmethods__["higgsA3eta"] = _pythia8.SigmaProcess_higgsA3eta_set
//    __swig_getmethods__["higgsA3eta"] = _pythia8.SigmaProcess_higgsA3eta_get
//    if _newclass:
//        higgsA3eta = _swig_property(_pythia8.SigmaProcess_higgsA3eta_get, _pythia8.SigmaProcess_higgsA3eta_set)
//    __swig_setmethods__["higgsH1phi"] = _pythia8.SigmaProcess_higgsH1phi_set
//    __swig_getmethods__["higgsH1phi"] = _pythia8.SigmaProcess_higgsH1phi_get
//    if _newclass:
//        higgsH1phi = _swig_property(_pythia8.SigmaProcess_higgsH1phi_get, _pythia8.SigmaProcess_higgsH1phi_set)
//    __swig_setmethods__["higgsH2phi"] = _pythia8.SigmaProcess_higgsH2phi_set
//    __swig_getmethods__["higgsH2phi"] = _pythia8.SigmaProcess_higgsH2phi_get
//    if _newclass:
//        higgsH2phi = _swig_property(_pythia8.SigmaProcess_higgsH2phi_get, _pythia8.SigmaProcess_higgsH2phi_set)
//    __swig_setmethods__["higgsA3phi"] = _pythia8.SigmaProcess_higgsA3phi_set
//    __swig_getmethods__["higgsA3phi"] = _pythia8.SigmaProcess_higgsA3phi_get
//    if _newclass:
//        higgsA3phi = _swig_property(_pythia8.SigmaProcess_higgsA3phi_get, _pythia8.SigmaProcess_higgsA3phi_set)
//    __swig_setmethods__["idA"] = _pythia8.SigmaProcess_idA_set
//    __swig_getmethods__["idA"] = _pythia8.SigmaProcess_idA_get
//    if _newclass:
//        idA = _swig_property(_pythia8.SigmaProcess_idA_get, _pythia8.SigmaProcess_idA_set)
//    __swig_setmethods__["idB"] = _pythia8.SigmaProcess_idB_set
//    __swig_getmethods__["idB"] = _pythia8.SigmaProcess_idB_get
//    if _newclass:
//        idB = _swig_property(_pythia8.SigmaProcess_idB_get, _pythia8.SigmaProcess_idB_set)
//    __swig_setmethods__["mA"] = _pythia8.SigmaProcess_mA_set
//    __swig_getmethods__["mA"] = _pythia8.SigmaProcess_mA_get
//    if _newclass:
//        mA = _swig_property(_pythia8.SigmaProcess_mA_get, _pythia8.SigmaProcess_mA_set)
//    __swig_setmethods__["mB"] = _pythia8.SigmaProcess_mB_set
//    __swig_getmethods__["mB"] = _pythia8.SigmaProcess_mB_get
//    if _newclass:
//        mB = _swig_property(_pythia8.SigmaProcess_mB_get, _pythia8.SigmaProcess_mB_set)
//    __swig_setmethods__["isLeptonA"] = _pythia8.SigmaProcess_isLeptonA_set
//    __swig_getmethods__["isLeptonA"] = _pythia8.SigmaProcess_isLeptonA_get
//    if _newclass:
//        isLeptonA = _swig_property(_pythia8.SigmaProcess_isLeptonA_get, _pythia8.SigmaProcess_isLeptonA_set)
//    __swig_setmethods__["isLeptonB"] = _pythia8.SigmaProcess_isLeptonB_set
//    __swig_getmethods__["isLeptonB"] = _pythia8.SigmaProcess_isLeptonB_get
//    if _newclass:
//        isLeptonB = _swig_property(_pythia8.SigmaProcess_isLeptonB_get, _pythia8.SigmaProcess_isLeptonB_set)
//    __swig_setmethods__["hasLeptonBeams"] = _pythia8.SigmaProcess_hasLeptonBeams_set
//    __swig_getmethods__["hasLeptonBeams"] = _pythia8.SigmaProcess_hasLeptonBeams_get
//    if _newclass:
//        hasLeptonBeams = _swig_property(_pythia8.SigmaProcess_hasLeptonBeams_get, _pythia8.SigmaProcess_hasLeptonBeams_set)
//    __swig_setmethods__["lepton2gammaA"] = _pythia8.SigmaProcess_lepton2gammaA_set
//    __swig_getmethods__["lepton2gammaA"] = _pythia8.SigmaProcess_lepton2gammaA_get
//    if _newclass:
//        lepton2gammaA = _swig_property(_pythia8.SigmaProcess_lepton2gammaA_get, _pythia8.SigmaProcess_lepton2gammaA_set)
//    __swig_setmethods__["lepton2gammaB"] = _pythia8.SigmaProcess_lepton2gammaB_set
//    __swig_getmethods__["lepton2gammaB"] = _pythia8.SigmaProcess_lepton2gammaB_get
//    if _newclass:
//        lepton2gammaB = _swig_property(_pythia8.SigmaProcess_lepton2gammaB_get, _pythia8.SigmaProcess_lepton2gammaB_set)
//    __swig_setmethods__["inBeamA"] = _pythia8.SigmaProcess_inBeamA_set
//    __swig_getmethods__["inBeamA"] = _pythia8.SigmaProcess_inBeamA_get
//    if _newclass:
//        inBeamA = _swig_property(_pythia8.SigmaProcess_inBeamA_get, _pythia8.SigmaProcess_inBeamA_set)
//    __swig_setmethods__["inBeamB"] = _pythia8.SigmaProcess_inBeamB_set
//    __swig_getmethods__["inBeamB"] = _pythia8.SigmaProcess_inBeamB_get
//    if _newclass:
//        inBeamB = _swig_property(_pythia8.SigmaProcess_inBeamB_get, _pythia8.SigmaProcess_inBeamB_set)
//
//    def addBeamA(self, idIn):
//        """
//Constants: could only be changed in the code itself.
//Pointer to various information on the generation.
//Pointer to the settings database.
//Pointer to the particle data table.
//Pointer to the random number generator.
//Pointers to incoming beams.
//Pointer to Standard Model couplings, including alphaS and alphaEM.
//Pointer to the total/elastic/diffractive cross section object.
//Pointer to an SLHA object.
//Pointer to LHAup for generating external events.
//Initialization data, normally only set once.
//CP violation parameters for Higgs sector, normally only set once.
//Information on incoming beams.
//Partons in beams, with PDF's.
//"""
//        return _pythia8.SigmaProcess_addBeamA(self, idIn)
//
//    def addBeamB(self, idIn):
//        """
//"""
//        return _pythia8.SigmaProcess_addBeamB(self, idIn)
//
//    def sizeBeamA(self):
//        """
//"""
//        return _pythia8.SigmaProcess_sizeBeamA(self)
//
//    def sizeBeamB(self):
//        """
//"""
//        return _pythia8.SigmaProcess_sizeBeamB(self)
//    __swig_setmethods__["inPair"] = _pythia8.SigmaProcess_inPair_set
//    __swig_getmethods__["inPair"] = _pythia8.SigmaProcess_inPair_get
//    if _newclass:
//        inPair = _swig_property(_pythia8.SigmaProcess_inPair_get, _pythia8.SigmaProcess_inPair_set)
//
//    def addPair(self, idAIn, idBIn):
//        """
//Allowed colliding parton pairs, with pdf's.
//"""
//        return _pythia8.SigmaProcess_addPair(self, idAIn, idBIn)
//
//    def sizePair(self):
//        """
//"""
//        return _pythia8.SigmaProcess_sizePair(self)
//    __swig_setmethods__["mH"] = _pythia8.SigmaProcess_mH_set
//    __swig_getmethods__["mH"] = _pythia8.SigmaProcess_mH_get
//    if _newclass:
//        mH = _swig_property(_pythia8.SigmaProcess_mH_get, _pythia8.SigmaProcess_mH_set)
//    __swig_setmethods__["sH"] = _pythia8.SigmaProcess_sH_set
//    __swig_getmethods__["sH"] = _pythia8.SigmaProcess_sH_get
//    if _newclass:
//        sH = _swig_property(_pythia8.SigmaProcess_sH_get, _pythia8.SigmaProcess_sH_set)
//    __swig_setmethods__["sH2"] = _pythia8.SigmaProcess_sH2_set
//    __swig_getmethods__["sH2"] = _pythia8.SigmaProcess_sH2_get
//    if _newclass:
//        sH2 = _swig_property(_pythia8.SigmaProcess_sH2_get, _pythia8.SigmaProcess_sH2_set)
//    __swig_setmethods__["Q2RenSave"] = _pythia8.SigmaProcess_Q2RenSave_set
//    __swig_getmethods__["Q2RenSave"] = _pythia8.SigmaProcess_Q2RenSave_get
//    if _newclass:
//        Q2RenSave = _swig_property(_pythia8.SigmaProcess_Q2RenSave_get, _pythia8.SigmaProcess_Q2RenSave_set)
//    __swig_setmethods__["alpEM"] = _pythia8.SigmaProcess_alpEM_set
//    __swig_getmethods__["alpEM"] = _pythia8.SigmaProcess_alpEM_get
//    if _newclass:
//        alpEM = _swig_property(_pythia8.SigmaProcess_alpEM_get, _pythia8.SigmaProcess_alpEM_set)
//    __swig_setmethods__["alpS"] = _pythia8.SigmaProcess_alpS_set
//    __swig_getmethods__["alpS"] = _pythia8.SigmaProcess_alpS_get
//    if _newclass:
//        alpS = _swig_property(_pythia8.SigmaProcess_alpS_get, _pythia8.SigmaProcess_alpS_set)
//    __swig_setmethods__["Q2FacSave"] = _pythia8.SigmaProcess_Q2FacSave_set
//    __swig_getmethods__["Q2FacSave"] = _pythia8.SigmaProcess_Q2FacSave_get
//    if _newclass:
//        Q2FacSave = _swig_property(_pythia8.SigmaProcess_Q2FacSave_get, _pythia8.SigmaProcess_Q2FacSave_set)
//    __swig_setmethods__["x1Save"] = _pythia8.SigmaProcess_x1Save_set
//    __swig_getmethods__["x1Save"] = _pythia8.SigmaProcess_x1Save_get
//    if _newclass:
//        x1Save = _swig_property(_pythia8.SigmaProcess_x1Save_get, _pythia8.SigmaProcess_x1Save_set)
//    __swig_setmethods__["x2Save"] = _pythia8.SigmaProcess_x2Save_set
//    __swig_getmethods__["x2Save"] = _pythia8.SigmaProcess_x2Save_get
//    if _newclass:
//        x2Save = _swig_property(_pythia8.SigmaProcess_x2Save_get, _pythia8.SigmaProcess_x2Save_set)
//    __swig_setmethods__["pdf1Save"] = _pythia8.SigmaProcess_pdf1Save_set
//    __swig_getmethods__["pdf1Save"] = _pythia8.SigmaProcess_pdf1Save_get
//    if _newclass:
//        pdf1Save = _swig_property(_pythia8.SigmaProcess_pdf1Save_get, _pythia8.SigmaProcess_pdf1Save_set)
//    __swig_setmethods__["pdf2Save"] = _pythia8.SigmaProcess_pdf2Save_set
//    __swig_getmethods__["pdf2Save"] = _pythia8.SigmaProcess_pdf2Save_get
//    if _newclass:
//        pdf2Save = _swig_property(_pythia8.SigmaProcess_pdf2Save_get, _pythia8.SigmaProcess_pdf2Save_set)
//    __swig_setmethods__["sigmaSumSave"] = _pythia8.SigmaProcess_sigmaSumSave_set
//    __swig_getmethods__["sigmaSumSave"] = _pythia8.SigmaProcess_sigmaSumSave_get
//    if _newclass:
//        sigmaSumSave = _swig_property(_pythia8.SigmaProcess_sigmaSumSave_get, _pythia8.SigmaProcess_sigmaSumSave_set)
//    __swig_setmethods__["id1"] = _pythia8.SigmaProcess_id1_set
//    __swig_getmethods__["id1"] = _pythia8.SigmaProcess_id1_get
//    if _newclass:
//        id1 = _swig_property(_pythia8.SigmaProcess_id1_get, _pythia8.SigmaProcess_id1_set)
//    __swig_setmethods__["id2"] = _pythia8.SigmaProcess_id2_set
//    __swig_getmethods__["id2"] = _pythia8.SigmaProcess_id2_get
//    if _newclass:
//        id2 = _swig_property(_pythia8.SigmaProcess_id2_get, _pythia8.SigmaProcess_id2_set)
//    __swig_setmethods__["id3"] = _pythia8.SigmaProcess_id3_set
//    __swig_getmethods__["id3"] = _pythia8.SigmaProcess_id3_get
//    if _newclass:
//        id3 = _swig_property(_pythia8.SigmaProcess_id3_get, _pythia8.SigmaProcess_id3_set)
//    __swig_setmethods__["id4"] = _pythia8.SigmaProcess_id4_set
//    __swig_getmethods__["id4"] = _pythia8.SigmaProcess_id4_get
//    if _newclass:
//        id4 = _swig_property(_pythia8.SigmaProcess_id4_get, _pythia8.SigmaProcess_id4_set)
//    __swig_setmethods__["id5"] = _pythia8.SigmaProcess_id5_set
//    __swig_getmethods__["id5"] = _pythia8.SigmaProcess_id5_get
//    if _newclass:
//        id5 = _swig_property(_pythia8.SigmaProcess_id5_get, _pythia8.SigmaProcess_id5_set)
//    __swig_setmethods__["idSave"] = _pythia8.SigmaProcess_idSave_set
//    __swig_getmethods__["idSave"] = _pythia8.SigmaProcess_idSave_get
//    if _newclass:
//        idSave = _swig_property(_pythia8.SigmaProcess_idSave_get, _pythia8.SigmaProcess_idSave_set)
//    __swig_setmethods__["colSave"] = _pythia8.SigmaProcess_colSave_set
//    __swig_getmethods__["colSave"] = _pythia8.SigmaProcess_colSave_get
//    if _newclass:
//        colSave = _swig_property(_pythia8.SigmaProcess_colSave_get, _pythia8.SigmaProcess_colSave_set)
//    __swig_setmethods__["acolSave"] = _pythia8.SigmaProcess_acolSave_set
//    __swig_getmethods__["acolSave"] = _pythia8.SigmaProcess_acolSave_get
//    if _newclass:
//        acolSave = _swig_property(_pythia8.SigmaProcess_acolSave_get, _pythia8.SigmaProcess_acolSave_set)
//    __swig_setmethods__["mSave"] = _pythia8.SigmaProcess_mSave_set
//    __swig_getmethods__["mSave"] = _pythia8.SigmaProcess_mSave_get
//    if _newclass:
//        mSave = _swig_property(_pythia8.SigmaProcess_mSave_get, _pythia8.SigmaProcess_mSave_set)
//    __swig_setmethods__["cosTheta"] = _pythia8.SigmaProcess_cosTheta_set
//    __swig_getmethods__["cosTheta"] = _pythia8.SigmaProcess_cosTheta_get
//    if _newclass:
//        cosTheta = _swig_property(_pythia8.SigmaProcess_cosTheta_get, _pythia8.SigmaProcess_cosTheta_set)
//    __swig_setmethods__["sinTheta"] = _pythia8.SigmaProcess_sinTheta_set
//    __swig_getmethods__["sinTheta"] = _pythia8.SigmaProcess_sinTheta_get
//    if _newclass:
//        sinTheta = _swig_property(_pythia8.SigmaProcess_sinTheta_get, _pythia8.SigmaProcess_sinTheta_set)
//    __swig_setmethods__["phi"] = _pythia8.SigmaProcess_phi_set
//    __swig_getmethods__["phi"] = _pythia8.SigmaProcess_phi_get
//    if _newclass:
//        phi = _swig_property(_pythia8.SigmaProcess_phi_get, _pythia8.SigmaProcess_phi_set)
//    __swig_setmethods__["sHMass"] = _pythia8.SigmaProcess_sHMass_set
//    __swig_getmethods__["sHMass"] = _pythia8.SigmaProcess_sHMass_get
//    if _newclass:
//        sHMass = _swig_property(_pythia8.SigmaProcess_sHMass_get, _pythia8.SigmaProcess_sHMass_set)
//    __swig_setmethods__["sHBeta"] = _pythia8.SigmaProcess_sHBeta_set
//    __swig_getmethods__["sHBeta"] = _pythia8.SigmaProcess_sHBeta_get
//    if _newclass:
//        sHBeta = _swig_property(_pythia8.SigmaProcess_sHBeta_get, _pythia8.SigmaProcess_sHBeta_set)
//    __swig_setmethods__["pT2Mass"] = _pythia8.SigmaProcess_pT2Mass_set
//    __swig_getmethods__["pT2Mass"] = _pythia8.SigmaProcess_pT2Mass_get
//    if _newclass:
//        pT2Mass = _swig_property(_pythia8.SigmaProcess_pT2Mass_get, _pythia8.SigmaProcess_pT2Mass_set)
//    __swig_setmethods__["pTFin"] = _pythia8.SigmaProcess_pTFin_set
//    __swig_getmethods__["pTFin"] = _pythia8.SigmaProcess_pTFin_get
//    if _newclass:
//        pTFin = _swig_property(_pythia8.SigmaProcess_pTFin_get, _pythia8.SigmaProcess_pTFin_set)
//    __swig_setmethods__["parton"] = _pythia8.SigmaProcess_parton_set
//    __swig_getmethods__["parton"] = _pythia8.SigmaProcess_parton_get
//    if _newclass:
//        parton = _swig_property(_pythia8.SigmaProcess_parton_get, _pythia8.SigmaProcess_parton_set)
//    __swig_setmethods__["partonT"] = _pythia8.SigmaProcess_partonT_set
//    __swig_getmethods__["partonT"] = _pythia8.SigmaProcess_partonT_get
//    if _newclass:
//        partonT = _swig_property(_pythia8.SigmaProcess_partonT_get, _pythia8.SigmaProcess_partonT_set)
//    __swig_setmethods__["mSaveT"] = _pythia8.SigmaProcess_mSaveT_set
//    __swig_getmethods__["mSaveT"] = _pythia8.SigmaProcess_mSaveT_get
//    if _newclass:
//        mSaveT = _swig_property(_pythia8.SigmaProcess_mSaveT_get, _pythia8.SigmaProcess_mSaveT_set)
//    __swig_setmethods__["pTFinT"] = _pythia8.SigmaProcess_pTFinT_set
//    __swig_getmethods__["pTFinT"] = _pythia8.SigmaProcess_pTFinT_get
//    if _newclass:
//        pTFinT = _swig_property(_pythia8.SigmaProcess_pTFinT_get, _pythia8.SigmaProcess_pTFinT_set)
//    __swig_setmethods__["cosThetaT"] = _pythia8.SigmaProcess_cosThetaT_set
//    __swig_getmethods__["cosThetaT"] = _pythia8.SigmaProcess_cosThetaT_get
//    if _newclass:
//        cosThetaT = _swig_property(_pythia8.SigmaProcess_cosThetaT_get, _pythia8.SigmaProcess_cosThetaT_set)
//    __swig_setmethods__["sinThetaT"] = _pythia8.SigmaProcess_sinThetaT_set
//    __swig_getmethods__["sinThetaT"] = _pythia8.SigmaProcess_sinThetaT_get
//    if _newclass:
//        sinThetaT = _swig_property(_pythia8.SigmaProcess_sinThetaT_get, _pythia8.SigmaProcess_sinThetaT_set)
//    __swig_setmethods__["phiT"] = _pythia8.SigmaProcess_phiT_set
//    __swig_getmethods__["phiT"] = _pythia8.SigmaProcess_phiT_get
//    if _newclass:
//        phiT = _swig_property(_pythia8.SigmaProcess_phiT_get, _pythia8.SigmaProcess_phiT_set)
//
//    def setupForME(self):
//        """
//Store common subprocess kinematics quantities.
//Store Q2 renormalization and factorization scales, and related values.
//Store flavour, colour, anticolour, mass, angles and the whole particle.
//Minimal set of saved kinematics for trial interactions when
//using the x-dependent matter profile of multiparton interactions.
//Calculate and store all modified masses and four-vectors
//intended for matrix elements. Return false if failed.
//"""
//        return _pythia8.SigmaProcess_setupForME(self)
//
//    def setupForMEin(self):
//        """
//"""
//        return _pythia8.SigmaProcess_setupForMEin(self)
//    __swig_setmethods__["mME"] = _pythia8.SigmaProcess_mME_set
//    __swig_getmethods__["mME"] = _pythia8.SigmaProcess_mME_get
//    if _newclass:
//        mME = _swig_property(_pythia8.SigmaProcess_mME_get, _pythia8.SigmaProcess_mME_set)
//    __swig_setmethods__["pME"] = _pythia8.SigmaProcess_pME_set
//    __swig_getmethods__["pME"] = _pythia8.SigmaProcess_pME_get
//    if _newclass:
//        pME = _swig_property(_pythia8.SigmaProcess_pME_get, _pythia8.SigmaProcess_pME_set)
//    __swig_setmethods__["swapTU"] = _pythia8.SigmaProcess_swapTU_set
//    __swig_getmethods__["swapTU"] = _pythia8.SigmaProcess_swapTU_get
//    if _newclass:
//        swapTU = _swig_property(_pythia8.SigmaProcess_swapTU_get, _pythia8.SigmaProcess_swapTU_set)
//
//    def setId(self, id1in=0, id2in=0, id3in=0, id4in=0, id5in=0):
//        """
//Store whether tHat and uHat are swapped (= same as swap 3 and 4).
//Set flavour, colour and anticolour.
//"""
//        return _pythia8.SigmaProcess_setId(self, id1in, id2in, id3in, id4in, id5in)
//
//    def setColAcol(self, col1=0, acol1=0, col2=0, acol2=0, col3=0, acol3=0, col4=0, acol4=0, col5=0, acol5=0):
//        """
//"""
//        return _pythia8.SigmaProcess_setColAcol(self, col1, acol1, col2, acol2, col3, acol3, col4, acol4, col5, acol5)
//
//    def swapColAcol(self):
//        """
//"""
//        return _pythia8.SigmaProcess_swapColAcol(self)
//
//    def swapCol1234(self):
//        """
//"""
//        return _pythia8.SigmaProcess_swapCol1234(self)
//
//    def swapCol12(self):
//        """
//"""
//        return _pythia8.SigmaProcess_swapCol12(self)
//
//    def swapCol34(self):
//        """
//"""
//        return _pythia8.SigmaProcess_swapCol34(self)
//
//    def weightTopDecay(self, process, iResBeg, iResEnd):
//        """
//Common code for top and Higgs secondary decay angular weights.
//"""
//        return _pythia8.SigmaProcess_weightTopDecay(self, process, iResBeg, iResEnd)
//
//    def weightHiggsDecay(self, process, iResBeg, iResEnd):
//        """
//"""
//        return _pythia8.SigmaProcess_weightHiggsDecay(self, process, iResBeg, iResEnd)
//    def __disown__(self):
//        self.this.disown()
//        _pythia8.disown_SigmaProcess(self)
//        return weakref_proxy(self)
//SigmaProcess_swigregister = _pythia8.SigmaProcess_swigregister
//SigmaProcess_swigregister(SigmaProcess)
//SigmaProcess.CONVERT2MB = _pythia8.cvar.SigmaProcess_CONVERT2MB
//SigmaProcess.MASSMARGIN = _pythia8.cvar.SigmaProcess_MASSMARGIN
//SigmaProcess.COMPRELERR = _pythia8.cvar.SigmaProcess_COMPRELERR
//SigmaProcess.NCOMPSTEP = _pythia8.cvar.SigmaProcess_NCOMPSTEP
//
//class Sigma0Process(SigmaProcess):
//    """
//Sigma0Process is the base class for unresolved and minimum-bias processes.
//It is derived from SigmaProcess.
//"""
//    __swig_setmethods__ = {}
//    for _s in [SigmaProcess]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma0Process, name, value)
//    __swig_getmethods__ = {}
//    for _s in [SigmaProcess]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma0Process, name)
//
//    def __init__(self, *args, **kwargs):
//        """
//Constructor.
//"""
//        raise AttributeError("No constructor defined")
//    __repr__ = _swig_repr
//    __swig_destroy__ = _pythia8.delete_Sigma0Process
//    __del__ = lambda self: None
//
//    def nFinal(self):
//        """
//Number of final-state particles.
//"""
//        return _pythia8.Sigma0Process_nFinal(self)
//
//    def initFlux(self):
//        """
//No partonic flux to be set up.
//"""
//        return _pythia8.Sigma0Process_initFlux(self)
//
//    def sigmaHat(self):
//        """
//"""
//        return _pythia8.Sigma0Process_sigmaHat(self)
//
//    def sigmaPDF(self, arg2, arg3, arg4, arg5, arg6):
//        """
//Since no PDF's there is no difference from above.
//"""
//        return _pythia8.Sigma0Process_sigmaPDF(self, arg2, arg3, arg4, arg5, arg6)
//
//    def convert2mb(self):
//        """
//Answer for these processes already in mb, so do not convert.
//"""
//        return _pythia8.Sigma0Process_convert2mb(self)
//Sigma0Process_swigregister = _pythia8.Sigma0Process_swigregister
//Sigma0Process_swigregister(Sigma0Process)
//
//class Sigma1Process(SigmaProcess):
//    """
//Sigma1Process is the base class for 2 -> 1 processes.
//It is derived from SigmaProcess.
//"""
//    __swig_setmethods__ = {}
//    for _s in [SigmaProcess]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma1Process, name, value)
//    __swig_getmethods__ = {}
//    for _s in [SigmaProcess]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma1Process, name)
//
//    def __init__(self, *args, **kwargs):
//        """
//Constructor.
//"""
//        raise AttributeError("No constructor defined")
//    __repr__ = _swig_repr
//    __swig_destroy__ = _pythia8.delete_Sigma1Process
//    __del__ = lambda self: None
//
//    def nFinal(self):
//        """
//Number of final-state particles.
//"""
//        return _pythia8.Sigma1Process_nFinal(self)
//
//    def set1Kin(self, x1in, x2in, sHin):
//        """
//Input and complement kinematics for resolved 2 -> 1 process.
//"""
//        return _pythia8.Sigma1Process_set1Kin(self, x1in, x2in, sHin)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat) for resolved 2 -> 1 processes.
//"""
//        return _pythia8.Sigma1Process_sigmaHat(self)
//
//    def sigmaHatWrap(self, id1in=0, id2in=0):
//        """
//Wrapper to sigmaHat, to (a) store current incoming flavours,
//(b) convert from GeV^-2 to mb where required, and
//(c) convert from |M|^2 to d(sigmaHat)/d(tHat) where required.
//"""
//        return _pythia8.Sigma1Process_sigmaHatWrap(self, id1in, id2in)
//Sigma1Process_swigregister = _pythia8.Sigma1Process_swigregister
//Sigma1Process_swigregister(Sigma1Process)
//
//class Sigma2Process(SigmaProcess):
//    """
//Sigma2Process is the base class for 2 -> 2 processes.
//It is derived from SigmaProcess.
//"""
//    __swig_setmethods__ = {}
//    for _s in [SigmaProcess]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2Process, name, value)
//    __swig_getmethods__ = {}
//    for _s in [SigmaProcess]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2Process, name)
//
//    def __init__(self, *args, **kwargs):
//        """
//Constructor.
//"""
//        raise AttributeError("No constructor defined")
//    __repr__ = _swig_repr
//    __swig_destroy__ = _pythia8.delete_Sigma2Process
//    __del__ = lambda self: None
//
//    def nFinal(self):
//        """
//Number of final-state particles.
//"""
//        return _pythia8.Sigma2Process_nFinal(self)
//
//    def set2Kin(self, x1in, x2in, sHin, tHin, m3in, m4in, runBW3in, runBW4in):
//        """
//Input and complement kinematics for resolved 2 -> 2 process.
//"""
//        return _pythia8.Sigma2Process_set2Kin(self, x1in, x2in, sHin, tHin, m3in, m4in, runBW3in, runBW4in)
//
//    def set2KinMPI(self, x1in, x2in, sHin, tHin, uHin, alpSin, alpEMin, needMasses, m3in, m4in):
//        """
//Ditto, but for Multiparton Interactions applications, so different input.
//"""
//        return _pythia8.Sigma2Process_set2KinMPI(self, x1in, x2in, sHin, tHin, uHin, alpSin, alpEMin, needMasses, m3in, m4in)
//
//    def sigmaHat(self):
//        """
//"""
//        return _pythia8.Sigma2Process_sigmaHat(self)
//
//    def sigmaHatWrap(self, id1in=0, id2in=0):
//        """
//Wrapper to sigmaHat, to (a) store current incoming flavours,
//(b) convert from GeV^-2 to mb where required, and
//(c) convert from |M|^2 to d(sigmaHat)/d(tHat) where required.
//"""
//        return _pythia8.Sigma2Process_sigmaHatWrap(self, id1in, id2in)
//
//    def final2KinMPI(self, i1Res=0, i2Res=0, p1Res=0., p2Res=0., m1Res=0., m2Res=0.):
//        """
//Perform kinematics for a Multiparton Interaction, in its rest frame.
//"""
//        return _pythia8.Sigma2Process_final2KinMPI(self, i1Res, i2Res, p1Res, p2Res, m1Res, m2Res)
//Sigma2Process_swigregister = _pythia8.Sigma2Process_swigregister
//Sigma2Process_swigregister(Sigma2Process)
//
//class Sigma3Process(SigmaProcess):
//    """
//Sigma3Process is the base class for 2 -> 3 processes.
//It is derived from SigmaProcess.
//"""
//    __swig_setmethods__ = {}
//    for _s in [SigmaProcess]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma3Process, name, value)
//    __swig_getmethods__ = {}
//    for _s in [SigmaProcess]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma3Process, name)
//
//    def __init__(self, *args, **kwargs):
//        """
//Constructor.
//"""
//        raise AttributeError("No constructor defined")
//    __repr__ = _swig_repr
//    __swig_destroy__ = _pythia8.delete_Sigma3Process
//    __del__ = lambda self: None
//
//    def nFinal(self):
//        """
//Number of final-state particles.
//"""
//        return _pythia8.Sigma3Process_nFinal(self)
//
//    def set3Kin(self, x1in, x2in, sHin, p3cmIn, p4cmIn, p5cmIn, m3in, m4in, m5in, runBW3in, runBW4in, runBW5in):
//        """
//Input and complement kinematics for resolved 2 -> 3 process.
//"""
//        return _pythia8.Sigma3Process_set3Kin(self, x1in, x2in, sHin, p3cmIn, p4cmIn, p5cmIn, m3in, m4in, m5in, runBW3in, runBW4in, runBW5in)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat) for resolved 2 -> 3 processes.
//"""
//        return _pythia8.Sigma3Process_sigmaHat(self)
//Sigma3Process_swigregister = _pythia8.Sigma3Process_swigregister
//Sigma3Process_swigregister(Sigma3Process)
//
//class SigmaLHAProcess(SigmaProcess):
//    """
//SigmaLHAProcess is a wrapper class for Les Houches Accord external input.
//It is derived from SigmaProcess.
//"""
//    __swig_setmethods__ = {}
//    for _s in [SigmaProcess]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SigmaLHAProcess, name, value)
//    __swig_getmethods__ = {}
//    for _s in [SigmaProcess]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, SigmaLHAProcess, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_SigmaLHAProcess()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_SigmaLHAProcess
//    __del__ = lambda self: None
//
//    def initFlux(self):
//        """
//No partonic flux to be set up.
//"""
//        return _pythia8.SigmaLHAProcess_initFlux(self)
//
//    def sigmaPDF(self, arg2, arg3, arg4, arg5, arg6):
//        """
//Dummy function: action is put in PhaseSpaceLHA.
//"""
//        return _pythia8.SigmaLHAProcess_sigmaPDF(self, arg2, arg3, arg4, arg5, arg6)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for decay angular configuration, where relevant.
//"""
//        return _pythia8.SigmaLHAProcess_weightDecay(self, process, iResBeg, iResEnd)
//
//    def setScale(self):
//        """
//Set scale, when that is missing for an external LHA process.
//"""
//        return _pythia8.SigmaLHAProcess_setScale(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.SigmaLHAProcess_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.SigmaLHAProcess_code(self)
//
//    def nFinal(self):
//        """
//Number of final-state particles depends on current process choice.
//"""
//        return _pythia8.SigmaLHAProcess_nFinal(self)
//
//    def convert2mb(self):
//        """
//Answer for these processes not in GeV^-2, so do not do this conversion.
//"""
//        return _pythia8.SigmaLHAProcess_convert2mb(self)
//
//    def isLHA(self):
//        """
//Ensure special treatment of Les Houches processes.
//"""
//        return _pythia8.SigmaLHAProcess_isLHA(self)
//
//    def allowNegativeSigma(self):
//        """
//Special treatment needed if negative cross sections allowed.
//"""
//        return _pythia8.SigmaLHAProcess_allowNegativeSigma(self)
//SigmaLHAProcess_swigregister = _pythia8.SigmaLHAProcess_swigregister
//SigmaLHAProcess_swigregister(SigmaLHAProcess)
//
//class Sigma0nonDiffractive(Sigma0Process):
//    """
//A derived class for minimum-bias (inelastic, nondiffractive) events.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma0Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma0nonDiffractive, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma0Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma0nonDiffractive, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma0nonDiffractive()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaHat(self):
//        """
//Evaluate sigma.
//"""
//        return _pythia8.Sigma0nonDiffractive_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma0nonDiffractive_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma0nonDiffractive_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma0nonDiffractive_code(self)
//
//    def isNonDiff(self):
//        """
//"""
//        return _pythia8.Sigma0nonDiffractive_isNonDiff(self)
//    __swig_destroy__ = _pythia8.delete_Sigma0nonDiffractive
//    __del__ = lambda self: None
//Sigma0nonDiffractive_swigregister = _pythia8.Sigma0nonDiffractive_swigregister
//Sigma0nonDiffractive_swigregister(Sigma0nonDiffractive)
//
//class Sigma0AB2AB(Sigma0Process):
//    """
//A derived class for elastic scattering A B -> A B.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma0Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma0AB2AB, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma0Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma0AB2AB, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma0AB2AB()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaHat(self):
//        """
//Evaluate sigma.
//"""
//        return _pythia8.Sigma0AB2AB_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma0AB2AB_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma0AB2AB_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma0AB2AB_code(self)
//
//    def isResolved(self):
//        """
//"""
//        return _pythia8.Sigma0AB2AB_isResolved(self)
//    __swig_destroy__ = _pythia8.delete_Sigma0AB2AB
//    __del__ = lambda self: None
//Sigma0AB2AB_swigregister = _pythia8.Sigma0AB2AB_swigregister
//Sigma0AB2AB_swigregister(Sigma0AB2AB)
//
//class Sigma0AB2XB(Sigma0Process):
//    """
//A derived class for single diffractive scattering A B -> X B.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma0Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma0AB2XB, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma0Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma0AB2XB, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma0AB2XB()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaHat(self):
//        """
//Evaluate sigma.
//"""
//        return _pythia8.Sigma0AB2XB_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma0AB2XB_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma0AB2XB_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma0AB2XB_code(self)
//
//    def isResolved(self):
//        """
//"""
//        return _pythia8.Sigma0AB2XB_isResolved(self)
//
//    def isDiffA(self):
//        """
//"""
//        return _pythia8.Sigma0AB2XB_isDiffA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma0AB2XB
//    __del__ = lambda self: None
//Sigma0AB2XB_swigregister = _pythia8.Sigma0AB2XB_swigregister
//Sigma0AB2XB_swigregister(Sigma0AB2XB)
//
//class Sigma0AB2AX(Sigma0Process):
//    """
//A derived class for single diffractive scattering A B -> A X.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma0Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma0AB2AX, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma0Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma0AB2AX, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma0AB2AX()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaHat(self):
//        """
//Evaluate sigma.
//"""
//        return _pythia8.Sigma0AB2AX_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma0AB2AX_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma0AB2AX_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma0AB2AX_code(self)
//
//    def isResolved(self):
//        """
//"""
//        return _pythia8.Sigma0AB2AX_isResolved(self)
//
//    def isDiffB(self):
//        """
//"""
//        return _pythia8.Sigma0AB2AX_isDiffB(self)
//    __swig_destroy__ = _pythia8.delete_Sigma0AB2AX
//    __del__ = lambda self: None
//Sigma0AB2AX_swigregister = _pythia8.Sigma0AB2AX_swigregister
//Sigma0AB2AX_swigregister(Sigma0AB2AX)
//
//class Sigma0AB2XX(Sigma0Process):
//    """
//A derived class for double diffractive scattering A B -> X X.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma0Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma0AB2XX, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma0Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma0AB2XX, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma0AB2XX()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaHat(self):
//        """
//Evaluate sigma.
//"""
//        return _pythia8.Sigma0AB2XX_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma0AB2XX_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma0AB2XX_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma0AB2XX_code(self)
//
//    def isResolved(self):
//        """
//"""
//        return _pythia8.Sigma0AB2XX_isResolved(self)
//
//    def isDiffA(self):
//        """
//"""
//        return _pythia8.Sigma0AB2XX_isDiffA(self)
//
//    def isDiffB(self):
//        """
//"""
//        return _pythia8.Sigma0AB2XX_isDiffB(self)
//    __swig_destroy__ = _pythia8.delete_Sigma0AB2XX
//    __del__ = lambda self: None
//Sigma0AB2XX_swigregister = _pythia8.Sigma0AB2XX_swigregister
//Sigma0AB2XX_swigregister(Sigma0AB2XX)
//
//class Sigma0AB2AXB(Sigma0Process):
//    """
//A derived class for central diffractive scattering A B -> A X B.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma0Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma0AB2AXB, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma0Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma0AB2AXB, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma0AB2AXB()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaHat(self):
//        """
//Evaluate sigma.
//"""
//        return _pythia8.Sigma0AB2AXB_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma0AB2AXB_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma0AB2AXB_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma0AB2AXB_code(self)
//
//    def nFinal(self):
//        """
//"""
//        return _pythia8.Sigma0AB2AXB_nFinal(self)
//
//    def isResolved(self):
//        """
//"""
//        return _pythia8.Sigma0AB2AXB_isResolved(self)
//
//    def isDiffC(self):
//        """
//"""
//        return _pythia8.Sigma0AB2AXB_isDiffC(self)
//    __swig_destroy__ = _pythia8.delete_Sigma0AB2AXB
//    __del__ = lambda self: None
//Sigma0AB2AXB_swigregister = _pythia8.Sigma0AB2AXB_swigregister
//Sigma0AB2AXB_swigregister(Sigma0AB2AXB)
//
//class Sigma2gg2gg(Sigma2Process):
//    """
//A derived class for g g -> g g.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2gg2gg, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2gg2gg, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2gg2gg()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2gg2gg_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2gg2gg_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2gg2gg_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2gg2gg_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2gg2gg_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2gg2gg_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2gg2gg
//    __del__ = lambda self: None
//Sigma2gg2gg_swigregister = _pythia8.Sigma2gg2gg_swigregister
//Sigma2gg2gg_swigregister(Sigma2gg2gg)
//
//class Sigma2gg2qqbar(Sigma2Process):
//    """
//A derived class for g g -> q qbar (q = u, d, s, i.e. almost massless).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2gg2qqbar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2gg2qqbar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2gg2qqbar()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2gg2qqbar_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2gg2qqbar_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2gg2qqbar_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2gg2qqbar_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2gg2qqbar_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2gg2qqbar_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2gg2qqbar_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2gg2qqbar
//    __del__ = lambda self: None
//Sigma2gg2qqbar_swigregister = _pythia8.Sigma2gg2qqbar_swigregister
//Sigma2gg2qqbar_swigregister(Sigma2gg2qqbar)
//
//class Sigma2qg2qg(Sigma2Process):
//    """
//A derived class for q g -> q g (q = u, d, s, c, b).
//Use massless approximation also for Q since no alternative.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qg2qg, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qg2qg, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qg2qg()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qg2qg_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qg2qg_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qg2qg_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qg2qg_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qg2qg_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qg2qg_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qg2qg
//    __del__ = lambda self: None
//Sigma2qg2qg_swigregister = _pythia8.Sigma2qg2qg_swigregister
//Sigma2qg2qg_swigregister(Sigma2qg2qg)
//
//class Sigma2qq2qq(Sigma2Process):
//    """
//A derived class for q qbar' -> q qbar' or q q' -> q q'
//(qbar qbar' -> qbar qbar'), q' may be same as q.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qq2qq, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qq2qq, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qq2qq()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qq2qq_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qq2qq_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qq2qq_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qq2qq_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qq2qq_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qq2qq_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qq2qq
//    __del__ = lambda self: None
//Sigma2qq2qq_swigregister = _pythia8.Sigma2qq2qq_swigregister
//Sigma2qq2qq_swigregister(Sigma2qq2qq)
//
//class Sigma2qqbar2gg(Sigma2Process):
//    """
//A derived class for q qbar -> g g.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2gg, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2gg, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qqbar2gg()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qqbar2gg_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qqbar2gg_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qqbar2gg_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qqbar2gg_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2gg_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2gg_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2gg
//    __del__ = lambda self: None
//Sigma2qqbar2gg_swigregister = _pythia8.Sigma2qqbar2gg_swigregister
//Sigma2qqbar2gg_swigregister(Sigma2qqbar2gg)
//
//class Sigma2qqbar2qqbarNew(Sigma2Process):
//    """
//A derived class for q qbar -> q' qbar'.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2qqbarNew, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2qqbarNew, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qqbar2qqbarNew()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qqbar2qqbarNew_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qqbar2qqbarNew_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qqbar2qqbarNew_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qqbar2qqbarNew_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qqbar2qqbarNew_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2qqbarNew_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2qqbarNew_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2qqbarNew
//    __del__ = lambda self: None
//Sigma2qqbar2qqbarNew_swigregister = _pythia8.Sigma2qqbar2qqbarNew_swigregister
//Sigma2qqbar2qqbarNew_swigregister(Sigma2qqbar2qqbarNew)
//
//class Sigma2gg2QQbar(Sigma2Process):
//    """
//A derived class for g g -> Q Qbar (Q = c, b or t).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2gg2QQbar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2gg2QQbar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idIn, codeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2gg2QQbar(idIn, codeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2gg2QQbar_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2gg2QQbar_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2gg2QQbar_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2gg2QQbar_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for W decay angles in top decay (else inactive).
//"""
//        return _pythia8.Sigma2gg2QQbar_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2gg2QQbar_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2gg2QQbar_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2gg2QQbar_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2gg2QQbar_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2gg2QQbar_id4Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2gg2QQbar
//    __del__ = lambda self: None
//Sigma2gg2QQbar_swigregister = _pythia8.Sigma2gg2QQbar_swigregister
//Sigma2gg2QQbar_swigregister(Sigma2gg2QQbar)
//
//class Sigma2qqbar2QQbar(Sigma2Process):
//    """
//A derived class for q qbar -> Q Qbar (Q = c, b or t).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2QQbar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2QQbar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idIn, codeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qqbar2QQbar(idIn, codeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qqbar2QQbar_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qqbar2QQbar_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qqbar2QQbar_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qqbar2QQbar_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for W decay angles in top decay (else inactive).
//"""
//        return _pythia8.Sigma2qqbar2QQbar_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qqbar2QQbar_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2QQbar_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2QQbar_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2QQbar_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2QQbar_id4Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2QQbar
//    __del__ = lambda self: None
//Sigma2qqbar2QQbar_swigregister = _pythia8.Sigma2qqbar2QQbar_swigregister
//Sigma2qqbar2QQbar_swigregister(Sigma2qqbar2QQbar)
//
//class Sigma3gg2ggg(Sigma3Process):
//    """
//A derived class for g g -> g g g.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma3Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma3gg2ggg, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma3Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma3gg2ggg, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma3gg2ggg()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma3gg2ggg_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma3gg2ggg_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma3gg2ggg_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma3gg2ggg_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma3gg2ggg_code(self)
//
//    def nFinal(self):
//        """
//"""
//        return _pythia8.Sigma3gg2ggg_nFinal(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma3gg2ggg_inFlux(self)
//
//    def isQCD3body(self):
//        """
//"""
//        return _pythia8.Sigma3gg2ggg_isQCD3body(self)
//    __swig_destroy__ = _pythia8.delete_Sigma3gg2ggg
//    __del__ = lambda self: None
//Sigma3gg2ggg_swigregister = _pythia8.Sigma3gg2ggg_swigregister
//Sigma3gg2ggg_swigregister(Sigma3gg2ggg)
//
//class Sigma3qqbar2ggg(Sigma3Process):
//    """
//A derived class for q qbar -> g g g.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma3Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma3qqbar2ggg, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma3Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma3qqbar2ggg, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma3qqbar2ggg()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma3qqbar2ggg_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma3qqbar2ggg_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma3qqbar2ggg_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma3qqbar2ggg_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma3qqbar2ggg_code(self)
//
//    def nFinal(self):
//        """
//"""
//        return _pythia8.Sigma3qqbar2ggg_nFinal(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma3qqbar2ggg_inFlux(self)
//
//    def isQCD3body(self):
//        """
//"""
//        return _pythia8.Sigma3qqbar2ggg_isQCD3body(self)
//    __swig_destroy__ = _pythia8.delete_Sigma3qqbar2ggg
//    __del__ = lambda self: None
//Sigma3qqbar2ggg_swigregister = _pythia8.Sigma3qqbar2ggg_swigregister
//Sigma3qqbar2ggg_swigregister(Sigma3qqbar2ggg)
//
//class Sigma3qg2qgg(Sigma3qqbar2ggg):
//    """
//A derived class for q g -> q g g
//Derived from Sigma3qqbar2ggg
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma3qqbar2ggg]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma3qg2qgg, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma3qqbar2ggg]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma3qg2qgg, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma3qg2qgg()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma3qg2qgg_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma3qg2qgg_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma3qg2qgg_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma3qg2qgg_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma3qg2qgg_code(self)
//
//    def nFinal(self):
//        """
//"""
//        return _pythia8.Sigma3qg2qgg_nFinal(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma3qg2qgg_inFlux(self)
//
//    def isQCD3body(self):
//        """
//"""
//        return _pythia8.Sigma3qg2qgg_isQCD3body(self)
//    __swig_destroy__ = _pythia8.delete_Sigma3qg2qgg
//    __del__ = lambda self: None
//Sigma3qg2qgg_swigregister = _pythia8.Sigma3qg2qgg_swigregister
//Sigma3qg2qgg_swigregister(Sigma3qg2qgg)
//
//class Sigma3gg2qqbarg(Sigma3qqbar2ggg):
//    """
//A derived class for g g -> q qbar g
//Derived from Sigma3qqbar2ggg
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma3qqbar2ggg]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma3gg2qqbarg, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma3qqbar2ggg]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma3gg2qqbarg, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma3gg2qqbarg()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma3gg2qqbarg_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma3gg2qqbarg_sigmaKin(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma3gg2qqbarg_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma3gg2qqbarg_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma3gg2qqbarg_code(self)
//
//    def nFinal(self):
//        """
//"""
//        return _pythia8.Sigma3gg2qqbarg_nFinal(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma3gg2qqbarg_inFlux(self)
//
//    def isQCD3body(self):
//        """
//"""
//        return _pythia8.Sigma3gg2qqbarg_isQCD3body(self)
//    __swig_destroy__ = _pythia8.delete_Sigma3gg2qqbarg
//    __del__ = lambda self: None
//Sigma3gg2qqbarg_swigregister = _pythia8.Sigma3gg2qqbarg_swigregister
//Sigma3gg2qqbarg_swigregister(Sigma3gg2qqbarg)
//
//class Sigma3qq2qqgDiff(Sigma3Process):
//    """
//A derived class for q q' -> q q' g
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma3Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma3qq2qqgDiff, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma3Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma3qq2qqgDiff, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma3qq2qqgDiff()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma3qq2qqgDiff_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma3qq2qqgDiff_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma3qq2qqgDiff_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma3qq2qqgDiff_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma3qq2qqgDiff_code(self)
//
//    def nFinal(self):
//        """
//"""
//        return _pythia8.Sigma3qq2qqgDiff_nFinal(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma3qq2qqgDiff_inFlux(self)
//
//    def isQCD3body(self):
//        """
//"""
//        return _pythia8.Sigma3qq2qqgDiff_isQCD3body(self)
//    __swig_destroy__ = _pythia8.delete_Sigma3qq2qqgDiff
//    __del__ = lambda self: None
//Sigma3qq2qqgDiff_swigregister = _pythia8.Sigma3qq2qqgDiff_swigregister
//Sigma3qq2qqgDiff_swigregister(Sigma3qq2qqgDiff)
//
//class Sigma3qqbar2qqbargDiff(Sigma3qq2qqgDiff):
//    """
//A derived class for q qbar -> q' qbar' g
//Derived from Sigma3qq2qqgDiff
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma3qq2qqgDiff]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma3qqbar2qqbargDiff, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma3qq2qqgDiff]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma3qqbar2qqbargDiff, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma3qqbar2qqbargDiff()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma3qqbar2qqbargDiff_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma3qqbar2qqbargDiff_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma3qqbar2qqbargDiff_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma3qqbar2qqbargDiff_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma3qqbar2qqbargDiff_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma3qqbar2qqbargDiff_code(self)
//
//    def nFinal(self):
//        """
//"""
//        return _pythia8.Sigma3qqbar2qqbargDiff_nFinal(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma3qqbar2qqbargDiff_inFlux(self)
//
//    def isQCD3body(self):
//        """
//"""
//        return _pythia8.Sigma3qqbar2qqbargDiff_isQCD3body(self)
//    __swig_destroy__ = _pythia8.delete_Sigma3qqbar2qqbargDiff
//    __del__ = lambda self: None
//Sigma3qqbar2qqbargDiff_swigregister = _pythia8.Sigma3qqbar2qqbargDiff_swigregister
//Sigma3qqbar2qqbargDiff_swigregister(Sigma3qqbar2qqbargDiff)
//
//class Sigma3qg2qqqbarDiff(Sigma3qq2qqgDiff):
//    """
//A derived class for q g -> q q' qbar'
//Derived from Sigma3qq2qqgDiff
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma3qq2qqgDiff]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma3qg2qqqbarDiff, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma3qq2qqgDiff]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma3qg2qqqbarDiff, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma3qg2qqqbarDiff()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma3qg2qqqbarDiff_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma3qg2qqqbarDiff_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma3qg2qqqbarDiff_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma3qg2qqqbarDiff_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma3qg2qqqbarDiff_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma3qg2qqqbarDiff_code(self)
//
//    def nFinal(self):
//        """
//"""
//        return _pythia8.Sigma3qg2qqqbarDiff_nFinal(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma3qg2qqqbarDiff_inFlux(self)
//
//    def isQCD3body(self):
//        """
//"""
//        return _pythia8.Sigma3qg2qqqbarDiff_isQCD3body(self)
//    __swig_destroy__ = _pythia8.delete_Sigma3qg2qqqbarDiff
//    __del__ = lambda self: None
//Sigma3qg2qqqbarDiff_swigregister = _pythia8.Sigma3qg2qqqbarDiff_swigregister
//Sigma3qg2qqqbarDiff_swigregister(Sigma3qg2qqqbarDiff)
//
//class Sigma3qq2qqgSame(Sigma3Process):
//    """
//A derived class for q q -> q q g
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma3Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma3qq2qqgSame, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma3Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma3qq2qqgSame, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma3qq2qqgSame()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma3qq2qqgSame_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma3qq2qqgSame_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma3qq2qqgSame_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma3qq2qqgSame_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma3qq2qqgSame_code(self)
//
//    def nFinal(self):
//        """
//"""
//        return _pythia8.Sigma3qq2qqgSame_nFinal(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma3qq2qqgSame_inFlux(self)
//
//    def isQCD3body(self):
//        """
//"""
//        return _pythia8.Sigma3qq2qqgSame_isQCD3body(self)
//    __swig_destroy__ = _pythia8.delete_Sigma3qq2qqgSame
//    __del__ = lambda self: None
//Sigma3qq2qqgSame_swigregister = _pythia8.Sigma3qq2qqgSame_swigregister
//Sigma3qq2qqgSame_swigregister(Sigma3qq2qqgSame)
//
//class Sigma3qqbar2qqbargSame(Sigma3qq2qqgSame):
//    """
//A derived class for q q -> q q g
//Derived from Sigma3qq2qqgSame
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma3qq2qqgSame]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma3qqbar2qqbargSame, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma3qq2qqgSame]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma3qqbar2qqbargSame, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma3qqbar2qqbargSame()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma3qqbar2qqbargSame_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma3qqbar2qqbargSame_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma3qqbar2qqbargSame_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma3qqbar2qqbargSame_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma3qqbar2qqbargSame_code(self)
//
//    def nFinal(self):
//        """
//"""
//        return _pythia8.Sigma3qqbar2qqbargSame_nFinal(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma3qqbar2qqbargSame_inFlux(self)
//
//    def isQCD3body(self):
//        """
//"""
//        return _pythia8.Sigma3qqbar2qqbargSame_isQCD3body(self)
//    __swig_destroy__ = _pythia8.delete_Sigma3qqbar2qqbargSame
//    __del__ = lambda self: None
//Sigma3qqbar2qqbargSame_swigregister = _pythia8.Sigma3qqbar2qqbargSame_swigregister
//Sigma3qqbar2qqbargSame_swigregister(Sigma3qqbar2qqbargSame)
//
//class Sigma3qg2qqqbarSame(Sigma3qq2qqgSame):
//    """
//A derived class for q g -> q qbar q; same flavour.
//Derived from Sigma3qq2qqgSame
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma3qq2qqgSame]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma3qg2qqqbarSame, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma3qq2qqgSame]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma3qg2qqqbarSame, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma3qg2qqqbarSame()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma3qg2qqqbarSame_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma3qg2qqqbarSame_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma3qg2qqqbarSame_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma3qg2qqqbarSame_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma3qg2qqqbarSame_code(self)
//
//    def nFinal(self):
//        """
//"""
//        return _pythia8.Sigma3qg2qqqbarSame_nFinal(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma3qg2qqqbarSame_inFlux(self)
//
//    def isQCD3body(self):
//        """
//"""
//        return _pythia8.Sigma3qg2qqqbarSame_isQCD3body(self)
//    __swig_destroy__ = _pythia8.delete_Sigma3qg2qqqbarSame
//    __del__ = lambda self: None
//Sigma3qg2qqqbarSame_swigregister = _pythia8.Sigma3qg2qqqbarSame_swigregister
//Sigma3qg2qqqbarSame_swigregister(Sigma3qg2qqqbarSame)
//
//class UserHooks(_object):
//    """
//UserHooks is base class for user access to program execution.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, UserHooks, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, UserHooks, name)
//    __repr__ = _swig_repr
//    __swig_destroy__ = _pythia8.delete_UserHooks
//    __del__ = lambda self: None
//
//    def initPtr(self, infoPtrIn, settingsPtrIn, particleDataPtrIn, rndmPtrIn, beamAPtrIn, beamBPtrIn, beamPomAPtrIn, beamPomBPtrIn, coupSMPtrIn, partonSystemsPtrIn, sigmaTotPtrIn):
//        """
//Initialize pointers and workEvent. Note: not virtual.
//"""
//        return _pythia8.UserHooks_initPtr(self, infoPtrIn, settingsPtrIn, particleDataPtrIn, rndmPtrIn, beamAPtrIn, beamBPtrIn, beamPomAPtrIn, beamPomBPtrIn, coupSMPtrIn, partonSystemsPtrIn, sigmaTotPtrIn)
//
//    def initAfterBeams(self):
//        """
//Initialisation after beams have been set by Pythia::init().
//"""
//        return _pythia8.UserHooks_initAfterBeams(self)
//
//    def canModifySigma(self):
//        """
//Possibility to modify cross section of process.
//"""
//        return _pythia8.UserHooks_canModifySigma(self)
//
//    def multiplySigmaBy(self, sigmaProcessPtr, phaseSpacePtr, inEvent):
//        """
//Multiplicative factor modifying the cross section of a hard process.
//"""
//        return _pythia8.UserHooks_multiplySigmaBy(self, sigmaProcessPtr, phaseSpacePtr, inEvent)
//
//    def canBiasSelection(self):
//        """
//Possibility to bias selection of events, compensated by a weight.
//"""
//        return _pythia8.UserHooks_canBiasSelection(self)
//
//    def biasSelectionBy(self, sigmaProcessPtr, phaseSpacePtr, inEvent):
//        """
//Multiplicative factor in the phase space selection of a hard process.
//"""
//        return _pythia8.UserHooks_biasSelectionBy(self, sigmaProcessPtr, phaseSpacePtr, inEvent)
//
//    def biasedSelectionWeight(self):
//        """
//Event weight to compensate for selection weight above.
//"""
//        return _pythia8.UserHooks_biasedSelectionWeight(self)
//
//    def canVetoProcessLevel(self):
//        """
//Possibility to veto event after process-level selection.
//"""
//        return _pythia8.UserHooks_canVetoProcessLevel(self)
//
//    def doVetoProcessLevel(self, arg0):
//        """
//Decide whether to veto current process or not, based on process record.
//Usage: doVetoProcessLevel( process).
//"""
//        return _pythia8.UserHooks_doVetoProcessLevel(self, arg0)
//
//    def canVetoResonanceDecays(self):
//        """
//Possibility to veto resonance decay chain.
//"""
//        return _pythia8.UserHooks_canVetoResonanceDecays(self)
//
//    def doVetoResonanceDecays(self, arg0):
//        """
//Decide whether to veto current resonance decay chain or not, based on
//process record. Usage: doVetoProcessLevel( process).
//"""
//        return _pythia8.UserHooks_doVetoResonanceDecays(self, arg0)
//
//    def canVetoPT(self):
//        """
//Possibility to veto MPI + ISR + FSR evolution and kill event,
//making decision at a fixed pT scale. Useful for MLM-style matching.
//"""
//        return _pythia8.UserHooks_canVetoPT(self)
//
//    def scaleVetoPT(self):
//        """
//Transverse-momentum scale for veto test.
//"""
//        return _pythia8.UserHooks_scaleVetoPT(self)
//
//    def doVetoPT(self, arg0, arg1):
//        """
//Decide whether to veto current event or not, based on event record.
//Usage: doVetoPT( iPos, event), where iPos = 0: no emissions so far;
//iPos = 1/2/3 joint evolution, latest step was MPI/ISR/FSR;
//iPos = 4: FSR only afterwards; iPos = 5: FSR in resonance decay.
//"""
//        return _pythia8.UserHooks_doVetoPT(self, arg0, arg1)
//
//    def canVetoStep(self):
//        """
//Possibility to veto MPI + ISR + FSR evolution and kill event,
//making decision after fixed number of ISR or FSR steps.
//"""
//        return _pythia8.UserHooks_canVetoStep(self)
//
//    def numberVetoStep(self):
//        """
//Up to how many ISR + FSR steps of hardest interaction should be checked.
//"""
//        return _pythia8.UserHooks_numberVetoStep(self)
//
//    def doVetoStep(self, arg0, arg1, arg2, arg3):
//        """
//Decide whether to veto current event or not, based on event record.
//Usage: doVetoStep( iPos, nISR, nFSR, event), where iPos as above,
//nISR and nFSR number of emissions so far for hard interaction only.
//"""
//        return _pythia8.UserHooks_doVetoStep(self, arg0, arg1, arg2, arg3)
//
//    def canVetoMPIStep(self):
//        """
//Possibility to veto MPI + ISR + FSR evolution and kill event,
//making decision after fixed number of MPI steps.
//"""
//        return _pythia8.UserHooks_canVetoMPIStep(self)
//
//    def numberVetoMPIStep(self):
//        """
//Up to how many MPI steps should be checked.
//"""
//        return _pythia8.UserHooks_numberVetoMPIStep(self)
//
//    def doVetoMPIStep(self, arg0, arg1):
//        """
//Decide whether to veto current event or not, based on event record.
//Usage: doVetoMPIStep( nMPI, event), where nMPI is number of MPI's so far.
//"""
//        return _pythia8.UserHooks_doVetoMPIStep(self, arg0, arg1)
//
//    def canVetoPartonLevelEarly(self):
//        """
//Possibility to veto event after ISR + FSR + MPI in parton level,
//but before beam remnants and resonance decays.
//"""
//        return _pythia8.UserHooks_canVetoPartonLevelEarly(self)
//
//    def doVetoPartonLevelEarly(self, arg0):
//        """
//Decide whether to veto current partons or not, based on event record.
//Usage: doVetoPartonLevelEarly( event).
//"""
//        return _pythia8.UserHooks_doVetoPartonLevelEarly(self, arg0)
//
//    def retryPartonLevel(self):
//        """
//Retry same ProcessLevel with a new PartonLevel after a veto in
//doVetoPT, doVetoStep, doVetoMPIStep or doVetoPartonLevelEarly
//if you overload this method to return true.
//"""
//        return _pythia8.UserHooks_retryPartonLevel(self)
//
//    def canVetoPartonLevel(self):
//        """
//Possibility to veto event after parton-level selection.
//"""
//        return _pythia8.UserHooks_canVetoPartonLevel(self)
//
//    def doVetoPartonLevel(self, arg0):
//        """
//Decide whether to veto current partons or not, based on event record.
//Usage: doVetoPartonLevel( event).
//"""
//        return _pythia8.UserHooks_doVetoPartonLevel(self, arg0)
//
//    def canSetResonanceScale(self):
//        """
//Possibility to set initial scale in TimeShower for resonance decay.
//"""
//        return _pythia8.UserHooks_canSetResonanceScale(self)
//
//    def scaleResonance(self, arg0, arg1):
//        """
//Initial scale for TimeShower evolution.
//Usage: scaleResonance( iRes, event), where iRes is location
//of decaying resonance in the event record.
//"""
//        return _pythia8.UserHooks_scaleResonance(self, arg0, arg1)
//
//    def canVetoISREmission(self):
//        """
//Possibility to veto an emission in the ISR machinery.
//"""
//        return _pythia8.UserHooks_canVetoISREmission(self)
//
//    def doVetoISREmission(self, arg0, arg1, arg2):
//        """
//Decide whether to veto current emission or not, based on event record.
//Usage: doVetoISREmission( sizeOld, event, iSys) where sizeOld is size
//of event record before current emission-to-be-scrutinized was added,
//and iSys is the system of the radiation (according to PartonSystems).
//"""
//        return _pythia8.UserHooks_doVetoISREmission(self, arg0, arg1, arg2)
//
//    def canVetoFSREmission(self):
//        """
//Possibility to veto an emission in the FSR machinery.
//"""
//        return _pythia8.UserHooks_canVetoFSREmission(self)
//
//    def doVetoFSREmission(self, arg0, arg1, arg2, arg3=False):
//        """
//Decide whether to veto current emission or not, based on event record.
//Usage: doVetoFSREmission( sizeOld, event, iSys, inResonance) where
//sizeOld is size of event record before current emission-to-be-scrutinized
//was added, iSys is the system of the radiation (according to
//PartonSystems), and inResonance is true if the emission takes place in a
//resonance decay.
//"""
//        return _pythia8.UserHooks_doVetoFSREmission(self, arg0, arg1, arg2, arg3)
//
//    def canVetoMPIEmission(self):
//        """
//Possibility to veto an MPI.
//"""
//        return _pythia8.UserHooks_canVetoMPIEmission(self)
//
//    def doVetoMPIEmission(self, arg0, arg1):
//        """
//Decide whether to veto an MPI based on event record.
//Usage: doVetoMPIEmission( sizeOld, event) where sizeOld
//is size of event record before the current MPI.
//"""
//        return _pythia8.UserHooks_doVetoMPIEmission(self, arg0, arg1)
//
//    def canReconnectResonanceSystems(self):
//        """
//Possibility to reconnect colours from resonance decay systems.
//"""
//        return _pythia8.UserHooks_canReconnectResonanceSystems(self)
//
//    def doReconnectResonanceSystems(self, arg0, arg1):
//        """
//Do reconnect colours from resonance decay systems.
//Usage: doVetoFSREmission( oldSizeEvt, event)
//where oldSizeEvent is the event size before resonance decays.
//Should normally return true, while false means serious failure.
//Value of PartonLevel:earlyResDec determines where method is called.
//"""
//        return _pythia8.UserHooks_doReconnectResonanceSystems(self, arg0, arg1)
//
//    def canEnhanceEmission(self):
//        """
//Enhance emission rates (sec. 4 in EPJC (2013) 73).
//"""
//        return _pythia8.UserHooks_canEnhanceEmission(self)
//
//    def enhanceFactor(self, arg0):
//        """
//"""
//        return _pythia8.UserHooks_enhanceFactor(self, arg0)
//
//    def vetoProbability(self, arg0):
//        """
//"""
//        return _pythia8.UserHooks_vetoProbability(self, arg0)
//
//    def setEnhancedEventWeight(self, wt):
//        """
//"""
//        return _pythia8.UserHooks_setEnhancedEventWeight(self, wt)
//
//    def getEnhancedEventWeight(self):
//        """
//"""
//        return _pythia8.UserHooks_getEnhancedEventWeight(self)
//
//    def canEnhanceTrial(self):
//        """
//Bookkeeping of weights for enhanced actual or trial emissions
//(sec. 3 in EPJC (2013) 73).
//"""
//        return _pythia8.UserHooks_canEnhanceTrial(self)
//
//    def setEnhancedTrial(self, pTIn, wtIn):
//        """
//"""
//        return _pythia8.UserHooks_setEnhancedTrial(self, pTIn, wtIn)
//
//    def getEnhancedTrialPT(self):
//        """
//"""
//        return _pythia8.UserHooks_getEnhancedTrialPT(self)
//
//    def getEnhancedTrialWeight(self):
//        """
//"""
//        return _pythia8.UserHooks_getEnhancedTrialWeight(self)
//
//    def canChangeFragPar(self):
//        """
//Can change fragmentation parameters.
//"""
//        return _pythia8.UserHooks_canChangeFragPar(self)
//
//    def doChangeFragPar(self, arg0, arg1, arg2, arg3, arg4, arg5):
//        """
//Do change fragmentation parameters.
//Input: flavPtr, zPtr, pTPtr, idEnd, m2Had, iParton.
//"""
//        return _pythia8.UserHooks_doChangeFragPar(self, arg0, arg1, arg2, arg3, arg4, arg5)
//
//    def doVetoFragmentation(self, arg0):
//        """
//Do a veto on a hadron just before it is added to the final state.
//"""
//        return _pythia8.UserHooks_doVetoFragmentation(self, arg0)
//
//    def canSetImpactParameter(self):
//        """
//Can set the overall impact parameter for the MPI treatment.
//"""
//        return _pythia8.UserHooks_canSetImpactParameter(self)
//
//    def doSetImpactParameter(self):
//        """
//Set the overall impact parameter for the MPI treatment.
//"""
//        return _pythia8.UserHooks_doSetImpactParameter(self)
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        if self.__class__ == UserHooks:
//            _self = None
//        else:
//            _self = self
//        this = _pythia8.new_UserHooks(_self, )
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["infoPtr"] = _pythia8.UserHooks_infoPtr_set
//    __swig_getmethods__["infoPtr"] = _pythia8.UserHooks_infoPtr_get
//    if _newclass:
//        infoPtr = _swig_property(_pythia8.UserHooks_infoPtr_get, _pythia8.UserHooks_infoPtr_set)
//    __swig_setmethods__["settingsPtr"] = _pythia8.UserHooks_settingsPtr_set
//    __swig_getmethods__["settingsPtr"] = _pythia8.UserHooks_settingsPtr_get
//    if _newclass:
//        settingsPtr = _swig_property(_pythia8.UserHooks_settingsPtr_get, _pythia8.UserHooks_settingsPtr_set)
//    __swig_setmethods__["particleDataPtr"] = _pythia8.UserHooks_particleDataPtr_set
//    __swig_getmethods__["particleDataPtr"] = _pythia8.UserHooks_particleDataPtr_get
//    if _newclass:
//        particleDataPtr = _swig_property(_pythia8.UserHooks_particleDataPtr_get, _pythia8.UserHooks_particleDataPtr_set)
//    __swig_setmethods__["rndmPtr"] = _pythia8.UserHooks_rndmPtr_set
//    __swig_getmethods__["rndmPtr"] = _pythia8.UserHooks_rndmPtr_get
//    if _newclass:
//        rndmPtr = _swig_property(_pythia8.UserHooks_rndmPtr_get, _pythia8.UserHooks_rndmPtr_set)
//    __swig_setmethods__["beamAPtr"] = _pythia8.UserHooks_beamAPtr_set
//    __swig_getmethods__["beamAPtr"] = _pythia8.UserHooks_beamAPtr_get
//    if _newclass:
//        beamAPtr = _swig_property(_pythia8.UserHooks_beamAPtr_get, _pythia8.UserHooks_beamAPtr_set)
//    __swig_setmethods__["beamBPtr"] = _pythia8.UserHooks_beamBPtr_set
//    __swig_getmethods__["beamBPtr"] = _pythia8.UserHooks_beamBPtr_get
//    if _newclass:
//        beamBPtr = _swig_property(_pythia8.UserHooks_beamBPtr_get, _pythia8.UserHooks_beamBPtr_set)
//    __swig_setmethods__["beamPomAPtr"] = _pythia8.UserHooks_beamPomAPtr_set
//    __swig_getmethods__["beamPomAPtr"] = _pythia8.UserHooks_beamPomAPtr_get
//    if _newclass:
//        beamPomAPtr = _swig_property(_pythia8.UserHooks_beamPomAPtr_get, _pythia8.UserHooks_beamPomAPtr_set)
//    __swig_setmethods__["beamPomBPtr"] = _pythia8.UserHooks_beamPomBPtr_set
//    __swig_getmethods__["beamPomBPtr"] = _pythia8.UserHooks_beamPomBPtr_get
//    if _newclass:
//        beamPomBPtr = _swig_property(_pythia8.UserHooks_beamPomBPtr_get, _pythia8.UserHooks_beamPomBPtr_set)
//    __swig_setmethods__["coupSMPtr"] = _pythia8.UserHooks_coupSMPtr_set
//    __swig_getmethods__["coupSMPtr"] = _pythia8.UserHooks_coupSMPtr_get
//    if _newclass:
//        coupSMPtr = _swig_property(_pythia8.UserHooks_coupSMPtr_get, _pythia8.UserHooks_coupSMPtr_set)
//    __swig_setmethods__["partonSystemsPtr"] = _pythia8.UserHooks_partonSystemsPtr_set
//    __swig_getmethods__["partonSystemsPtr"] = _pythia8.UserHooks_partonSystemsPtr_get
//    if _newclass:
//        partonSystemsPtr = _swig_property(_pythia8.UserHooks_partonSystemsPtr_get, _pythia8.UserHooks_partonSystemsPtr_set)
//    __swig_setmethods__["sigmaTotPtr"] = _pythia8.UserHooks_sigmaTotPtr_set
//    __swig_getmethods__["sigmaTotPtr"] = _pythia8.UserHooks_sigmaTotPtr_get
//    if _newclass:
//        sigmaTotPtr = _swig_property(_pythia8.UserHooks_sigmaTotPtr_get, _pythia8.UserHooks_sigmaTotPtr_set)
//
//    def omitResonanceDecays(self, process, finalOnly=False):
//        """
//Pointer to various information on the generation.
//Pointer to the settings database.
//Pointer to the particle data table.
//Pointer to the random number generator.
//Pointers to the two incoming beams and to Pomeron beam-inside-beam.
//Pointers to Standard Model couplings.
//Pointer to information on subcollision parton locations.
//Pointer to the total/elastic/diffractive cross sections.
//omitResonanceDecays omits resonance decay chains from process record.
//"""
//        return _pythia8.UserHooks_omitResonanceDecays(self, process, finalOnly)
//
//    def subEvent(self, event, isHardest=True):
//        """
//subEvent extracts currently resolved partons in the hard process.
//"""
//        return _pythia8.UserHooks_subEvent(self, event, isHardest)
//    __swig_setmethods__["workEvent"] = _pythia8.UserHooks_workEvent_set
//    __swig_getmethods__["workEvent"] = _pythia8.UserHooks_workEvent_get
//    if _newclass:
//        workEvent = _swig_property(_pythia8.UserHooks_workEvent_get, _pythia8.UserHooks_workEvent_set)
//    __swig_setmethods__["selBias"] = _pythia8.UserHooks_selBias_set
//    __swig_getmethods__["selBias"] = _pythia8.UserHooks_selBias_get
//    if _newclass:
//        selBias = _swig_property(_pythia8.UserHooks_selBias_get, _pythia8.UserHooks_selBias_set)
//    __swig_setmethods__["enhancedEventWeight"] = _pythia8.UserHooks_enhancedEventWeight_set
//    __swig_getmethods__["enhancedEventWeight"] = _pythia8.UserHooks_enhancedEventWeight_get
//    if _newclass:
//        enhancedEventWeight = _swig_property(_pythia8.UserHooks_enhancedEventWeight_get, _pythia8.UserHooks_enhancedEventWeight_set)
//    __swig_setmethods__["pTEnhanced"] = _pythia8.UserHooks_pTEnhanced_set
//    __swig_getmethods__["pTEnhanced"] = _pythia8.UserHooks_pTEnhanced_get
//    if _newclass:
//        pTEnhanced = _swig_property(_pythia8.UserHooks_pTEnhanced_get, _pythia8.UserHooks_pTEnhanced_set)
//    __swig_setmethods__["wtEnhanced"] = _pythia8.UserHooks_wtEnhanced_set
//    __swig_getmethods__["wtEnhanced"] = _pythia8.UserHooks_wtEnhanced_get
//    if _newclass:
//        wtEnhanced = _swig_property(_pythia8.UserHooks_wtEnhanced_get, _pythia8.UserHooks_wtEnhanced_set)
//    def __disown__(self):
//        self.this.disown()
//        _pythia8.disown_UserHooks(self)
//        return weakref_proxy(self)
//UserHooks_swigregister = _pythia8.UserHooks_swigregister
//UserHooks_swigregister(UserHooks)
//
//class SuppressSmallPT(UserHooks):
//    """
//SuppressSmallPT is a derived class for user access to program execution.
//It is a simple example, illustrating how to suppress the cross section
//of 2 -> 2 processes by a factor pT^4 / (pT0^2 + pT^2)^2, with pT0 input,
//and also modify alpha_strong scale similarly.
//"""
//    __swig_setmethods__ = {}
//    for _s in [UserHooks]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SuppressSmallPT, name, value)
//    __swig_getmethods__ = {}
//    for _s in [UserHooks]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, SuppressSmallPT, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, pT0timesMPIIn=1., numberAlphaSIn=0, useSameAlphaSasMPIIn=True):
//        """
//Constructor.
//"""
//        this = _pythia8.new_SuppressSmallPT(pT0timesMPIIn, numberAlphaSIn, useSameAlphaSasMPIIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def canModifySigma(self):
//        """
//Possibility to modify cross section of process.
//"""
//        return _pythia8.SuppressSmallPT_canModifySigma(self)
//
//    def multiplySigmaBy(self, sigmaProcessPtr, phaseSpacePtr, arg4):
//        """
//Multiplicative factor modifying the cross section of a hard process.
//Usage: inEvent is true for event generation, false for initialization.
//"""
//        return _pythia8.SuppressSmallPT_multiplySigmaBy(self, sigmaProcessPtr, phaseSpacePtr, arg4)
//    __swig_destroy__ = _pythia8.delete_SuppressSmallPT
//    __del__ = lambda self: None
//SuppressSmallPT_swigregister = _pythia8.SuppressSmallPT_swigregister
//SuppressSmallPT_swigregister(SuppressSmallPT)
//
//class UserHooksVector(UserHooks):
//    __swig_setmethods__ = {}
//    for _s in [UserHooks]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, UserHooksVector, name, value)
//    __swig_getmethods__ = {}
//    for _s in [UserHooks]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, UserHooksVector, name)
//
//    def __init__(self, *args, **kwargs):
//        raise AttributeError("No constructor defined")
//    __repr__ = _swig_repr
//    __swig_destroy__ = _pythia8.delete_UserHooksVector
//    __del__ = lambda self: None
//
//    def initAfterBeams(self):
//        return _pythia8.UserHooksVector_initAfterBeams(self)
//
//    def canModifySigma(self):
//        return _pythia8.UserHooksVector_canModifySigma(self)
//
//    def multiplySigmaBy(self, sigmaProcessPtr, phaseSpacePtr, inEvent):
//        return _pythia8.UserHooksVector_multiplySigmaBy(self, sigmaProcessPtr, phaseSpacePtr, inEvent)
//
//    def canBiasSelection(self):
//        return _pythia8.UserHooksVector_canBiasSelection(self)
//
//    def biasSelectionBy(self, sigmaProcessPtr, phaseSpacePtr, inEvent):
//        return _pythia8.UserHooksVector_biasSelectionBy(self, sigmaProcessPtr, phaseSpacePtr, inEvent)
//
//    def biasedSelectionWeight(self):
//        return _pythia8.UserHooksVector_biasedSelectionWeight(self)
//
//    def canVetoProcessLevel(self):
//        return _pythia8.UserHooksVector_canVetoProcessLevel(self)
//
//    def doVetoProcessLevel(self, e):
//        return _pythia8.UserHooksVector_doVetoProcessLevel(self, e)
//
//    def canVetoResonanceDecays(self):
//        return _pythia8.UserHooksVector_canVetoResonanceDecays(self)
//
//    def doVetoResonanceDecays(self, e):
//        return _pythia8.UserHooksVector_doVetoResonanceDecays(self, e)
//
//    def canVetoPT(self):
//        return _pythia8.UserHooksVector_canVetoPT(self)
//
//    def scaleVetoPT(self):
//        return _pythia8.UserHooksVector_scaleVetoPT(self)
//
//    def doVetoPT(self, iPos, e):
//        return _pythia8.UserHooksVector_doVetoPT(self, iPos, e)
//
//    def canVetoStep(self):
//        return _pythia8.UserHooksVector_canVetoStep(self)
//
//    def numberVetoStep(self):
//        return _pythia8.UserHooksVector_numberVetoStep(self)
//
//    def doVetoStep(self, iPos, nISR, nFSR, e):
//        return _pythia8.UserHooksVector_doVetoStep(self, iPos, nISR, nFSR, e)
//
//    def canVetoMPIStep(self):
//        return _pythia8.UserHooksVector_canVetoMPIStep(self)
//
//    def numberVetoMPIStep(self):
//        return _pythia8.UserHooksVector_numberVetoMPIStep(self)
//
//    def doVetoMPIStep(self, nMPI, e):
//        return _pythia8.UserHooksVector_doVetoMPIStep(self, nMPI, e)
//
//    def canVetoPartonLevelEarly(self):
//        return _pythia8.UserHooksVector_canVetoPartonLevelEarly(self)
//
//    def doVetoPartonLevelEarly(self, e):
//        return _pythia8.UserHooksVector_doVetoPartonLevelEarly(self, e)
//
//    def retryPartonLevel(self):
//        return _pythia8.UserHooksVector_retryPartonLevel(self)
//
//    def canVetoPartonLevel(self):
//        return _pythia8.UserHooksVector_canVetoPartonLevel(self)
//
//    def doVetoPartonLevel(self, e):
//        return _pythia8.UserHooksVector_doVetoPartonLevel(self, e)
//
//    def canSetResonanceScale(self):
//        return _pythia8.UserHooksVector_canSetResonanceScale(self)
//
//    def scaleResonance(self, iRes, e):
//        return _pythia8.UserHooksVector_scaleResonance(self, iRes, e)
//
//    def canVetoISREmission(self):
//        return _pythia8.UserHooksVector_canVetoISREmission(self)
//
//    def doVetoISREmission(self, sizeOld, e, iSys):
//        return _pythia8.UserHooksVector_doVetoISREmission(self, sizeOld, e, iSys)
//
//    def canVetoFSREmission(self):
//        return _pythia8.UserHooksVector_canVetoFSREmission(self)
//
//    def doVetoFSREmission(self, sizeOld, e, iSys, inResonance=False):
//        return _pythia8.UserHooksVector_doVetoFSREmission(self, sizeOld, e, iSys, inResonance)
//
//    def canVetoMPIEmission(self):
//        return _pythia8.UserHooksVector_canVetoMPIEmission(self)
//
//    def doVetoMPIEmission(self, sizeOld, e):
//        return _pythia8.UserHooksVector_doVetoMPIEmission(self, sizeOld, e)
//
//    def canReconnectResonanceSystems(self):
//        return _pythia8.UserHooksVector_canReconnectResonanceSystems(self)
//
//    def doReconnectResonanceSystems(self, j, e):
//        return _pythia8.UserHooksVector_doReconnectResonanceSystems(self, j, e)
//
//    def canEnhanceEmission(self):
//        return _pythia8.UserHooksVector_canEnhanceEmission(self)
//
//    def enhanceFactor(self, s):
//        return _pythia8.UserHooksVector_enhanceFactor(self, s)
//
//    def vetoProbability(self, s):
//        return _pythia8.UserHooksVector_vetoProbability(self, s)
//
//    def canEnhanceTrial(self):
//        return _pythia8.UserHooksVector_canEnhanceTrial(self)
//
//    def canChangeFragPar(self):
//        return _pythia8.UserHooksVector_canChangeFragPar(self)
//
//    def canSetImpactParameter(self):
//        return _pythia8.UserHooksVector_canSetImpactParameter(self)
//
//    def doSetImpactParameter(self):
//        return _pythia8.UserHooksVector_doSetImpactParameter(self)
//    __swig_setmethods__["hooks"] = _pythia8.UserHooksVector_hooks_set
//    __swig_getmethods__["hooks"] = _pythia8.UserHooksVector_hooks_get
//    if _newclass:
//        hooks = _swig_property(_pythia8.UserHooksVector_hooks_get, _pythia8.UserHooksVector_hooks_set)
//UserHooksVector_swigregister = _pythia8.UserHooksVector_swigregister
//UserHooksVector_swigregister(UserHooksVector)
//
//class SigmaMultiparton(_object):
//    """
//SigmaMultiparton is a helper class to MultipartonInteractions.
//It packs pointers to the allowed processes for different
//flavour combinations and levels of ambition.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SigmaMultiparton, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, SigmaMultiparton, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_SigmaMultiparton()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_SigmaMultiparton
//    __del__ = lambda self: None
//
//    def init(self, inState, processLevel, infoPtr, settingsPtr, particleDataPtr, rndmPtrIn, beamAPtr, beamBPtr, couplingsPtr):
//        """
//Initialize list of processes.
//"""
//        return _pythia8.SigmaMultiparton_init(self, inState, processLevel, infoPtr, settingsPtr, particleDataPtr, rndmPtrIn, beamAPtr, beamBPtr, couplingsPtr)
//
//    def sigma(self, id1, id2, x1, x2, sHat, tHat, uHat, alpS, alpEM, restore=False, pickOtherIn=False):
//        """
//Calculate cross section summed over possibilities.
//"""
//        return _pythia8.SigmaMultiparton_sigma(self, id1, id2, x1, x2, sHat, tHat, uHat, alpS, alpEM, restore, pickOtherIn)
//
//    def pickedOther(self):
//        """
//Return whether the other, rare processes were selected.
//"""
//        return _pythia8.SigmaMultiparton_pickedOther(self)
//
//    def sigmaSel(self):
//        """
//Return one subprocess, picked according to relative cross sections.
//"""
//        return _pythia8.SigmaMultiparton_sigmaSel(self)
//
//    def swapTU(self):
//        """
//"""
//        return _pythia8.SigmaMultiparton_swapTU(self)
//
//    def nProc(self):
//        """
//Return code or name of a specified process, for statistics table.
//"""
//        return _pythia8.SigmaMultiparton_nProc(self)
//
//    def codeProc(self, iProc):
//        """
//"""
//        return _pythia8.SigmaMultiparton_codeProc(self, iProc)
//
//    def nameProc(self, iProc):
//        """
//"""
//        return _pythia8.SigmaMultiparton_nameProc(self, iProc)
//SigmaMultiparton_swigregister = _pythia8.SigmaMultiparton_swigregister
//SigmaMultiparton_swigregister(SigmaMultiparton)
//
//class MultipartonInteractions(_object):
//    """
//The MultipartonInteractions class contains the main methods for the
//generation of multiparton parton-parton interactions in hadronic collisions.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, MultipartonInteractions, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, MultipartonInteractions, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_MultipartonInteractions()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, doMPIinit, iDiffSysIn, infoPtrIn, settings, particleDataPtr, rndmPtrIn, beamAPtrIn, beamBPtrIn, couplingsPtrIn, partonSystemsPtrIn, sigmaTotPtrIn, userHooksPtrIn, partonVertexPtrIn, hasGammaIn=False):
//        """
//Initialize the generation process for given beams.
//"""
//        return _pythia8.MultipartonInteractions_init(self, doMPIinit, iDiffSysIn, infoPtrIn, settings, particleDataPtr, rndmPtrIn, beamAPtrIn, beamBPtrIn, couplingsPtrIn, partonSystemsPtrIn, sigmaTotPtrIn, userHooksPtrIn, partonVertexPtrIn, hasGammaIn)
//
//    def reset(self):
//        """
//Reset impact parameter choice and update the CM energy.
//"""
//        return _pythia8.MultipartonInteractions_reset(self)
//
//    def pTfirst(self):
//        """
//Select first = hardest pT in nondiffractive process.
//"""
//        return _pythia8.MultipartonInteractions_pTfirst(self)
//
//    def setupFirstSys(self, process):
//        """
//Set up kinematics for first = hardest pT in nondiffractive process.
//"""
//        return _pythia8.MultipartonInteractions_setupFirstSys(self, process)
//
//    def limitPTmax(self, event):
//        """
//Find whether to limit maximum scale of emissions.
//Provide sum pT / 2 as potential limit where relevant.
//"""
//        return _pythia8.MultipartonInteractions_limitPTmax(self, event)
//
//    def scaleLimitPT(self):
//        """
//"""
//        return _pythia8.MultipartonInteractions_scaleLimitPT(self)
//
//    def prepare(self, event, pTscale=1000., rehashB=False):
//        """
//Prepare system for evolution.
//"""
//        return _pythia8.MultipartonInteractions_prepare(self, event, pTscale, rehashB)
//
//    def pTnext(self, pTbegAll, pTendAll, event):
//        """
//Select next pT in downwards evolution.
//"""
//        return _pythia8.MultipartonInteractions_pTnext(self, pTbegAll, pTendAll, event)
//
//    def scatter(self, event):
//        """
//Set up kinematics of acceptable interaction.
//"""
//        return _pythia8.MultipartonInteractions_scatter(self, event)
//
//    def setEmpty(self):
//        """
//Set "empty" values to avoid query of undefined quantities.
//"""
//        return _pythia8.MultipartonInteractions_setEmpty(self)
//
//    def Q2Ren(self):
//        """
//Get some information on current interaction.
//"""
//        return _pythia8.MultipartonInteractions_Q2Ren(self)
//
//    def alphaSH(self):
//        """
//"""
//        return _pythia8.MultipartonInteractions_alphaSH(self)
//
//    def alphaEMH(self):
//        """
//"""
//        return _pythia8.MultipartonInteractions_alphaEMH(self)
//
//    def x1H(self):
//        """
//"""
//        return _pythia8.MultipartonInteractions_x1H(self)
//
//    def x2H(self):
//        """
//"""
//        return _pythia8.MultipartonInteractions_x2H(self)
//
//    def Q2Fac(self):
//        """
//"""
//        return _pythia8.MultipartonInteractions_Q2Fac(self)
//
//    def pdf1(self):
//        """
//"""
//        return _pythia8.MultipartonInteractions_pdf1(self)
//
//    def pdf2(self):
//        """
//"""
//        return _pythia8.MultipartonInteractions_pdf2(self)
//
//    def bMPI(self):
//        """
//"""
//        return _pythia8.MultipartonInteractions_bMPI(self)
//
//    def enhanceMPI(self):
//        """
//"""
//        return _pythia8.MultipartonInteractions_enhanceMPI(self)
//
//    def enhanceMPIavg(self):
//        """
//"""
//        return _pythia8.MultipartonInteractions_enhanceMPIavg(self)
//
//    def getVSC1(self):
//        """
//For x-dependent matter profile, return incoming valence/sea
//decision from trial interactions.
//"""
//        return _pythia8.MultipartonInteractions_getVSC1(self)
//
//    def getVSC2(self):
//        """
//"""
//        return _pythia8.MultipartonInteractions_getVSC2(self)
//
//    def getBeamOffset(self):
//        """
//Set the offset wrt. to normal beam particle positions for hard diffraction
//and for photon beam from lepton.
//"""
//        return _pythia8.MultipartonInteractions_getBeamOffset(self)
//
//    def setBeamOffset(self, offsetIn):
//        """
//"""
//        return _pythia8.MultipartonInteractions_setBeamOffset(self, offsetIn)
//
//    def accumulate(self):
//        """
//Update and print statistics on number of processes.
//Note: currently only valid for nondiffractive systems, not diffraction??
//"""
//        return _pythia8.MultipartonInteractions_accumulate(self)
//
//    def statistics(self, resetStat=False):
//        """
//"""
//        return _pythia8.MultipartonInteractions_statistics(self, resetStat)
//
//    def resetStatistics(self):
//        """
//"""
//        return _pythia8.MultipartonInteractions_resetStatistics(self)
//    __swig_destroy__ = _pythia8.delete_MultipartonInteractions
//    __del__ = lambda self: None
//MultipartonInteractions_swigregister = _pythia8.MultipartonInteractions_swigregister
//MultipartonInteractions_swigregister(MultipartonInteractions)
//
//class PhaseSpace(_object):
//    """
//Pointer to various information on the generation.
//Pointer to the settings database.
//Pointer to the random number generator.
//Data related to currently implemented models.
//Current values.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, PhaseSpace, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, PhaseSpace, name)
//    __repr__ = _swig_repr
//    __swig_destroy__ = _pythia8.delete_PhaseSpace
//    __del__ = lambda self: None
//
//    def init(self, isFirst, sigmaProcessPtrIn, infoPtrIn, settingsPtrIn, particleDataPtrIn, rndmPtrIn, beamAPtrIn, beamBPtrIn, couplingsPtrIn, sigmaTotPtrIn, userHooksPtrIn):
//        """
//Perform simple initialization and store pointers.
//"""
//        return _pythia8.PhaseSpace_init(self, isFirst, sigmaProcessPtrIn, infoPtrIn, settingsPtrIn, particleDataPtrIn, rndmPtrIn, beamAPtrIn, beamBPtrIn, couplingsPtrIn, sigmaTotPtrIn, userHooksPtrIn)
//
//    def newECM(self, eCMin):
//        """
//Update the CM energy of the event.
//"""
//        return _pythia8.PhaseSpace_newECM(self, eCMin)
//
//    def setLHAPtr(self, lhaUpPtrIn):
//        """
//Store or replace Les Houches pointer.
//"""
//        return _pythia8.PhaseSpace_setLHAPtr(self, lhaUpPtrIn)
//
//    def setupSampling(self):
//        """
//A pure virtual method, wherein an optimization procedure
//is used to determine how phase space should be sampled.
//"""
//        return _pythia8.PhaseSpace_setupSampling(self)
//
//    def trialKin(self, inEvent=True, repeatSame=False):
//        """
//A pure virtual method, wherein a trial event kinematics
//is to be selected in the derived class.
//"""
//        return _pythia8.PhaseSpace_trialKin(self, inEvent, repeatSame)
//
//    def finalKin(self):
//        """
//A pure virtual method, wherein the accepted event kinematics
//is to be constructed in the derived class.
//"""
//        return _pythia8.PhaseSpace_finalKin(self)
//
//    def decayKinematics(self, process):
//        """
//Allow for nonisotropic decays when ME's available.
//"""
//        return _pythia8.PhaseSpace_decayKinematics(self, process)
//
//    def sigmaNow(self):
//        """
//Give back current or maximum cross section, or set latter.
//"""
//        return _pythia8.PhaseSpace_sigmaNow(self)
//
//    def sigmaMax(self):
//        """
//"""
//        return _pythia8.PhaseSpace_sigmaMax(self)
//
//    def biasSelectionWeight(self):
//        """
//"""
//        return _pythia8.PhaseSpace_biasSelectionWeight(self)
//
//    def newSigmaMax(self):
//        """
//"""
//        return _pythia8.PhaseSpace_newSigmaMax(self)
//
//    def setSigmaMax(self, sigmaMaxIn):
//        """
//"""
//        return _pythia8.PhaseSpace_setSigmaMax(self, sigmaMaxIn)
//
//    def sigmaSumSigned(self):
//        """
//For Les Houches with negative event weight needs
//"""
//        return _pythia8.PhaseSpace_sigmaSumSigned(self)
//
//    def p(self, i):
//        """
//Give back constructed four-vectors and known masses.
//"""
//        return _pythia8.PhaseSpace_p(self, i)
//
//    def m(self, i):
//        """
//"""
//        return _pythia8.PhaseSpace_m(self, i)
//
//    def setP(self, i, pNew):
//        """
//Reset the four-momentum.
//"""
//        return _pythia8.PhaseSpace_setP(self, i, pNew)
//
//    def ecm(self):
//        """
//Give back other event properties.
//"""
//        return _pythia8.PhaseSpace_ecm(self)
//
//    def x1(self):
//        """
//"""
//        return _pythia8.PhaseSpace_x1(self)
//
//    def x2(self):
//        """
//"""
//        return _pythia8.PhaseSpace_x2(self)
//
//    def sHat(self):
//        """
//"""
//        return _pythia8.PhaseSpace_sHat(self)
//
//    def tHat(self):
//        """
//"""
//        return _pythia8.PhaseSpace_tHat(self)
//
//    def uHat(self):
//        """
//"""
//        return _pythia8.PhaseSpace_uHat(self)
//
//    def pTHat(self):
//        """
//"""
//        return _pythia8.PhaseSpace_pTHat(self)
//
//    def thetaHat(self):
//        """
//"""
//        return _pythia8.PhaseSpace_thetaHat(self)
//
//    def phiHat(self):
//        """
//"""
//        return _pythia8.PhaseSpace_phiHat(self)
//
//    def runBW3(self):
//        """
//"""
//        return _pythia8.PhaseSpace_runBW3(self)
//
//    def runBW4(self):
//        """
//"""
//        return _pythia8.PhaseSpace_runBW4(self)
//
//    def runBW5(self):
//        """
//"""
//        return _pythia8.PhaseSpace_runBW5(self)
//
//    def isResolved(self):
//        """
//Inform whether beam particles are resolved in partons or scatter directly.
//"""
//        return _pythia8.PhaseSpace_isResolved(self)
//
//    def rescaleSigma(self, arg0):
//        """
//Functions to rescale momenta and cross section for new sHat
//Currently implemented only for PhaseSpace2to2tauyz class.
//"""
//        return _pythia8.PhaseSpace_rescaleSigma(self, arg0)
//
//    def rescaleMomenta(self, arg0):
//        """
//"""
//        return _pythia8.PhaseSpace_rescaleMomenta(self, arg0)
//
//    def weightGammaPDFApprox(self):
//        """
//Calculate the weight for over-estimated cross section.
//"""
//        return _pythia8.PhaseSpace_weightGammaPDFApprox(self)
//
//    def setGammaKinPtr(self, arg0):
//        """
//Set the GammaKinematics pointer. Implemented for non-diffractive gm+gm.
//"""
//        return _pythia8.PhaseSpace_setGammaKinPtr(self, arg0)
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        if self.__class__ == PhaseSpace:
//            _self = None
//        else:
//            _self = self
//        this = _pythia8.new_PhaseSpace(_self, )
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["sigmaProcessPtr"] = _pythia8.PhaseSpace_sigmaProcessPtr_set
//    __swig_getmethods__["sigmaProcessPtr"] = _pythia8.PhaseSpace_sigmaProcessPtr_get
//    if _newclass:
//        sigmaProcessPtr = _swig_property(_pythia8.PhaseSpace_sigmaProcessPtr_get, _pythia8.PhaseSpace_sigmaProcessPtr_set)
//    __swig_setmethods__["infoPtr"] = _pythia8.PhaseSpace_infoPtr_set
//    __swig_getmethods__["infoPtr"] = _pythia8.PhaseSpace_infoPtr_get
//    if _newclass:
//        infoPtr = _swig_property(_pythia8.PhaseSpace_infoPtr_get, _pythia8.PhaseSpace_infoPtr_set)
//    __swig_setmethods__["settingsPtr"] = _pythia8.PhaseSpace_settingsPtr_set
//    __swig_getmethods__["settingsPtr"] = _pythia8.PhaseSpace_settingsPtr_get
//    if _newclass:
//        settingsPtr = _swig_property(_pythia8.PhaseSpace_settingsPtr_get, _pythia8.PhaseSpace_settingsPtr_set)
//    __swig_setmethods__["particleDataPtr"] = _pythia8.PhaseSpace_particleDataPtr_set
//    __swig_getmethods__["particleDataPtr"] = _pythia8.PhaseSpace_particleDataPtr_get
//    if _newclass:
//        particleDataPtr = _swig_property(_pythia8.PhaseSpace_particleDataPtr_get, _pythia8.PhaseSpace_particleDataPtr_set)
//    __swig_setmethods__["rndmPtr"] = _pythia8.PhaseSpace_rndmPtr_set
//    __swig_getmethods__["rndmPtr"] = _pythia8.PhaseSpace_rndmPtr_get
//    if _newclass:
//        rndmPtr = _swig_property(_pythia8.PhaseSpace_rndmPtr_get, _pythia8.PhaseSpace_rndmPtr_set)
//    __swig_setmethods__["beamAPtr"] = _pythia8.PhaseSpace_beamAPtr_set
//    __swig_getmethods__["beamAPtr"] = _pythia8.PhaseSpace_beamAPtr_get
//    if _newclass:
//        beamAPtr = _swig_property(_pythia8.PhaseSpace_beamAPtr_get, _pythia8.PhaseSpace_beamAPtr_set)
//    __swig_setmethods__["beamBPtr"] = _pythia8.PhaseSpace_beamBPtr_set
//    __swig_getmethods__["beamBPtr"] = _pythia8.PhaseSpace_beamBPtr_get
//    if _newclass:
//        beamBPtr = _swig_property(_pythia8.PhaseSpace_beamBPtr_get, _pythia8.PhaseSpace_beamBPtr_set)
//    __swig_setmethods__["couplingsPtr"] = _pythia8.PhaseSpace_couplingsPtr_set
//    __swig_getmethods__["couplingsPtr"] = _pythia8.PhaseSpace_couplingsPtr_get
//    if _newclass:
//        couplingsPtr = _swig_property(_pythia8.PhaseSpace_couplingsPtr_get, _pythia8.PhaseSpace_couplingsPtr_set)
//    __swig_setmethods__["sigmaTotPtr"] = _pythia8.PhaseSpace_sigmaTotPtr_set
//    __swig_getmethods__["sigmaTotPtr"] = _pythia8.PhaseSpace_sigmaTotPtr_get
//    if _newclass:
//        sigmaTotPtr = _swig_property(_pythia8.PhaseSpace_sigmaTotPtr_get, _pythia8.PhaseSpace_sigmaTotPtr_set)
//    __swig_setmethods__["userHooksPtr"] = _pythia8.PhaseSpace_userHooksPtr_set
//    __swig_getmethods__["userHooksPtr"] = _pythia8.PhaseSpace_userHooksPtr_get
//    if _newclass:
//        userHooksPtr = _swig_property(_pythia8.PhaseSpace_userHooksPtr_get, _pythia8.PhaseSpace_userHooksPtr_set)
//    __swig_setmethods__["lhaUpPtr"] = _pythia8.PhaseSpace_lhaUpPtr_set
//    __swig_getmethods__["lhaUpPtr"] = _pythia8.PhaseSpace_lhaUpPtr_get
//    if _newclass:
//        lhaUpPtr = _swig_property(_pythia8.PhaseSpace_lhaUpPtr_get, _pythia8.PhaseSpace_lhaUpPtr_set)
//    __swig_setmethods__["useBreitWigners"] = _pythia8.PhaseSpace_useBreitWigners_set
//    __swig_getmethods__["useBreitWigners"] = _pythia8.PhaseSpace_useBreitWigners_get
//    if _newclass:
//        useBreitWigners = _swig_property(_pythia8.PhaseSpace_useBreitWigners_get, _pythia8.PhaseSpace_useBreitWigners_set)
//    __swig_setmethods__["doEnergySpread"] = _pythia8.PhaseSpace_doEnergySpread_set
//    __swig_getmethods__["doEnergySpread"] = _pythia8.PhaseSpace_doEnergySpread_get
//    if _newclass:
//        doEnergySpread = _swig_property(_pythia8.PhaseSpace_doEnergySpread_get, _pythia8.PhaseSpace_doEnergySpread_set)
//    __swig_setmethods__["showSearch"] = _pythia8.PhaseSpace_showSearch_set
//    __swig_getmethods__["showSearch"] = _pythia8.PhaseSpace_showSearch_get
//    if _newclass:
//        showSearch = _swig_property(_pythia8.PhaseSpace_showSearch_get, _pythia8.PhaseSpace_showSearch_set)
//    __swig_setmethods__["showViolation"] = _pythia8.PhaseSpace_showViolation_set
//    __swig_getmethods__["showViolation"] = _pythia8.PhaseSpace_showViolation_get
//    if _newclass:
//        showViolation = _swig_property(_pythia8.PhaseSpace_showViolation_get, _pythia8.PhaseSpace_showViolation_set)
//    __swig_setmethods__["increaseMaximum"] = _pythia8.PhaseSpace_increaseMaximum_set
//    __swig_getmethods__["increaseMaximum"] = _pythia8.PhaseSpace_increaseMaximum_get
//    if _newclass:
//        increaseMaximum = _swig_property(_pythia8.PhaseSpace_increaseMaximum_get, _pythia8.PhaseSpace_increaseMaximum_set)
//    __swig_setmethods__["hasQ2Min"] = _pythia8.PhaseSpace_hasQ2Min_set
//    __swig_getmethods__["hasQ2Min"] = _pythia8.PhaseSpace_hasQ2Min_get
//    if _newclass:
//        hasQ2Min = _swig_property(_pythia8.PhaseSpace_hasQ2Min_get, _pythia8.PhaseSpace_hasQ2Min_set)
//    __swig_setmethods__["gmZmodeGlobal"] = _pythia8.PhaseSpace_gmZmodeGlobal_set
//    __swig_getmethods__["gmZmodeGlobal"] = _pythia8.PhaseSpace_gmZmodeGlobal_get
//    if _newclass:
//        gmZmodeGlobal = _swig_property(_pythia8.PhaseSpace_gmZmodeGlobal_get, _pythia8.PhaseSpace_gmZmodeGlobal_set)
//    __swig_setmethods__["mHatGlobalMin"] = _pythia8.PhaseSpace_mHatGlobalMin_set
//    __swig_getmethods__["mHatGlobalMin"] = _pythia8.PhaseSpace_mHatGlobalMin_get
//    if _newclass:
//        mHatGlobalMin = _swig_property(_pythia8.PhaseSpace_mHatGlobalMin_get, _pythia8.PhaseSpace_mHatGlobalMin_set)
//    __swig_setmethods__["mHatGlobalMax"] = _pythia8.PhaseSpace_mHatGlobalMax_set
//    __swig_getmethods__["mHatGlobalMax"] = _pythia8.PhaseSpace_mHatGlobalMax_get
//    if _newclass:
//        mHatGlobalMax = _swig_property(_pythia8.PhaseSpace_mHatGlobalMax_get, _pythia8.PhaseSpace_mHatGlobalMax_set)
//    __swig_setmethods__["pTHatGlobalMin"] = _pythia8.PhaseSpace_pTHatGlobalMin_set
//    __swig_getmethods__["pTHatGlobalMin"] = _pythia8.PhaseSpace_pTHatGlobalMin_get
//    if _newclass:
//        pTHatGlobalMin = _swig_property(_pythia8.PhaseSpace_pTHatGlobalMin_get, _pythia8.PhaseSpace_pTHatGlobalMin_set)
//    __swig_setmethods__["pTHatGlobalMax"] = _pythia8.PhaseSpace_pTHatGlobalMax_set
//    __swig_getmethods__["pTHatGlobalMax"] = _pythia8.PhaseSpace_pTHatGlobalMax_get
//    if _newclass:
//        pTHatGlobalMax = _swig_property(_pythia8.PhaseSpace_pTHatGlobalMax_get, _pythia8.PhaseSpace_pTHatGlobalMax_set)
//    __swig_setmethods__["Q2GlobalMin"] = _pythia8.PhaseSpace_Q2GlobalMin_set
//    __swig_getmethods__["Q2GlobalMin"] = _pythia8.PhaseSpace_Q2GlobalMin_get
//    if _newclass:
//        Q2GlobalMin = _swig_property(_pythia8.PhaseSpace_Q2GlobalMin_get, _pythia8.PhaseSpace_Q2GlobalMin_set)
//    __swig_setmethods__["pTHatMinDiverge"] = _pythia8.PhaseSpace_pTHatMinDiverge_set
//    __swig_getmethods__["pTHatMinDiverge"] = _pythia8.PhaseSpace_pTHatMinDiverge_get
//    if _newclass:
//        pTHatMinDiverge = _swig_property(_pythia8.PhaseSpace_pTHatMinDiverge_get, _pythia8.PhaseSpace_pTHatMinDiverge_set)
//    __swig_setmethods__["minWidthBreitWigners"] = _pythia8.PhaseSpace_minWidthBreitWigners_set
//    __swig_getmethods__["minWidthBreitWigners"] = _pythia8.PhaseSpace_minWidthBreitWigners_get
//    if _newclass:
//        minWidthBreitWigners = _swig_property(_pythia8.PhaseSpace_minWidthBreitWigners_get, _pythia8.PhaseSpace_minWidthBreitWigners_set)
//    __swig_setmethods__["idA"] = _pythia8.PhaseSpace_idA_set
//    __swig_getmethods__["idA"] = _pythia8.PhaseSpace_idA_get
//    if _newclass:
//        idA = _swig_property(_pythia8.PhaseSpace_idA_get, _pythia8.PhaseSpace_idA_set)
//    __swig_setmethods__["idB"] = _pythia8.PhaseSpace_idB_set
//    __swig_getmethods__["idB"] = _pythia8.PhaseSpace_idB_get
//    if _newclass:
//        idB = _swig_property(_pythia8.PhaseSpace_idB_get, _pythia8.PhaseSpace_idB_set)
//    __swig_setmethods__["mA"] = _pythia8.PhaseSpace_mA_set
//    __swig_getmethods__["mA"] = _pythia8.PhaseSpace_mA_get
//    if _newclass:
//        mA = _swig_property(_pythia8.PhaseSpace_mA_get, _pythia8.PhaseSpace_mA_set)
//    __swig_setmethods__["mB"] = _pythia8.PhaseSpace_mB_set
//    __swig_getmethods__["mB"] = _pythia8.PhaseSpace_mB_get
//    if _newclass:
//        mB = _swig_property(_pythia8.PhaseSpace_mB_get, _pythia8.PhaseSpace_mB_set)
//    __swig_setmethods__["eCM"] = _pythia8.PhaseSpace_eCM_set
//    __swig_getmethods__["eCM"] = _pythia8.PhaseSpace_eCM_get
//    if _newclass:
//        eCM = _swig_property(_pythia8.PhaseSpace_eCM_get, _pythia8.PhaseSpace_eCM_set)
//    __swig_setmethods__["s"] = _pythia8.PhaseSpace_s_set
//    __swig_getmethods__["s"] = _pythia8.PhaseSpace_s_get
//    if _newclass:
//        s = _swig_property(_pythia8.PhaseSpace_s_get, _pythia8.PhaseSpace_s_set)
//    __swig_setmethods__["hasLeptonBeamA"] = _pythia8.PhaseSpace_hasLeptonBeamA_set
//    __swig_getmethods__["hasLeptonBeamA"] = _pythia8.PhaseSpace_hasLeptonBeamA_get
//    if _newclass:
//        hasLeptonBeamA = _swig_property(_pythia8.PhaseSpace_hasLeptonBeamA_get, _pythia8.PhaseSpace_hasLeptonBeamA_set)
//    __swig_setmethods__["hasLeptonBeamB"] = _pythia8.PhaseSpace_hasLeptonBeamB_set
//    __swig_getmethods__["hasLeptonBeamB"] = _pythia8.PhaseSpace_hasLeptonBeamB_get
//    if _newclass:
//        hasLeptonBeamB = _swig_property(_pythia8.PhaseSpace_hasLeptonBeamB_get, _pythia8.PhaseSpace_hasLeptonBeamB_set)
//    __swig_setmethods__["hasOneLeptonBeam"] = _pythia8.PhaseSpace_hasOneLeptonBeam_set
//    __swig_getmethods__["hasOneLeptonBeam"] = _pythia8.PhaseSpace_hasOneLeptonBeam_get
//    if _newclass:
//        hasOneLeptonBeam = _swig_property(_pythia8.PhaseSpace_hasOneLeptonBeam_get, _pythia8.PhaseSpace_hasOneLeptonBeam_set)
//    __swig_setmethods__["hasTwoLeptonBeams"] = _pythia8.PhaseSpace_hasTwoLeptonBeams_set
//    __swig_getmethods__["hasTwoLeptonBeams"] = _pythia8.PhaseSpace_hasTwoLeptonBeams_get
//    if _newclass:
//        hasTwoLeptonBeams = _swig_property(_pythia8.PhaseSpace_hasTwoLeptonBeams_get, _pythia8.PhaseSpace_hasTwoLeptonBeams_set)
//    __swig_setmethods__["hasPointGammaA"] = _pythia8.PhaseSpace_hasPointGammaA_set
//    __swig_getmethods__["hasPointGammaA"] = _pythia8.PhaseSpace_hasPointGammaA_get
//    if _newclass:
//        hasPointGammaA = _swig_property(_pythia8.PhaseSpace_hasPointGammaA_get, _pythia8.PhaseSpace_hasPointGammaA_set)
//    __swig_setmethods__["hasPointGammaB"] = _pythia8.PhaseSpace_hasPointGammaB_set
//    __swig_getmethods__["hasPointGammaB"] = _pythia8.PhaseSpace_hasPointGammaB_get
//    if _newclass:
//        hasPointGammaB = _swig_property(_pythia8.PhaseSpace_hasPointGammaB_get, _pythia8.PhaseSpace_hasPointGammaB_set)
//    __swig_setmethods__["hasOnePointParticle"] = _pythia8.PhaseSpace_hasOnePointParticle_set
//    __swig_getmethods__["hasOnePointParticle"] = _pythia8.PhaseSpace_hasOnePointParticle_get
//    if _newclass:
//        hasOnePointParticle = _swig_property(_pythia8.PhaseSpace_hasOnePointParticle_get, _pythia8.PhaseSpace_hasOnePointParticle_set)
//    __swig_setmethods__["hasTwoPointParticles"] = _pythia8.PhaseSpace_hasTwoPointParticles_set
//    __swig_getmethods__["hasTwoPointParticles"] = _pythia8.PhaseSpace_hasTwoPointParticles_get
//    if _newclass:
//        hasTwoPointParticles = _swig_property(_pythia8.PhaseSpace_hasTwoPointParticles_get, _pythia8.PhaseSpace_hasTwoPointParticles_set)
//    __swig_setmethods__["newSigmaMx"] = _pythia8.PhaseSpace_newSigmaMx_set
//    __swig_getmethods__["newSigmaMx"] = _pythia8.PhaseSpace_newSigmaMx_get
//    if _newclass:
//        newSigmaMx = _swig_property(_pythia8.PhaseSpace_newSigmaMx_get, _pythia8.PhaseSpace_newSigmaMx_set)
//    __swig_setmethods__["canModifySigma"] = _pythia8.PhaseSpace_canModifySigma_set
//    __swig_getmethods__["canModifySigma"] = _pythia8.PhaseSpace_canModifySigma_get
//    if _newclass:
//        canModifySigma = _swig_property(_pythia8.PhaseSpace_canModifySigma_get, _pythia8.PhaseSpace_canModifySigma_set)
//    __swig_setmethods__["canBiasSelection"] = _pythia8.PhaseSpace_canBiasSelection_set
//    __swig_getmethods__["canBiasSelection"] = _pythia8.PhaseSpace_canBiasSelection_get
//    if _newclass:
//        canBiasSelection = _swig_property(_pythia8.PhaseSpace_canBiasSelection_get, _pythia8.PhaseSpace_canBiasSelection_set)
//    __swig_setmethods__["canBias2Sel"] = _pythia8.PhaseSpace_canBias2Sel_set
//    __swig_getmethods__["canBias2Sel"] = _pythia8.PhaseSpace_canBias2Sel_get
//    if _newclass:
//        canBias2Sel = _swig_property(_pythia8.PhaseSpace_canBias2Sel_get, _pythia8.PhaseSpace_canBias2Sel_set)
//    __swig_setmethods__["gmZmode"] = _pythia8.PhaseSpace_gmZmode_set
//    __swig_getmethods__["gmZmode"] = _pythia8.PhaseSpace_gmZmode_get
//    if _newclass:
//        gmZmode = _swig_property(_pythia8.PhaseSpace_gmZmode_get, _pythia8.PhaseSpace_gmZmode_set)
//    __swig_setmethods__["bias2SelPow"] = _pythia8.PhaseSpace_bias2SelPow_set
//    __swig_getmethods__["bias2SelPow"] = _pythia8.PhaseSpace_bias2SelPow_get
//    if _newclass:
//        bias2SelPow = _swig_property(_pythia8.PhaseSpace_bias2SelPow_get, _pythia8.PhaseSpace_bias2SelPow_set)
//    __swig_setmethods__["bias2SelRef"] = _pythia8.PhaseSpace_bias2SelRef_set
//    __swig_getmethods__["bias2SelRef"] = _pythia8.PhaseSpace_bias2SelRef_get
//    if _newclass:
//        bias2SelRef = _swig_property(_pythia8.PhaseSpace_bias2SelRef_get, _pythia8.PhaseSpace_bias2SelRef_set)
//    __swig_setmethods__["wtBW"] = _pythia8.PhaseSpace_wtBW_set
//    __swig_getmethods__["wtBW"] = _pythia8.PhaseSpace_wtBW_get
//    if _newclass:
//        wtBW = _swig_property(_pythia8.PhaseSpace_wtBW_get, _pythia8.PhaseSpace_wtBW_set)
//    __swig_setmethods__["sigmaNw"] = _pythia8.PhaseSpace_sigmaNw_set
//    __swig_getmethods__["sigmaNw"] = _pythia8.PhaseSpace_sigmaNw_get
//    if _newclass:
//        sigmaNw = _swig_property(_pythia8.PhaseSpace_sigmaNw_get, _pythia8.PhaseSpace_sigmaNw_set)
//    __swig_setmethods__["sigmaMx"] = _pythia8.PhaseSpace_sigmaMx_set
//    __swig_getmethods__["sigmaMx"] = _pythia8.PhaseSpace_sigmaMx_get
//    if _newclass:
//        sigmaMx = _swig_property(_pythia8.PhaseSpace_sigmaMx_get, _pythia8.PhaseSpace_sigmaMx_set)
//    __swig_setmethods__["sigmaPos"] = _pythia8.PhaseSpace_sigmaPos_set
//    __swig_getmethods__["sigmaPos"] = _pythia8.PhaseSpace_sigmaPos_get
//    if _newclass:
//        sigmaPos = _swig_property(_pythia8.PhaseSpace_sigmaPos_get, _pythia8.PhaseSpace_sigmaPos_set)
//    __swig_setmethods__["sigmaNeg"] = _pythia8.PhaseSpace_sigmaNeg_set
//    __swig_getmethods__["sigmaNeg"] = _pythia8.PhaseSpace_sigmaNeg_get
//    if _newclass:
//        sigmaNeg = _swig_property(_pythia8.PhaseSpace_sigmaNeg_get, _pythia8.PhaseSpace_sigmaNeg_set)
//    __swig_setmethods__["biasWt"] = _pythia8.PhaseSpace_biasWt_set
//    __swig_getmethods__["biasWt"] = _pythia8.PhaseSpace_biasWt_get
//    if _newclass:
//        biasWt = _swig_property(_pythia8.PhaseSpace_biasWt_get, _pythia8.PhaseSpace_biasWt_set)
//    __swig_setmethods__["mHatMin"] = _pythia8.PhaseSpace_mHatMin_set
//    __swig_getmethods__["mHatMin"] = _pythia8.PhaseSpace_mHatMin_get
//    if _newclass:
//        mHatMin = _swig_property(_pythia8.PhaseSpace_mHatMin_get, _pythia8.PhaseSpace_mHatMin_set)
//    __swig_setmethods__["mHatMax"] = _pythia8.PhaseSpace_mHatMax_set
//    __swig_getmethods__["mHatMax"] = _pythia8.PhaseSpace_mHatMax_get
//    if _newclass:
//        mHatMax = _swig_property(_pythia8.PhaseSpace_mHatMax_get, _pythia8.PhaseSpace_mHatMax_set)
//    __swig_setmethods__["sHatMin"] = _pythia8.PhaseSpace_sHatMin_set
//    __swig_getmethods__["sHatMin"] = _pythia8.PhaseSpace_sHatMin_get
//    if _newclass:
//        sHatMin = _swig_property(_pythia8.PhaseSpace_sHatMin_get, _pythia8.PhaseSpace_sHatMin_set)
//    __swig_setmethods__["sHatMax"] = _pythia8.PhaseSpace_sHatMax_set
//    __swig_getmethods__["sHatMax"] = _pythia8.PhaseSpace_sHatMax_get
//    if _newclass:
//        sHatMax = _swig_property(_pythia8.PhaseSpace_sHatMax_get, _pythia8.PhaseSpace_sHatMax_set)
//    __swig_setmethods__["pTHatMin"] = _pythia8.PhaseSpace_pTHatMin_set
//    __swig_getmethods__["pTHatMin"] = _pythia8.PhaseSpace_pTHatMin_get
//    if _newclass:
//        pTHatMin = _swig_property(_pythia8.PhaseSpace_pTHatMin_get, _pythia8.PhaseSpace_pTHatMin_set)
//    __swig_setmethods__["pTHatMax"] = _pythia8.PhaseSpace_pTHatMax_set
//    __swig_getmethods__["pTHatMax"] = _pythia8.PhaseSpace_pTHatMax_get
//    if _newclass:
//        pTHatMax = _swig_property(_pythia8.PhaseSpace_pTHatMax_get, _pythia8.PhaseSpace_pTHatMax_set)
//    __swig_setmethods__["pT2HatMin"] = _pythia8.PhaseSpace_pT2HatMin_set
//    __swig_getmethods__["pT2HatMin"] = _pythia8.PhaseSpace_pT2HatMin_get
//    if _newclass:
//        pT2HatMin = _swig_property(_pythia8.PhaseSpace_pT2HatMin_get, _pythia8.PhaseSpace_pT2HatMin_set)
//    __swig_setmethods__["pT2HatMax"] = _pythia8.PhaseSpace_pT2HatMax_set
//    __swig_getmethods__["pT2HatMax"] = _pythia8.PhaseSpace_pT2HatMax_get
//    if _newclass:
//        pT2HatMax = _swig_property(_pythia8.PhaseSpace_pT2HatMax_get, _pythia8.PhaseSpace_pT2HatMax_set)
//    __swig_setmethods__["x1H"] = _pythia8.PhaseSpace_x1H_set
//    __swig_getmethods__["x1H"] = _pythia8.PhaseSpace_x1H_get
//    if _newclass:
//        x1H = _swig_property(_pythia8.PhaseSpace_x1H_get, _pythia8.PhaseSpace_x1H_set)
//    __swig_setmethods__["x2H"] = _pythia8.PhaseSpace_x2H_set
//    __swig_getmethods__["x2H"] = _pythia8.PhaseSpace_x2H_get
//    if _newclass:
//        x2H = _swig_property(_pythia8.PhaseSpace_x2H_get, _pythia8.PhaseSpace_x2H_set)
//    __swig_setmethods__["m3"] = _pythia8.PhaseSpace_m3_set
//    __swig_getmethods__["m3"] = _pythia8.PhaseSpace_m3_get
//    if _newclass:
//        m3 = _swig_property(_pythia8.PhaseSpace_m3_get, _pythia8.PhaseSpace_m3_set)
//    __swig_setmethods__["m4"] = _pythia8.PhaseSpace_m4_set
//    __swig_getmethods__["m4"] = _pythia8.PhaseSpace_m4_get
//    if _newclass:
//        m4 = _swig_property(_pythia8.PhaseSpace_m4_get, _pythia8.PhaseSpace_m4_set)
//    __swig_setmethods__["m5"] = _pythia8.PhaseSpace_m5_set
//    __swig_getmethods__["m5"] = _pythia8.PhaseSpace_m5_get
//    if _newclass:
//        m5 = _swig_property(_pythia8.PhaseSpace_m5_get, _pythia8.PhaseSpace_m5_set)
//    __swig_setmethods__["s3"] = _pythia8.PhaseSpace_s3_set
//    __swig_getmethods__["s3"] = _pythia8.PhaseSpace_s3_get
//    if _newclass:
//        s3 = _swig_property(_pythia8.PhaseSpace_s3_get, _pythia8.PhaseSpace_s3_set)
//    __swig_setmethods__["s4"] = _pythia8.PhaseSpace_s4_set
//    __swig_getmethods__["s4"] = _pythia8.PhaseSpace_s4_get
//    if _newclass:
//        s4 = _swig_property(_pythia8.PhaseSpace_s4_get, _pythia8.PhaseSpace_s4_set)
//    __swig_setmethods__["s5"] = _pythia8.PhaseSpace_s5_set
//    __swig_getmethods__["s5"] = _pythia8.PhaseSpace_s5_get
//    if _newclass:
//        s5 = _swig_property(_pythia8.PhaseSpace_s5_get, _pythia8.PhaseSpace_s5_set)
//    __swig_setmethods__["mHat"] = _pythia8.PhaseSpace_mHat_set
//    __swig_getmethods__["mHat"] = _pythia8.PhaseSpace_mHat_get
//    if _newclass:
//        mHat = _swig_property(_pythia8.PhaseSpace_mHat_get, _pythia8.PhaseSpace_mHat_set)
//    __swig_setmethods__["sH"] = _pythia8.PhaseSpace_sH_set
//    __swig_getmethods__["sH"] = _pythia8.PhaseSpace_sH_get
//    if _newclass:
//        sH = _swig_property(_pythia8.PhaseSpace_sH_get, _pythia8.PhaseSpace_sH_set)
//    __swig_setmethods__["tH"] = _pythia8.PhaseSpace_tH_set
//    __swig_getmethods__["tH"] = _pythia8.PhaseSpace_tH_get
//    if _newclass:
//        tH = _swig_property(_pythia8.PhaseSpace_tH_get, _pythia8.PhaseSpace_tH_set)
//    __swig_setmethods__["uH"] = _pythia8.PhaseSpace_uH_set
//    __swig_getmethods__["uH"] = _pythia8.PhaseSpace_uH_get
//    if _newclass:
//        uH = _swig_property(_pythia8.PhaseSpace_uH_get, _pythia8.PhaseSpace_uH_set)
//    __swig_setmethods__["pAbs"] = _pythia8.PhaseSpace_pAbs_set
//    __swig_getmethods__["pAbs"] = _pythia8.PhaseSpace_pAbs_get
//    if _newclass:
//        pAbs = _swig_property(_pythia8.PhaseSpace_pAbs_get, _pythia8.PhaseSpace_pAbs_set)
//    __swig_setmethods__["p2Abs"] = _pythia8.PhaseSpace_p2Abs_set
//    __swig_getmethods__["p2Abs"] = _pythia8.PhaseSpace_p2Abs_get
//    if _newclass:
//        p2Abs = _swig_property(_pythia8.PhaseSpace_p2Abs_get, _pythia8.PhaseSpace_p2Abs_set)
//    __swig_setmethods__["pTH"] = _pythia8.PhaseSpace_pTH_set
//    __swig_getmethods__["pTH"] = _pythia8.PhaseSpace_pTH_get
//    if _newclass:
//        pTH = _swig_property(_pythia8.PhaseSpace_pTH_get, _pythia8.PhaseSpace_pTH_set)
//    __swig_setmethods__["theta"] = _pythia8.PhaseSpace_theta_set
//    __swig_getmethods__["theta"] = _pythia8.PhaseSpace_theta_get
//    if _newclass:
//        theta = _swig_property(_pythia8.PhaseSpace_theta_get, _pythia8.PhaseSpace_theta_set)
//    __swig_setmethods__["phi"] = _pythia8.PhaseSpace_phi_set
//    __swig_getmethods__["phi"] = _pythia8.PhaseSpace_phi_get
//    if _newclass:
//        phi = _swig_property(_pythia8.PhaseSpace_phi_get, _pythia8.PhaseSpace_phi_set)
//    __swig_setmethods__["betaZ"] = _pythia8.PhaseSpace_betaZ_set
//    __swig_getmethods__["betaZ"] = _pythia8.PhaseSpace_betaZ_get
//    if _newclass:
//        betaZ = _swig_property(_pythia8.PhaseSpace_betaZ_get, _pythia8.PhaseSpace_betaZ_set)
//    __swig_setmethods__["pH"] = _pythia8.PhaseSpace_pH_set
//    __swig_getmethods__["pH"] = _pythia8.PhaseSpace_pH_get
//    if _newclass:
//        pH = _swig_property(_pythia8.PhaseSpace_pH_get, _pythia8.PhaseSpace_pH_set)
//    __swig_setmethods__["mH"] = _pythia8.PhaseSpace_mH_set
//    __swig_getmethods__["mH"] = _pythia8.PhaseSpace_mH_get
//    if _newclass:
//        mH = _swig_property(_pythia8.PhaseSpace_mH_get, _pythia8.PhaseSpace_mH_set)
//
//    def decayKinematicsStep(self, process, iRes):
//        """
//Constants: could only be changed in the code itself.
//Pointer to cross section.
//Pointer to various information on the generation.
//Pointer to the settings database.
//Pointer to the particle data table.
//Pointer to the random number generator.
//Pointers to incoming beams.
//Pointer to Standard Model couplings.
//Pointer to the total/elastic/diffractive cross section object.
//Pointer to userHooks object for user interaction with program.
//Pointer to LHAup for generating external events.
//Initialization data, normally only set once.
//Information on incoming beams.
//Cross section information.
//Process-specific kinematics properties, almost always available.
//Event-specific kinematics properties, almost always available.
//Reselect decay products momenta isotropically in phase space.
//"""
//        return _pythia8.PhaseSpace_decayKinematicsStep(self, process, iRes)
//
//    def setup3Body(self):
//        """
//Much common code for normal 2 -> 1, 2 -> 2 and 2 -> 3 cases:
//Determine how phase space should be sampled.
//"""
//        return _pythia8.PhaseSpace_setup3Body(self)
//
//    def setupSampling123(self, is2, is3):
//        """
//"""
//        return _pythia8.PhaseSpace_setupSampling123(self, is2, is3)
//
//    def trialKin123(self, is2, is3, inEvent=True):
//        """
//Select a trial kinematics phase space point.
//"""
//        return _pythia8.PhaseSpace_trialKin123(self, is2, is3, inEvent)
//    __swig_setmethods__["idResA"] = _pythia8.PhaseSpace_idResA_set
//    __swig_getmethods__["idResA"] = _pythia8.PhaseSpace_idResA_get
//    if _newclass:
//        idResA = _swig_property(_pythia8.PhaseSpace_idResA_get, _pythia8.PhaseSpace_idResA_set)
//    __swig_setmethods__["idResB"] = _pythia8.PhaseSpace_idResB_set
//    __swig_getmethods__["idResB"] = _pythia8.PhaseSpace_idResB_get
//    if _newclass:
//        idResB = _swig_property(_pythia8.PhaseSpace_idResB_get, _pythia8.PhaseSpace_idResB_set)
//    __swig_setmethods__["mResA"] = _pythia8.PhaseSpace_mResA_set
//    __swig_getmethods__["mResA"] = _pythia8.PhaseSpace_mResA_get
//    if _newclass:
//        mResA = _swig_property(_pythia8.PhaseSpace_mResA_get, _pythia8.PhaseSpace_mResA_set)
//    __swig_setmethods__["mResB"] = _pythia8.PhaseSpace_mResB_set
//    __swig_getmethods__["mResB"] = _pythia8.PhaseSpace_mResB_get
//    if _newclass:
//        mResB = _swig_property(_pythia8.PhaseSpace_mResB_get, _pythia8.PhaseSpace_mResB_set)
//    __swig_setmethods__["GammaResA"] = _pythia8.PhaseSpace_GammaResA_set
//    __swig_getmethods__["GammaResA"] = _pythia8.PhaseSpace_GammaResA_get
//    if _newclass:
//        GammaResA = _swig_property(_pythia8.PhaseSpace_GammaResA_get, _pythia8.PhaseSpace_GammaResA_set)
//    __swig_setmethods__["GammaResB"] = _pythia8.PhaseSpace_GammaResB_set
//    __swig_getmethods__["GammaResB"] = _pythia8.PhaseSpace_GammaResB_get
//    if _newclass:
//        GammaResB = _swig_property(_pythia8.PhaseSpace_GammaResB_get, _pythia8.PhaseSpace_GammaResB_set)
//    __swig_setmethods__["tauResA"] = _pythia8.PhaseSpace_tauResA_set
//    __swig_getmethods__["tauResA"] = _pythia8.PhaseSpace_tauResA_get
//    if _newclass:
//        tauResA = _swig_property(_pythia8.PhaseSpace_tauResA_get, _pythia8.PhaseSpace_tauResA_set)
//    __swig_setmethods__["tauResB"] = _pythia8.PhaseSpace_tauResB_set
//    __swig_getmethods__["tauResB"] = _pythia8.PhaseSpace_tauResB_get
//    if _newclass:
//        tauResB = _swig_property(_pythia8.PhaseSpace_tauResB_get, _pythia8.PhaseSpace_tauResB_set)
//    __swig_setmethods__["widResA"] = _pythia8.PhaseSpace_widResA_set
//    __swig_getmethods__["widResA"] = _pythia8.PhaseSpace_widResA_get
//    if _newclass:
//        widResA = _swig_property(_pythia8.PhaseSpace_widResA_get, _pythia8.PhaseSpace_widResA_set)
//    __swig_setmethods__["widResB"] = _pythia8.PhaseSpace_widResB_set
//    __swig_getmethods__["widResB"] = _pythia8.PhaseSpace_widResB_get
//    if _newclass:
//        widResB = _swig_property(_pythia8.PhaseSpace_widResB_get, _pythia8.PhaseSpace_widResB_set)
//    __swig_setmethods__["sameResMass"] = _pythia8.PhaseSpace_sameResMass_set
//    __swig_getmethods__["sameResMass"] = _pythia8.PhaseSpace_sameResMass_get
//    if _newclass:
//        sameResMass = _swig_property(_pythia8.PhaseSpace_sameResMass_get, _pythia8.PhaseSpace_sameResMass_set)
//    __swig_setmethods__["useMirrorWeight"] = _pythia8.PhaseSpace_useMirrorWeight_set
//    __swig_getmethods__["useMirrorWeight"] = _pythia8.PhaseSpace_useMirrorWeight_get
//    if _newclass:
//        useMirrorWeight = _swig_property(_pythia8.PhaseSpace_useMirrorWeight_get, _pythia8.PhaseSpace_useMirrorWeight_set)
//    __swig_setmethods__["hasNegZ"] = _pythia8.PhaseSpace_hasNegZ_set
//    __swig_getmethods__["hasNegZ"] = _pythia8.PhaseSpace_hasNegZ_get
//    if _newclass:
//        hasNegZ = _swig_property(_pythia8.PhaseSpace_hasNegZ_get, _pythia8.PhaseSpace_hasNegZ_set)
//    __swig_setmethods__["hasPosZ"] = _pythia8.PhaseSpace_hasPosZ_set
//    __swig_getmethods__["hasPosZ"] = _pythia8.PhaseSpace_hasPosZ_get
//    if _newclass:
//        hasPosZ = _swig_property(_pythia8.PhaseSpace_hasPosZ_get, _pythia8.PhaseSpace_hasPosZ_set)
//    __swig_setmethods__["tau"] = _pythia8.PhaseSpace_tau_set
//    __swig_getmethods__["tau"] = _pythia8.PhaseSpace_tau_get
//    if _newclass:
//        tau = _swig_property(_pythia8.PhaseSpace_tau_get, _pythia8.PhaseSpace_tau_set)
//    __swig_setmethods__["y"] = _pythia8.PhaseSpace_y_set
//    __swig_getmethods__["y"] = _pythia8.PhaseSpace_y_get
//    if _newclass:
//        y = _swig_property(_pythia8.PhaseSpace_y_get, _pythia8.PhaseSpace_y_set)
//    __swig_setmethods__["z"] = _pythia8.PhaseSpace_z_set
//    __swig_getmethods__["z"] = _pythia8.PhaseSpace_z_get
//    if _newclass:
//        z = _swig_property(_pythia8.PhaseSpace_z_get, _pythia8.PhaseSpace_z_set)
//    __swig_setmethods__["tauMin"] = _pythia8.PhaseSpace_tauMin_set
//    __swig_getmethods__["tauMin"] = _pythia8.PhaseSpace_tauMin_get
//    if _newclass:
//        tauMin = _swig_property(_pythia8.PhaseSpace_tauMin_get, _pythia8.PhaseSpace_tauMin_set)
//    __swig_setmethods__["tauMax"] = _pythia8.PhaseSpace_tauMax_set
//    __swig_getmethods__["tauMax"] = _pythia8.PhaseSpace_tauMax_get
//    if _newclass:
//        tauMax = _swig_property(_pythia8.PhaseSpace_tauMax_get, _pythia8.PhaseSpace_tauMax_set)
//    __swig_setmethods__["yMax"] = _pythia8.PhaseSpace_yMax_set
//    __swig_getmethods__["yMax"] = _pythia8.PhaseSpace_yMax_get
//    if _newclass:
//        yMax = _swig_property(_pythia8.PhaseSpace_yMax_get, _pythia8.PhaseSpace_yMax_set)
//    __swig_setmethods__["zMin"] = _pythia8.PhaseSpace_zMin_set
//    __swig_getmethods__["zMin"] = _pythia8.PhaseSpace_zMin_get
//    if _newclass:
//        zMin = _swig_property(_pythia8.PhaseSpace_zMin_get, _pythia8.PhaseSpace_zMin_set)
//    __swig_setmethods__["zMax"] = _pythia8.PhaseSpace_zMax_set
//    __swig_getmethods__["zMax"] = _pythia8.PhaseSpace_zMax_get
//    if _newclass:
//        zMax = _swig_property(_pythia8.PhaseSpace_zMax_get, _pythia8.PhaseSpace_zMax_set)
//    __swig_setmethods__["ratio34"] = _pythia8.PhaseSpace_ratio34_set
//    __swig_getmethods__["ratio34"] = _pythia8.PhaseSpace_ratio34_get
//    if _newclass:
//        ratio34 = _swig_property(_pythia8.PhaseSpace_ratio34_get, _pythia8.PhaseSpace_ratio34_set)
//    __swig_setmethods__["unity34"] = _pythia8.PhaseSpace_unity34_set
//    __swig_getmethods__["unity34"] = _pythia8.PhaseSpace_unity34_get
//    if _newclass:
//        unity34 = _swig_property(_pythia8.PhaseSpace_unity34_get, _pythia8.PhaseSpace_unity34_set)
//    __swig_setmethods__["zNeg"] = _pythia8.PhaseSpace_zNeg_set
//    __swig_getmethods__["zNeg"] = _pythia8.PhaseSpace_zNeg_get
//    if _newclass:
//        zNeg = _swig_property(_pythia8.PhaseSpace_zNeg_get, _pythia8.PhaseSpace_zNeg_set)
//    __swig_setmethods__["zPos"] = _pythia8.PhaseSpace_zPos_set
//    __swig_getmethods__["zPos"] = _pythia8.PhaseSpace_zPos_get
//    if _newclass:
//        zPos = _swig_property(_pythia8.PhaseSpace_zPos_get, _pythia8.PhaseSpace_zPos_set)
//    __swig_setmethods__["wtTau"] = _pythia8.PhaseSpace_wtTau_set
//    __swig_getmethods__["wtTau"] = _pythia8.PhaseSpace_wtTau_get
//    if _newclass:
//        wtTau = _swig_property(_pythia8.PhaseSpace_wtTau_get, _pythia8.PhaseSpace_wtTau_set)
//    __swig_setmethods__["wtY"] = _pythia8.PhaseSpace_wtY_set
//    __swig_getmethods__["wtY"] = _pythia8.PhaseSpace_wtY_get
//    if _newclass:
//        wtY = _swig_property(_pythia8.PhaseSpace_wtY_get, _pythia8.PhaseSpace_wtY_set)
//    __swig_setmethods__["wtZ"] = _pythia8.PhaseSpace_wtZ_set
//    __swig_getmethods__["wtZ"] = _pythia8.PhaseSpace_wtZ_get
//    if _newclass:
//        wtZ = _swig_property(_pythia8.PhaseSpace_wtZ_get, _pythia8.PhaseSpace_wtZ_set)
//    __swig_setmethods__["wt3Body"] = _pythia8.PhaseSpace_wt3Body_set
//    __swig_getmethods__["wt3Body"] = _pythia8.PhaseSpace_wt3Body_get
//    if _newclass:
//        wt3Body = _swig_property(_pythia8.PhaseSpace_wt3Body_get, _pythia8.PhaseSpace_wt3Body_set)
//    __swig_setmethods__["runBW3H"] = _pythia8.PhaseSpace_runBW3H_set
//    __swig_getmethods__["runBW3H"] = _pythia8.PhaseSpace_runBW3H_get
//    if _newclass:
//        runBW3H = _swig_property(_pythia8.PhaseSpace_runBW3H_get, _pythia8.PhaseSpace_runBW3H_set)
//    __swig_setmethods__["runBW4H"] = _pythia8.PhaseSpace_runBW4H_set
//    __swig_getmethods__["runBW4H"] = _pythia8.PhaseSpace_runBW4H_get
//    if _newclass:
//        runBW4H = _swig_property(_pythia8.PhaseSpace_runBW4H_get, _pythia8.PhaseSpace_runBW4H_set)
//    __swig_setmethods__["runBW5H"] = _pythia8.PhaseSpace_runBW5H_set
//    __swig_getmethods__["runBW5H"] = _pythia8.PhaseSpace_runBW5H_get
//    if _newclass:
//        runBW5H = _swig_property(_pythia8.PhaseSpace_runBW5H_get, _pythia8.PhaseSpace_runBW5H_set)
//    __swig_setmethods__["intTau0"] = _pythia8.PhaseSpace_intTau0_set
//    __swig_getmethods__["intTau0"] = _pythia8.PhaseSpace_intTau0_get
//    if _newclass:
//        intTau0 = _swig_property(_pythia8.PhaseSpace_intTau0_get, _pythia8.PhaseSpace_intTau0_set)
//    __swig_setmethods__["intTau1"] = _pythia8.PhaseSpace_intTau1_set
//    __swig_getmethods__["intTau1"] = _pythia8.PhaseSpace_intTau1_get
//    if _newclass:
//        intTau1 = _swig_property(_pythia8.PhaseSpace_intTau1_get, _pythia8.PhaseSpace_intTau1_set)
//    __swig_setmethods__["intTau2"] = _pythia8.PhaseSpace_intTau2_set
//    __swig_getmethods__["intTau2"] = _pythia8.PhaseSpace_intTau2_get
//    if _newclass:
//        intTau2 = _swig_property(_pythia8.PhaseSpace_intTau2_get, _pythia8.PhaseSpace_intTau2_set)
//    __swig_setmethods__["intTau3"] = _pythia8.PhaseSpace_intTau3_set
//    __swig_getmethods__["intTau3"] = _pythia8.PhaseSpace_intTau3_get
//    if _newclass:
//        intTau3 = _swig_property(_pythia8.PhaseSpace_intTau3_get, _pythia8.PhaseSpace_intTau3_set)
//    __swig_setmethods__["intTau4"] = _pythia8.PhaseSpace_intTau4_set
//    __swig_getmethods__["intTau4"] = _pythia8.PhaseSpace_intTau4_get
//    if _newclass:
//        intTau4 = _swig_property(_pythia8.PhaseSpace_intTau4_get, _pythia8.PhaseSpace_intTau4_set)
//    __swig_setmethods__["intTau5"] = _pythia8.PhaseSpace_intTau5_set
//    __swig_getmethods__["intTau5"] = _pythia8.PhaseSpace_intTau5_get
//    if _newclass:
//        intTau5 = _swig_property(_pythia8.PhaseSpace_intTau5_get, _pythia8.PhaseSpace_intTau5_set)
//    __swig_setmethods__["intTau6"] = _pythia8.PhaseSpace_intTau6_set
//    __swig_getmethods__["intTau6"] = _pythia8.PhaseSpace_intTau6_get
//    if _newclass:
//        intTau6 = _swig_property(_pythia8.PhaseSpace_intTau6_get, _pythia8.PhaseSpace_intTau6_set)
//    __swig_setmethods__["intY0"] = _pythia8.PhaseSpace_intY0_set
//    __swig_getmethods__["intY0"] = _pythia8.PhaseSpace_intY0_get
//    if _newclass:
//        intY0 = _swig_property(_pythia8.PhaseSpace_intY0_get, _pythia8.PhaseSpace_intY0_set)
//    __swig_setmethods__["intY12"] = _pythia8.PhaseSpace_intY12_set
//    __swig_getmethods__["intY12"] = _pythia8.PhaseSpace_intY12_get
//    if _newclass:
//        intY12 = _swig_property(_pythia8.PhaseSpace_intY12_get, _pythia8.PhaseSpace_intY12_set)
//    __swig_setmethods__["intY34"] = _pythia8.PhaseSpace_intY34_set
//    __swig_getmethods__["intY34"] = _pythia8.PhaseSpace_intY34_get
//    if _newclass:
//        intY34 = _swig_property(_pythia8.PhaseSpace_intY34_get, _pythia8.PhaseSpace_intY34_set)
//    __swig_setmethods__["intY56"] = _pythia8.PhaseSpace_intY56_set
//    __swig_getmethods__["intY56"] = _pythia8.PhaseSpace_intY56_get
//    if _newclass:
//        intY56 = _swig_property(_pythia8.PhaseSpace_intY56_get, _pythia8.PhaseSpace_intY56_set)
//    __swig_setmethods__["mTchan1"] = _pythia8.PhaseSpace_mTchan1_set
//    __swig_getmethods__["mTchan1"] = _pythia8.PhaseSpace_mTchan1_get
//    if _newclass:
//        mTchan1 = _swig_property(_pythia8.PhaseSpace_mTchan1_get, _pythia8.PhaseSpace_mTchan1_set)
//    __swig_setmethods__["sTchan1"] = _pythia8.PhaseSpace_sTchan1_set
//    __swig_getmethods__["sTchan1"] = _pythia8.PhaseSpace_sTchan1_get
//    if _newclass:
//        sTchan1 = _swig_property(_pythia8.PhaseSpace_sTchan1_get, _pythia8.PhaseSpace_sTchan1_set)
//    __swig_setmethods__["mTchan2"] = _pythia8.PhaseSpace_mTchan2_set
//    __swig_getmethods__["mTchan2"] = _pythia8.PhaseSpace_mTchan2_get
//    if _newclass:
//        mTchan2 = _swig_property(_pythia8.PhaseSpace_mTchan2_get, _pythia8.PhaseSpace_mTchan2_set)
//    __swig_setmethods__["sTchan2"] = _pythia8.PhaseSpace_sTchan2_set
//    __swig_getmethods__["sTchan2"] = _pythia8.PhaseSpace_sTchan2_get
//    if _newclass:
//        sTchan2 = _swig_property(_pythia8.PhaseSpace_sTchan2_get, _pythia8.PhaseSpace_sTchan2_set)
//    __swig_setmethods__["frac3Flat"] = _pythia8.PhaseSpace_frac3Flat_set
//    __swig_getmethods__["frac3Flat"] = _pythia8.PhaseSpace_frac3Flat_get
//    if _newclass:
//        frac3Flat = _swig_property(_pythia8.PhaseSpace_frac3Flat_get, _pythia8.PhaseSpace_frac3Flat_set)
//    __swig_setmethods__["frac3Pow1"] = _pythia8.PhaseSpace_frac3Pow1_set
//    __swig_getmethods__["frac3Pow1"] = _pythia8.PhaseSpace_frac3Pow1_get
//    if _newclass:
//        frac3Pow1 = _swig_property(_pythia8.PhaseSpace_frac3Pow1_get, _pythia8.PhaseSpace_frac3Pow1_set)
//    __swig_setmethods__["frac3Pow2"] = _pythia8.PhaseSpace_frac3Pow2_set
//    __swig_getmethods__["frac3Pow2"] = _pythia8.PhaseSpace_frac3Pow2_get
//    if _newclass:
//        frac3Pow2 = _swig_property(_pythia8.PhaseSpace_frac3Pow2_get, _pythia8.PhaseSpace_frac3Pow2_set)
//    __swig_setmethods__["zNegMin"] = _pythia8.PhaseSpace_zNegMin_set
//    __swig_getmethods__["zNegMin"] = _pythia8.PhaseSpace_zNegMin_get
//    if _newclass:
//        zNegMin = _swig_property(_pythia8.PhaseSpace_zNegMin_get, _pythia8.PhaseSpace_zNegMin_set)
//    __swig_setmethods__["zNegMax"] = _pythia8.PhaseSpace_zNegMax_set
//    __swig_getmethods__["zNegMax"] = _pythia8.PhaseSpace_zNegMax_get
//    if _newclass:
//        zNegMax = _swig_property(_pythia8.PhaseSpace_zNegMax_get, _pythia8.PhaseSpace_zNegMax_set)
//    __swig_setmethods__["zPosMin"] = _pythia8.PhaseSpace_zPosMin_set
//    __swig_getmethods__["zPosMin"] = _pythia8.PhaseSpace_zPosMin_get
//    if _newclass:
//        zPosMin = _swig_property(_pythia8.PhaseSpace_zPosMin_get, _pythia8.PhaseSpace_zPosMin_set)
//    __swig_setmethods__["zPosMax"] = _pythia8.PhaseSpace_zPosMax_set
//    __swig_getmethods__["zPosMax"] = _pythia8.PhaseSpace_zPosMax_get
//    if _newclass:
//        zPosMax = _swig_property(_pythia8.PhaseSpace_zPosMax_get, _pythia8.PhaseSpace_zPosMax_set)
//    __swig_setmethods__["p3cm"] = _pythia8.PhaseSpace_p3cm_set
//    __swig_getmethods__["p3cm"] = _pythia8.PhaseSpace_p3cm_get
//    if _newclass:
//        p3cm = _swig_property(_pythia8.PhaseSpace_p3cm_get, _pythia8.PhaseSpace_p3cm_set)
//    __swig_setmethods__["p4cm"] = _pythia8.PhaseSpace_p4cm_set
//    __swig_getmethods__["p4cm"] = _pythia8.PhaseSpace_p4cm_get
//    if _newclass:
//        p4cm = _swig_property(_pythia8.PhaseSpace_p4cm_get, _pythia8.PhaseSpace_p4cm_set)
//    __swig_setmethods__["p5cm"] = _pythia8.PhaseSpace_p5cm_set
//    __swig_getmethods__["p5cm"] = _pythia8.PhaseSpace_p5cm_get
//    if _newclass:
//        p5cm = _swig_property(_pythia8.PhaseSpace_p5cm_get, _pythia8.PhaseSpace_p5cm_set)
//    __swig_setmethods__["nTau"] = _pythia8.PhaseSpace_nTau_set
//    __swig_getmethods__["nTau"] = _pythia8.PhaseSpace_nTau_get
//    if _newclass:
//        nTau = _swig_property(_pythia8.PhaseSpace_nTau_get, _pythia8.PhaseSpace_nTau_set)
//    __swig_setmethods__["nY"] = _pythia8.PhaseSpace_nY_set
//    __swig_getmethods__["nY"] = _pythia8.PhaseSpace_nY_get
//    if _newclass:
//        nY = _swig_property(_pythia8.PhaseSpace_nY_get, _pythia8.PhaseSpace_nY_set)
//    __swig_setmethods__["nZ"] = _pythia8.PhaseSpace_nZ_set
//    __swig_getmethods__["nZ"] = _pythia8.PhaseSpace_nZ_get
//    if _newclass:
//        nZ = _swig_property(_pythia8.PhaseSpace_nZ_get, _pythia8.PhaseSpace_nZ_set)
//    __swig_setmethods__["tauCoef"] = _pythia8.PhaseSpace_tauCoef_set
//    __swig_getmethods__["tauCoef"] = _pythia8.PhaseSpace_tauCoef_get
//    if _newclass:
//        tauCoef = _swig_property(_pythia8.PhaseSpace_tauCoef_get, _pythia8.PhaseSpace_tauCoef_set)
//    __swig_setmethods__["yCoef"] = _pythia8.PhaseSpace_yCoef_set
//    __swig_getmethods__["yCoef"] = _pythia8.PhaseSpace_yCoef_get
//    if _newclass:
//        yCoef = _swig_property(_pythia8.PhaseSpace_yCoef_get, _pythia8.PhaseSpace_yCoef_set)
//    __swig_setmethods__["zCoef"] = _pythia8.PhaseSpace_zCoef_set
//    __swig_getmethods__["zCoef"] = _pythia8.PhaseSpace_zCoef_get
//    if _newclass:
//        zCoef = _swig_property(_pythia8.PhaseSpace_zCoef_get, _pythia8.PhaseSpace_zCoef_set)
//    __swig_setmethods__["tauCoefSum"] = _pythia8.PhaseSpace_tauCoefSum_set
//    __swig_getmethods__["tauCoefSum"] = _pythia8.PhaseSpace_tauCoefSum_get
//    if _newclass:
//        tauCoefSum = _swig_property(_pythia8.PhaseSpace_tauCoefSum_get, _pythia8.PhaseSpace_tauCoefSum_set)
//    __swig_setmethods__["yCoefSum"] = _pythia8.PhaseSpace_yCoefSum_set
//    __swig_getmethods__["yCoefSum"] = _pythia8.PhaseSpace_yCoefSum_get
//    if _newclass:
//        yCoefSum = _swig_property(_pythia8.PhaseSpace_yCoefSum_get, _pythia8.PhaseSpace_yCoefSum_set)
//    __swig_setmethods__["zCoefSum"] = _pythia8.PhaseSpace_zCoefSum_set
//    __swig_getmethods__["zCoefSum"] = _pythia8.PhaseSpace_zCoefSum_get
//    if _newclass:
//        zCoefSum = _swig_property(_pythia8.PhaseSpace_zCoefSum_get, _pythia8.PhaseSpace_zCoefSum_set)
//
//    def limitTau(self, is2, is3):
//        """
//Presence and properties of any s-channel resonances.
//Kinematics properties specific to 2 -> 1/2/3.
//Coefficients for optimized selection in 2 -> 1/2/3.
//Calculate kinematical limits for 2 -> 1/2/3.
//"""
//        return _pythia8.PhaseSpace_limitTau(self, is2, is3)
//
//    def limitY(self):
//        """
//"""
//        return _pythia8.PhaseSpace_limitY(self)
//
//    def limitZ(self):
//        """
//"""
//        return _pythia8.PhaseSpace_limitZ(self)
//
//    def selectTau(self, iTau, tauVal, is2):
//        """
//Select kinematical variable between defined limits for 2 -> 1/2/3.
//"""
//        return _pythia8.PhaseSpace_selectTau(self, iTau, tauVal, is2)
//
//    def selectY(self, iY, yVal):
//        """
//"""
//        return _pythia8.PhaseSpace_selectY(self, iY, yVal)
//
//    def selectZ(self, iZ, zVal):
//        """
//"""
//        return _pythia8.PhaseSpace_selectZ(self, iZ, zVal)
//
//    def select3Body(self):
//        """
//"""
//        return _pythia8.PhaseSpace_select3Body(self)
//
//    def solveSys(self, n, bin, vec, mat, coef):
//        """
//Solve equation system for better phase space coefficients in 2 -> 1/2/3.
//"""
//        return _pythia8.PhaseSpace_solveSys(self, n, bin, vec, mat, coef)
//    __swig_setmethods__["useBW"] = _pythia8.PhaseSpace_useBW_set
//    __swig_getmethods__["useBW"] = _pythia8.PhaseSpace_useBW_get
//    if _newclass:
//        useBW = _swig_property(_pythia8.PhaseSpace_useBW_get, _pythia8.PhaseSpace_useBW_set)
//    __swig_setmethods__["idMass"] = _pythia8.PhaseSpace_idMass_set
//    __swig_getmethods__["idMass"] = _pythia8.PhaseSpace_idMass_get
//    if _newclass:
//        idMass = _swig_property(_pythia8.PhaseSpace_idMass_get, _pythia8.PhaseSpace_idMass_set)
//    __swig_setmethods__["mPeak"] = _pythia8.PhaseSpace_mPeak_set
//    __swig_getmethods__["mPeak"] = _pythia8.PhaseSpace_mPeak_get
//    if _newclass:
//        mPeak = _swig_property(_pythia8.PhaseSpace_mPeak_get, _pythia8.PhaseSpace_mPeak_set)
//    __swig_setmethods__["sPeak"] = _pythia8.PhaseSpace_sPeak_set
//    __swig_getmethods__["sPeak"] = _pythia8.PhaseSpace_sPeak_get
//    if _newclass:
//        sPeak = _swig_property(_pythia8.PhaseSpace_sPeak_get, _pythia8.PhaseSpace_sPeak_set)
//    __swig_setmethods__["mWidth"] = _pythia8.PhaseSpace_mWidth_set
//    __swig_getmethods__["mWidth"] = _pythia8.PhaseSpace_mWidth_get
//    if _newclass:
//        mWidth = _swig_property(_pythia8.PhaseSpace_mWidth_get, _pythia8.PhaseSpace_mWidth_set)
//    __swig_setmethods__["mMin"] = _pythia8.PhaseSpace_mMin_set
//    __swig_getmethods__["mMin"] = _pythia8.PhaseSpace_mMin_get
//    if _newclass:
//        mMin = _swig_property(_pythia8.PhaseSpace_mMin_get, _pythia8.PhaseSpace_mMin_set)
//    __swig_setmethods__["mMax"] = _pythia8.PhaseSpace_mMax_set
//    __swig_getmethods__["mMax"] = _pythia8.PhaseSpace_mMax_get
//    if _newclass:
//        mMax = _swig_property(_pythia8.PhaseSpace_mMax_get, _pythia8.PhaseSpace_mMax_set)
//    __swig_setmethods__["mw"] = _pythia8.PhaseSpace_mw_set
//    __swig_getmethods__["mw"] = _pythia8.PhaseSpace_mw_get
//    if _newclass:
//        mw = _swig_property(_pythia8.PhaseSpace_mw_get, _pythia8.PhaseSpace_mw_set)
//    __swig_setmethods__["wmRat"] = _pythia8.PhaseSpace_wmRat_set
//    __swig_getmethods__["wmRat"] = _pythia8.PhaseSpace_wmRat_get
//    if _newclass:
//        wmRat = _swig_property(_pythia8.PhaseSpace_wmRat_get, _pythia8.PhaseSpace_wmRat_set)
//    __swig_setmethods__["mLower"] = _pythia8.PhaseSpace_mLower_set
//    __swig_getmethods__["mLower"] = _pythia8.PhaseSpace_mLower_get
//    if _newclass:
//        mLower = _swig_property(_pythia8.PhaseSpace_mLower_get, _pythia8.PhaseSpace_mLower_set)
//    __swig_setmethods__["mUpper"] = _pythia8.PhaseSpace_mUpper_set
//    __swig_getmethods__["mUpper"] = _pythia8.PhaseSpace_mUpper_get
//    if _newclass:
//        mUpper = _swig_property(_pythia8.PhaseSpace_mUpper_get, _pythia8.PhaseSpace_mUpper_set)
//    __swig_setmethods__["sLower"] = _pythia8.PhaseSpace_sLower_set
//    __swig_getmethods__["sLower"] = _pythia8.PhaseSpace_sLower_get
//    if _newclass:
//        sLower = _swig_property(_pythia8.PhaseSpace_sLower_get, _pythia8.PhaseSpace_sLower_set)
//    __swig_setmethods__["sUpper"] = _pythia8.PhaseSpace_sUpper_set
//    __swig_getmethods__["sUpper"] = _pythia8.PhaseSpace_sUpper_get
//    if _newclass:
//        sUpper = _swig_property(_pythia8.PhaseSpace_sUpper_get, _pythia8.PhaseSpace_sUpper_set)
//    __swig_setmethods__["fracFlatS"] = _pythia8.PhaseSpace_fracFlatS_set
//    __swig_getmethods__["fracFlatS"] = _pythia8.PhaseSpace_fracFlatS_get
//    if _newclass:
//        fracFlatS = _swig_property(_pythia8.PhaseSpace_fracFlatS_get, _pythia8.PhaseSpace_fracFlatS_set)
//    __swig_setmethods__["fracFlatM"] = _pythia8.PhaseSpace_fracFlatM_set
//    __swig_getmethods__["fracFlatM"] = _pythia8.PhaseSpace_fracFlatM_get
//    if _newclass:
//        fracFlatM = _swig_property(_pythia8.PhaseSpace_fracFlatM_get, _pythia8.PhaseSpace_fracFlatM_set)
//    __swig_setmethods__["fracInv"] = _pythia8.PhaseSpace_fracInv_set
//    __swig_getmethods__["fracInv"] = _pythia8.PhaseSpace_fracInv_get
//    if _newclass:
//        fracInv = _swig_property(_pythia8.PhaseSpace_fracInv_get, _pythia8.PhaseSpace_fracInv_set)
//    __swig_setmethods__["fracInv2"] = _pythia8.PhaseSpace_fracInv2_set
//    __swig_getmethods__["fracInv2"] = _pythia8.PhaseSpace_fracInv2_get
//    if _newclass:
//        fracInv2 = _swig_property(_pythia8.PhaseSpace_fracInv2_get, _pythia8.PhaseSpace_fracInv2_set)
//    __swig_setmethods__["atanLower"] = _pythia8.PhaseSpace_atanLower_set
//    __swig_getmethods__["atanLower"] = _pythia8.PhaseSpace_atanLower_get
//    if _newclass:
//        atanLower = _swig_property(_pythia8.PhaseSpace_atanLower_get, _pythia8.PhaseSpace_atanLower_set)
//    __swig_setmethods__["atanUpper"] = _pythia8.PhaseSpace_atanUpper_set
//    __swig_getmethods__["atanUpper"] = _pythia8.PhaseSpace_atanUpper_get
//    if _newclass:
//        atanUpper = _swig_property(_pythia8.PhaseSpace_atanUpper_get, _pythia8.PhaseSpace_atanUpper_set)
//    __swig_setmethods__["intBW"] = _pythia8.PhaseSpace_intBW_set
//    __swig_getmethods__["intBW"] = _pythia8.PhaseSpace_intBW_get
//    if _newclass:
//        intBW = _swig_property(_pythia8.PhaseSpace_intBW_get, _pythia8.PhaseSpace_intBW_set)
//    __swig_setmethods__["intFlatS"] = _pythia8.PhaseSpace_intFlatS_set
//    __swig_getmethods__["intFlatS"] = _pythia8.PhaseSpace_intFlatS_get
//    if _newclass:
//        intFlatS = _swig_property(_pythia8.PhaseSpace_intFlatS_get, _pythia8.PhaseSpace_intFlatS_set)
//    __swig_setmethods__["intFlatM"] = _pythia8.PhaseSpace_intFlatM_set
//    __swig_getmethods__["intFlatM"] = _pythia8.PhaseSpace_intFlatM_get
//    if _newclass:
//        intFlatM = _swig_property(_pythia8.PhaseSpace_intFlatM_get, _pythia8.PhaseSpace_intFlatM_set)
//    __swig_setmethods__["intInv"] = _pythia8.PhaseSpace_intInv_set
//    __swig_getmethods__["intInv"] = _pythia8.PhaseSpace_intInv_get
//    if _newclass:
//        intInv = _swig_property(_pythia8.PhaseSpace_intInv_get, _pythia8.PhaseSpace_intInv_set)
//    __swig_setmethods__["intInv2"] = _pythia8.PhaseSpace_intInv2_set
//    __swig_getmethods__["intInv2"] = _pythia8.PhaseSpace_intInv2_get
//    if _newclass:
//        intInv2 = _swig_property(_pythia8.PhaseSpace_intInv2_get, _pythia8.PhaseSpace_intInv2_set)
//
//    def setupMass1(self, iM):
//        """
//Properties specific to resonance mass selection in 2 -> 2 and 2 -> 3.
//Setup mass selection for one resonance at a time. Split in two parts.
//"""
//        return _pythia8.PhaseSpace_setupMass1(self, iM)
//
//    def setupMass2(self, iM, distToThresh):
//        """
//"""
//        return _pythia8.PhaseSpace_setupMass2(self, iM, distToThresh)
//
//    def trialMass(self, iM):
//        """
//Do mass selection and find the associated weight.
//"""
//        return _pythia8.PhaseSpace_trialMass(self, iM)
//
//    def weightMass(self, iM):
//        """
//"""
//        return _pythia8.PhaseSpace_weightMass(self, iM)
//
//    def tRange(self, sIn, s1In, s2In, s3In, s4In):
//        """
//"""
//        return _pythia8.PhaseSpace_tRange(self, sIn, s1In, s2In, s3In, s4In)
//
//    def tInRange(self, tIn, sIn, s1In, s2In, s3In, s4In):
//        """
//"""
//        return _pythia8.PhaseSpace_tInRange(self, tIn, sIn, s1In, s2In, s3In, s4In)
//    def __disown__(self):
//        self.this.disown()
//        _pythia8.disown_PhaseSpace(self)
//        return weakref_proxy(self)
//PhaseSpace_swigregister = _pythia8.PhaseSpace_swigregister
//PhaseSpace_swigregister(PhaseSpace)
//PhaseSpace.NMAXTRY = _pythia8.cvar.PhaseSpace_NMAXTRY
//PhaseSpace.NTRY3BODY = _pythia8.cvar.PhaseSpace_NTRY3BODY
//PhaseSpace.SAFETYMARGIN = _pythia8.cvar.PhaseSpace_SAFETYMARGIN
//PhaseSpace.TINY = _pythia8.cvar.PhaseSpace_TINY
//PhaseSpace.EVENFRAC = _pythia8.cvar.PhaseSpace_EVENFRAC
//PhaseSpace.SAMESIGMA = _pythia8.cvar.PhaseSpace_SAMESIGMA
//PhaseSpace.MRESMINABS = _pythia8.cvar.PhaseSpace_MRESMINABS
//PhaseSpace.WIDTHMARGIN = _pythia8.cvar.PhaseSpace_WIDTHMARGIN
//PhaseSpace.SAMEMASS = _pythia8.cvar.PhaseSpace_SAMEMASS
//PhaseSpace.MASSMARGIN = _pythia8.cvar.PhaseSpace_MASSMARGIN
//PhaseSpace.EXTRABWWTMAX = _pythia8.cvar.PhaseSpace_EXTRABWWTMAX
//PhaseSpace.THRESHOLDSIZE = _pythia8.cvar.PhaseSpace_THRESHOLDSIZE
//PhaseSpace.THRESHOLDSTEP = _pythia8.cvar.PhaseSpace_THRESHOLDSTEP
//PhaseSpace.YRANGEMARGIN = _pythia8.cvar.PhaseSpace_YRANGEMARGIN
//PhaseSpace.LEPTONXMIN = _pythia8.cvar.PhaseSpace_LEPTONXMIN
//PhaseSpace.LEPTONXMAX = _pythia8.cvar.PhaseSpace_LEPTONXMAX
//PhaseSpace.LEPTONXLOGMIN = _pythia8.cvar.PhaseSpace_LEPTONXLOGMIN
//PhaseSpace.LEPTONXLOGMAX = _pythia8.cvar.PhaseSpace_LEPTONXLOGMAX
//PhaseSpace.LEPTONTAUMIN = _pythia8.cvar.PhaseSpace_LEPTONTAUMIN
//PhaseSpace.SHATMINZ = _pythia8.cvar.PhaseSpace_SHATMINZ
//PhaseSpace.PT2RATMINZ = _pythia8.cvar.PhaseSpace_PT2RATMINZ
//PhaseSpace.WTCORRECTION = _pythia8.cvar.PhaseSpace_WTCORRECTION
//
//class PhaseSpace2to1tauy(PhaseSpace):
//    """
// double tmp = sqrt(1. - exp(-x2 * (4./M_PI + kx2) / (1. + kx2)));
// return ((x >= 0.) ? tmp : -tmp); }
//"""
//    __swig_setmethods__ = {}
//    for _s in [PhaseSpace]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, PhaseSpace2to1tauy, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PhaseSpace]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, PhaseSpace2to1tauy, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_PhaseSpace2to1tauy()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def setupSampling(self):
//        """
//Optimize subsequent kinematics selection.
//"""
//        return _pythia8.PhaseSpace2to1tauy_setupSampling(self)
//
//    def trialKin(self, inEvent=True, arg3=False):
//        """
//Construct the trial kinematics.
//"""
//        return _pythia8.PhaseSpace2to1tauy_trialKin(self, inEvent, arg3)
//
//    def finalKin(self):
//        """
//Construct the final event kinematics.
//"""
//        return _pythia8.PhaseSpace2to1tauy_finalKin(self)
//    __swig_destroy__ = _pythia8.delete_PhaseSpace2to1tauy
//    __del__ = lambda self: None
//PhaseSpace2to1tauy_swigregister = _pythia8.PhaseSpace2to1tauy_swigregister
//PhaseSpace2to1tauy_swigregister(PhaseSpace2to1tauy)
//
//class PhaseSpace2to2tauyz(PhaseSpace):
//    """
//"""
//    __swig_setmethods__ = {}
//    for _s in [PhaseSpace]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, PhaseSpace2to2tauyz, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PhaseSpace]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, PhaseSpace2to2tauyz, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_PhaseSpace2to2tauyz()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def setupSampling(self):
//        """
//Optimize subsequent kinematics selection.
//"""
//        return _pythia8.PhaseSpace2to2tauyz_setupSampling(self)
//
//    def trialKin(self, inEvent=True, arg3=False):
//        """
//Construct the trial kinematics.
//"""
//        return _pythia8.PhaseSpace2to2tauyz_trialKin(self, inEvent, arg3)
//
//    def finalKin(self):
//        """
//Construct the final event kinematics.
//"""
//        return _pythia8.PhaseSpace2to2tauyz_finalKin(self)
//
//    def rescaleMomenta(self, sHatNew):
//        """
//Rescales the momenta of incoming and outgoing partons according to
//new sHat.
//"""
//        return _pythia8.PhaseSpace2to2tauyz_rescaleMomenta(self, sHatNew)
//
//    def rescaleSigma(self, sHatNew):
//        """
//Recalculates cross section with rescaled sHat.
//"""
//        return _pythia8.PhaseSpace2to2tauyz_rescaleSigma(self, sHatNew)
//
//    def weightGammaPDFApprox(self):
//        """
//Calculate the weight for over-estimated cross section.
//"""
//        return _pythia8.PhaseSpace2to2tauyz_weightGammaPDFApprox(self)
//    __swig_destroy__ = _pythia8.delete_PhaseSpace2to2tauyz
//    __del__ = lambda self: None
//PhaseSpace2to2tauyz_swigregister = _pythia8.PhaseSpace2to2tauyz_swigregister
//PhaseSpace2to2tauyz_swigregister(PhaseSpace2to2tauyz)
//
//class PhaseSpace2to2elastic(PhaseSpace):
//    """
//"""
//    __swig_setmethods__ = {}
//    for _s in [PhaseSpace]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, PhaseSpace2to2elastic, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PhaseSpace]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, PhaseSpace2to2elastic, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_PhaseSpace2to2elastic()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def setupSampling(self):
//        """
//Construct the trial or final event kinematics.
//"""
//        return _pythia8.PhaseSpace2to2elastic_setupSampling(self)
//
//    def trialKin(self, inEvent=True, arg3=False):
//        """
//"""
//        return _pythia8.PhaseSpace2to2elastic_trialKin(self, inEvent, arg3)
//
//    def finalKin(self):
//        """
//"""
//        return _pythia8.PhaseSpace2to2elastic_finalKin(self)
//
//    def isResolved(self):
//        """
//Are beam particles resolved in partons or scatter directly?
//"""
//        return _pythia8.PhaseSpace2to2elastic_isResolved(self)
//    __swig_destroy__ = _pythia8.delete_PhaseSpace2to2elastic
//    __del__ = lambda self: None
//PhaseSpace2to2elastic_swigregister = _pythia8.PhaseSpace2to2elastic_swigregister
//PhaseSpace2to2elastic_swigregister(PhaseSpace2to2elastic)
//
//class PhaseSpace2to2diffractive(PhaseSpace):
//    """
//Constants: could only be changed in the code itself.
//Kinematics properties specific to 2 -> 2 elastic.
//"""
//    __swig_setmethods__ = {}
//    for _s in [PhaseSpace]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, PhaseSpace2to2diffractive, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PhaseSpace]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, PhaseSpace2to2diffractive, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, isDiffAin=False, isDiffBin=False):
//        """
//Constructor.
//"""
//        this = _pythia8.new_PhaseSpace2to2diffractive(isDiffAin, isDiffBin)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def setupSampling(self):
//        """
//Construct the trial or final event kinematics.
//"""
//        return _pythia8.PhaseSpace2to2diffractive_setupSampling(self)
//
//    def trialKin(self, inEvent=True, arg3=False):
//        """
//"""
//        return _pythia8.PhaseSpace2to2diffractive_trialKin(self, inEvent, arg3)
//
//    def finalKin(self):
//        """
//"""
//        return _pythia8.PhaseSpace2to2diffractive_finalKin(self)
//
//    def isResolved(self):
//        """
//Are beam particles resolved in partons or scatter directly?
//"""
//        return _pythia8.PhaseSpace2to2diffractive_isResolved(self)
//    __swig_destroy__ = _pythia8.delete_PhaseSpace2to2diffractive
//    __del__ = lambda self: None
//PhaseSpace2to2diffractive_swigregister = _pythia8.PhaseSpace2to2diffractive_swigregister
//PhaseSpace2to2diffractive_swigregister(PhaseSpace2to2diffractive)
//
//class PhaseSpace2to3diffractive(PhaseSpace):
//    """
//Constants: could only be changed in the code itself.
//Initialization data.
//Kinematics properties specific to 2 -> 2 diffraction.
//"""
//    __swig_setmethods__ = {}
//    for _s in [PhaseSpace]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, PhaseSpace2to3diffractive, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PhaseSpace]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, PhaseSpace2to3diffractive, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_PhaseSpace2to3diffractive()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def setupSampling(self):
//        """
//Construct the trial or final event kinematics.
//"""
//        return _pythia8.PhaseSpace2to3diffractive_setupSampling(self)
//
//    def trialKin(self, inEvent=True, arg3=False):
//        """
//"""
//        return _pythia8.PhaseSpace2to3diffractive_trialKin(self, inEvent, arg3)
//
//    def finalKin(self):
//        """
//"""
//        return _pythia8.PhaseSpace2to3diffractive_finalKin(self)
//
//    def isResolved(self):
//        """
//Are beam particles resolved in partons or scatter directly?
//"""
//        return _pythia8.PhaseSpace2to3diffractive_isResolved(self)
//    __swig_destroy__ = _pythia8.delete_PhaseSpace2to3diffractive
//    __del__ = lambda self: None
//PhaseSpace2to3diffractive_swigregister = _pythia8.PhaseSpace2to3diffractive_swigregister
//PhaseSpace2to3diffractive_swigregister(PhaseSpace2to3diffractive)
//
//class PhaseSpace2to2nondiffractive(PhaseSpace):
//    """
//Constants: could only be changed in the code itself.
//Initialization data.
//Local variables to calculate DPE kinematics.
//"""
//    __swig_setmethods__ = {}
//    for _s in [PhaseSpace]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, PhaseSpace2to2nondiffractive, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PhaseSpace]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, PhaseSpace2to2nondiffractive, name)
//
//    def __init__(self, *args, **kwargs):
//        """
//Constructor.
//"""
//        raise AttributeError("No constructor defined - class is abstract")
//    __repr__ = _swig_repr
//
//    def setupSampling(self):
//        """
//Construct the trial or final event kinematics.
//"""
//        return _pythia8.PhaseSpace2to2nondiffractive_setupSampling(self)
//
//    def trialKin(self, arg2, arg3=False):
//        """
//"""
//        return _pythia8.PhaseSpace2to2nondiffractive_trialKin(self, arg2, arg3)
//
//    def finalKin(self):
//        """
//"""
//        return _pythia8.PhaseSpace2to2nondiffractive_finalKin(self)
//    __swig_destroy__ = _pythia8.delete_PhaseSpace2to2nondiffractive
//    __del__ = lambda self: None
//PhaseSpace2to2nondiffractive_swigregister = _pythia8.PhaseSpace2to2nondiffractive_swigregister
//PhaseSpace2to2nondiffractive_swigregister(PhaseSpace2to2nondiffractive)
//
//class PhaseSpace2to2nondiffractiveGamma(PhaseSpace):
//    """
//"""
//    __swig_setmethods__ = {}
//    for _s in [PhaseSpace]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, PhaseSpace2to2nondiffractiveGamma, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PhaseSpace]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, PhaseSpace2to2nondiffractiveGamma, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_PhaseSpace2to2nondiffractiveGamma()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def setupSampling(self):
//        """
//Construct the trial or final event kinematics.
//"""
//        return _pythia8.PhaseSpace2to2nondiffractiveGamma_setupSampling(self)
//
//    def trialKin(self, inEvent=True, arg3=False):
//        """
//"""
//        return _pythia8.PhaseSpace2to2nondiffractiveGamma_trialKin(self, inEvent, arg3)
//
//    def finalKin(self):
//        """
//"""
//        return _pythia8.PhaseSpace2to2nondiffractiveGamma_finalKin(self)
//
//    def setGammaKinPtr(self, gammaKinPtrIn):
//        """
//Set the pointer to GammaKinematics.
//"""
//        return _pythia8.PhaseSpace2to2nondiffractiveGamma_setGammaKinPtr(self, gammaKinPtrIn)
//    __swig_destroy__ = _pythia8.delete_PhaseSpace2to2nondiffractiveGamma
//    __del__ = lambda self: None
//PhaseSpace2to2nondiffractiveGamma_swigregister = _pythia8.PhaseSpace2to2nondiffractiveGamma_swigregister
//PhaseSpace2to2nondiffractiveGamma_swigregister(PhaseSpace2to2nondiffractiveGamma)
//
//class PhaseSpace2to3tauycyl(PhaseSpace):
//    """
//Pointer to object that samples photon kinematics from leptons.
//Parameters.
//"""
//    __swig_setmethods__ = {}
//    for _s in [PhaseSpace]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, PhaseSpace2to3tauycyl, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PhaseSpace]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, PhaseSpace2to3tauycyl, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_PhaseSpace2to3tauycyl()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def setupSampling(self):
//        """
//Optimize subsequent kinematics selection.
//"""
//        return _pythia8.PhaseSpace2to3tauycyl_setupSampling(self)
//
//    def trialKin(self, inEvent=True, arg3=False):
//        """
//Construct the trial kinematics.
//"""
//        return _pythia8.PhaseSpace2to3tauycyl_trialKin(self, inEvent, arg3)
//
//    def finalKin(self):
//        """
//Construct the final event kinematics.
//"""
//        return _pythia8.PhaseSpace2to3tauycyl_finalKin(self)
//    __swig_destroy__ = _pythia8.delete_PhaseSpace2to3tauycyl
//    __del__ = lambda self: None
//PhaseSpace2to3tauycyl_swigregister = _pythia8.PhaseSpace2to3tauycyl_swigregister
//PhaseSpace2to3tauycyl_swigregister(PhaseSpace2to3tauycyl)
//
//class PhaseSpace2to3yyycyl(PhaseSpace):
//    """
//"""
//    __swig_setmethods__ = {}
//    for _s in [PhaseSpace]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, PhaseSpace2to3yyycyl, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PhaseSpace]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, PhaseSpace2to3yyycyl, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_PhaseSpace2to3yyycyl()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def setupSampling(self):
//        """
//Optimize subsequent kinematics selection.
//"""
//        return _pythia8.PhaseSpace2to3yyycyl_setupSampling(self)
//
//    def trialKin(self, inEvent=True, arg3=False):
//        """
//Construct the trial kinematics.
//"""
//        return _pythia8.PhaseSpace2to3yyycyl_trialKin(self, inEvent, arg3)
//
//    def finalKin(self):
//        """
//Construct the final event kinematics.
//"""
//        return _pythia8.PhaseSpace2to3yyycyl_finalKin(self)
//    __swig_destroy__ = _pythia8.delete_PhaseSpace2to3yyycyl
//    __del__ = lambda self: None
//PhaseSpace2to3yyycyl_swigregister = _pythia8.PhaseSpace2to3yyycyl_swigregister
//PhaseSpace2to3yyycyl_swigregister(PhaseSpace2to3yyycyl)
//
//class PhaseSpaceLHA(PhaseSpace):
//    """
//Phase space cuts specifically for 2 -> 3 QCD processes.
//Event kinematics choices.
//"""
//    __swig_setmethods__ = {}
//    for _s in [PhaseSpace]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, PhaseSpaceLHA, name, value)
//    __swig_getmethods__ = {}
//    for _s in [PhaseSpace]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, PhaseSpaceLHA, name)
//
//    def __init__(self, *args, **kwargs):
//        """
//Constructor.
//"""
//        raise AttributeError("No constructor defined - class is abstract")
//    __repr__ = _swig_repr
//
//    def setupSampling(self):
//        """
//Find maximal cross section for comparison with internal processes.
//"""
//        return _pythia8.PhaseSpaceLHA_setupSampling(self)
//
//    def trialKin(self, arg2, repeatSame=False):
//        """
//Construct the next process, by interface to Les Houches class.
//"""
//        return _pythia8.PhaseSpaceLHA_trialKin(self, arg2, repeatSame)
//
//    def finalKin(self):
//        """
//Set scale, alpha_s and alpha_em if not done.
//"""
//        return _pythia8.PhaseSpaceLHA_finalKin(self)
//
//    def sigmaSumSigned(self):
//        """
//For Les Houches with negative event weight needs
//"""
//        return _pythia8.PhaseSpaceLHA_sigmaSumSigned(self)
//    __swig_destroy__ = _pythia8.delete_PhaseSpaceLHA
//    __del__ = lambda self: None
//PhaseSpaceLHA_swigregister = _pythia8.PhaseSpaceLHA_swigregister
//PhaseSpaceLHA_swigregister(PhaseSpaceLHA)
//
//class Sigma1qg2qStar(Sigma1Process):
//    """
//A derived class for q g -> q^* (excited quark state).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma1qg2qStar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma1qg2qStar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idqIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma1qg2qStar(idqIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma1qg2qStar_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma1qg2qStar_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma1qg2qStar_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma1qg2qStar_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for q* decay angles (else inactive).
//"""
//        return _pythia8.Sigma1qg2qStar_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma1qg2qStar_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma1qg2qStar_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma1qg2qStar_inFlux(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma1qg2qStar_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma1qg2qStar
//    __del__ = lambda self: None
//Sigma1qg2qStar_swigregister = _pythia8.Sigma1qg2qStar_swigregister
//Sigma1qg2qStar_swigregister(Sigma1qg2qStar)
//
//class Sigma1lgm2lStar(Sigma1Process):
//    """
//A derived class for l gamma -> l^* (excited lepton state).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma1lgm2lStar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma1lgm2lStar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idlIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma1lgm2lStar(idlIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma1lgm2lStar_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma1lgm2lStar_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma1lgm2lStar_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma1lgm2lStar_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for l* decay angles (else inactive).
//"""
//        return _pythia8.Sigma1lgm2lStar_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma1lgm2lStar_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma1lgm2lStar_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma1lgm2lStar_inFlux(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma1lgm2lStar_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma1lgm2lStar
//    __del__ = lambda self: None
//Sigma1lgm2lStar_swigregister = _pythia8.Sigma1lgm2lStar_swigregister
//Sigma1lgm2lStar_swigregister(Sigma1lgm2lStar)
//
//class Sigma2qq2qStarq(Sigma2Process):
//    """
//A derived class for q q' -> q^* q' (excited quark state).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qq2qStarq, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qq2qStarq, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idqIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qq2qStarq(idqIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qq2qStarq_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qq2qStarq_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2qq2qStarq_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qq2qStarq_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for q* decay angles (else inactive).
//"""
//        return _pythia8.Sigma2qq2qStarq_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qq2qStarq_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qq2qStarq_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qq2qStarq_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qq2qStarq_id3Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qq2qStarq
//    __del__ = lambda self: None
//Sigma2qq2qStarq_swigregister = _pythia8.Sigma2qq2qStarq_swigregister
//Sigma2qq2qStarq_swigregister(Sigma2qq2qStarq)
//
//class Sigma2qqbar2lStarlbar(Sigma2Process):
//    """
//A derived class for q qbar -> l^* lbar (excited lepton state).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2lStarlbar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2lStarlbar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idlIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qqbar2lStarlbar(idlIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qqbar2lStarlbar_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qqbar2lStarlbar_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2qqbar2lStarlbar_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qqbar2lStarlbar_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for l* decay angles (else inactive).
//"""
//        return _pythia8.Sigma2qqbar2lStarlbar_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qqbar2lStarlbar_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2lStarlbar_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2lStarlbar_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2lStarlbar_id3Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2lStarlbar
//    __del__ = lambda self: None
//Sigma2qqbar2lStarlbar_swigregister = _pythia8.Sigma2qqbar2lStarlbar_swigregister
//Sigma2qqbar2lStarlbar_swigregister(Sigma2qqbar2lStarlbar)
//
//class Sigma2qqbar2lStarlStarBar(Sigma2Process):
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2lStarlStarBar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2lStarlStarBar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idlIn):
//        this = _pythia8.new_Sigma2qqbar2lStarlStarBar(idlIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        return _pythia8.Sigma2qqbar2lStarlStarBar_initProc(self)
//
//    def sigmaKin(self):
//        return _pythia8.Sigma2qqbar2lStarlStarBar_sigmaKin(self)
//
//    def sigmaHat(self):
//        return _pythia8.Sigma2qqbar2lStarlStarBar_sigmaHat(self)
//
//    def setIdColAcol(self):
//        return _pythia8.Sigma2qqbar2lStarlStarBar_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        return _pythia8.Sigma2qqbar2lStarlStarBar_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        return _pythia8.Sigma2qqbar2lStarlStarBar_name(self)
//
//    def code(self):
//        return _pythia8.Sigma2qqbar2lStarlStarBar_code(self)
//
//    def inFlux(self):
//        return _pythia8.Sigma2qqbar2lStarlStarBar_inFlux(self)
//
//    def id3Mass(self):
//        return _pythia8.Sigma2qqbar2lStarlStarBar_id3Mass(self)
//
//    def id4Mass(self):
//        return _pythia8.Sigma2qqbar2lStarlStarBar_id4Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2lStarlStarBar
//    __del__ = lambda self: None
//Sigma2qqbar2lStarlStarBar_swigregister = _pythia8.Sigma2qqbar2lStarlStarBar_swigregister
//Sigma2qqbar2lStarlStarBar_swigregister(Sigma2qqbar2lStarlStarBar)
//
//class Sigma2QCqq2qq(Sigma2Process):
//    """
//A derived class for q q -> q q (quark contact interactions).
//Based on, Sigma2qq2qq (QCD).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2QCqq2qq, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2QCqq2qq, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2QCqq2qq()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2QCqq2qq_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2QCqq2qq_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2QCqq2qq_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2QCqq2qq_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2QCqq2qq_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2QCqq2qq_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2QCqq2qq_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2QCqq2qq
//    __del__ = lambda self: None
//Sigma2QCqq2qq_swigregister = _pythia8.Sigma2QCqq2qq_swigregister
//Sigma2QCqq2qq_swigregister(Sigma2QCqq2qq)
//
//class Sigma2QCqqbar2qqbar(Sigma2Process):
//    """
//A derived class for q qbar -> q' qbar' (quark contact interactions).
//Based on, Sigma2qqbar2qqbarNew(QCD).
//Note: This process give the same contributions for q == q' and q != q'.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2QCqqbar2qqbar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2QCqqbar2qqbar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2QCqqbar2qqbar()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2QCqqbar2qqbar_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2QCqqbar2qqbar_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2QCqqbar2qqbar_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2QCqqbar2qqbar_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2QCqqbar2qqbar_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2QCqqbar2qqbar_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2QCqqbar2qqbar_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2QCqqbar2qqbar
//    __del__ = lambda self: None
//Sigma2QCqqbar2qqbar_swigregister = _pythia8.Sigma2QCqqbar2qqbar_swigregister
//Sigma2QCqqbar2qqbar_swigregister(Sigma2QCqqbar2qqbar)
//
//class Sigma2QCffbar2llbar(Sigma2Process):
//    """
//A derived class for f fbar -> l lbar
//(contact interactions).
//Does not include t-channel contributions relevant for e^+e^- to e^+e^-
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2QCffbar2llbar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2QCffbar2llbar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idIn, codeIn):
//        """
//Constructor: bool Graviton  = true, to use LED graviton settings.
//"""
//        this = _pythia8.new_Sigma2QCffbar2llbar(idIn, codeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2QCffbar2llbar_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section;
//first step when inflavours unknown.
//"""
//        return _pythia8.Sigma2QCffbar2llbar_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat); second step for given inflavours.
//"""
//        return _pythia8.Sigma2QCffbar2llbar_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2QCffbar2llbar_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2QCffbar2llbar_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2QCffbar2llbar_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2QCffbar2llbar_inFlux(self)
//
//    def isSChannel(self):
//        """
//"""
//        return _pythia8.Sigma2QCffbar2llbar_isSChannel(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2QCffbar2llbar
//    __del__ = lambda self: None
//Sigma2QCffbar2llbar_swigregister = _pythia8.Sigma2QCffbar2llbar_swigregister
//Sigma2QCffbar2llbar_swigregister(Sigma2QCffbar2llbar)
//
//class Sigma1ffbar2Zp2XX(Sigma1Process):
//    """
//A derived class for f fbar' -> Zprime -> X X. (Zprime a.k.a. DMmed(s=1).)
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma1ffbar2Zp2XX, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma1ffbar2Zp2XX, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma1ffbar2Zp2XX()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma1ffbar2Zp2XX_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma1ffbar2Zp2XX_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma1ffbar2Zp2XX_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma1ffbar2Zp2XX_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma1ffbar2Zp2XX_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2Zp2XX_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2Zp2XX_inFlux(self)
//
//    def resonanceA(self):
//        return _pythia8.Sigma1ffbar2Zp2XX_resonanceA(self)
//
//    def isSChannel(self):
//        """
//Zprime
//"""
//        return _pythia8.Sigma1ffbar2Zp2XX_isSChannel(self)
//
//    def gmZmode(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2Zp2XX_gmZmode(self)
//    __swig_destroy__ = _pythia8.delete_Sigma1ffbar2Zp2XX
//    __del__ = lambda self: None
//Sigma1ffbar2Zp2XX_swigregister = _pythia8.Sigma1ffbar2Zp2XX_swigregister
//Sigma1ffbar2Zp2XX_swigregister(Sigma1ffbar2Zp2XX)
//
//class Sigma2qqbar2Zpg2XXj(Sigma2Process):
//    """
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2Zpg2XXj, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2Zpg2XXj, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qqbar2Zpg2XXj()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qqbar2Zpg2XXj_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qqbar2Zpg2XXj_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2qqbar2Zpg2XXj_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qqbar2Zpg2XXj_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qqbar2Zpg2XXj_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2Zpg2XXj_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2Zpg2XXj_inFlux(self)
//
//    def resonanceA(self):
//        return _pythia8.Sigma2qqbar2Zpg2XXj_resonanceA(self)
//
//    def id3Mass(self):
//        """
//Zprime
//"""
//        return _pythia8.Sigma2qqbar2Zpg2XXj_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2Zpg2XXj_id4Mass(self)
//
//    def isSChannel(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2Zpg2XXj_isSChannel(self)
//
//    def gmZmode(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2Zpg2XXj_gmZmode(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2Zpg2XXj
//    __del__ = lambda self: None
//Sigma2qqbar2Zpg2XXj_swigregister = _pythia8.Sigma2qqbar2Zpg2XXj_swigregister
//Sigma2qqbar2Zpg2XXj_swigregister(Sigma2qqbar2Zpg2XXj)
//
//class Sigma2qg2Zpq2XXj(Sigma2qqbar2Zpg2XXj):
//    """
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2qqbar2Zpg2XXj]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qg2Zpq2XXj, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2qqbar2Zpg2XXj]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qg2Zpq2XXj, name)
//
//    def __init__(self, *args, **kwargs):
//        """
//Constructor.
//"""
//        raise AttributeError("No constructor defined")
//    __repr__ = _swig_repr
//    __swig_destroy__ = _pythia8.delete_Sigma2qg2Zpq2XXj
//    __del__ = lambda self: None
//Sigma2qg2Zpq2XXj_swigregister = _pythia8.Sigma2qg2Zpq2XXj_swigregister
//Sigma2qg2Zpq2XXj_swigregister(Sigma2qg2Zpq2XXj)
//
//class Sigma2ffbar2ZpH(Sigma2Process):
//    """
//A derived class for f fbar' -> Zprime H, Zprime -> X X.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbar2ZpH, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbar2ZpH, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ffbar2ZpH()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2ffbar2ZpH_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2ffbar2ZpH_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2ffbar2ZpH_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ffbar2ZpH_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ffbar2ZpH_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2ZpH_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2ZpH_inFlux(self)
//
//    def isSChannel(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2ZpH_isSChannel(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2ZpH_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2ZpH_id4Mass(self)
//
//    def resonanceA(self):
//        return _pythia8.Sigma2ffbar2ZpH_resonanceA(self)
//
//    def gmZmode(self):
//        """
//Zprime
//"""
//        return _pythia8.Sigma2ffbar2ZpH_gmZmode(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbar2ZpH
//    __del__ = lambda self: None
//Sigma2ffbar2ZpH_swigregister = _pythia8.Sigma2ffbar2ZpH_swigregister
//Sigma2ffbar2ZpH_swigregister(Sigma2ffbar2ZpH)
//
//class Sigma1gg2S2XX(Sigma1Process):
//    """
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma1gg2S2XX, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma1gg2S2XX, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma1gg2S2XX()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma1gg2S2XX_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma1gg2S2XX_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma1gg2S2XX_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma1gg2S2XX_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma1gg2S2XX_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma1gg2S2XX_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma1gg2S2XX_inFlux(self)
//
//    def resonanceA(self):
//        return _pythia8.Sigma1gg2S2XX_resonanceA(self)
//
//    def isSChannel(self):
//        """
//scalar mediator
//"""
//        return _pythia8.Sigma1gg2S2XX_isSChannel(self)
//    __swig_destroy__ = _pythia8.delete_Sigma1gg2S2XX
//    __del__ = lambda self: None
//Sigma1gg2S2XX_swigregister = _pythia8.Sigma1gg2S2XX_swigregister
//Sigma1gg2S2XX_swigregister(Sigma1gg2S2XX)
//
//class Sigma2gg2Sg2XXj(Sigma2Process):
//    """
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2gg2Sg2XXj, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2gg2Sg2XXj, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2gg2Sg2XXj()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2gg2Sg2XXj_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2gg2Sg2XXj_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2gg2Sg2XXj_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2gg2Sg2XXj_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2gg2Sg2XXj_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2gg2Sg2XXj_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2gg2Sg2XXj_inFlux(self)
//
//    def resonanceA(self):
//        return _pythia8.Sigma2gg2Sg2XXj_resonanceA(self)
//
//    def isSChannel(self):
//        """
//scalar mediator
//"""
//        return _pythia8.Sigma2gg2Sg2XXj_isSChannel(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2gg2Sg2XXj_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2gg2Sg2XXj_id4Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2gg2Sg2XXj
//    __del__ = lambda self: None
//Sigma2gg2Sg2XXj_swigregister = _pythia8.Sigma2gg2Sg2XXj_swigregister
//Sigma2gg2Sg2XXj_swigregister(Sigma2gg2Sg2XXj)
//
//class Sigma2qg2Sq2XXj(Sigma2gg2Sg2XXj):
//    """
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2gg2Sg2XXj]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qg2Sq2XXj, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2gg2Sg2XXj]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qg2Sq2XXj, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qg2Sq2XXj()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qg2Sq2XXj_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qg2Sq2XXj_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qg2Sq2XXj_inFlux(self)
//
//    def isSChannel(self):
//        """
//"""
//        return _pythia8.Sigma2qg2Sq2XXj_isSChannel(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qg2Sq2XXj
//    __del__ = lambda self: None
//Sigma2qg2Sq2XXj_swigregister = _pythia8.Sigma2qg2Sq2XXj_swigregister
//Sigma2qg2Sq2XXj_swigregister(Sigma2qg2Sq2XXj)
//
//class Sigma2qg2qgamma(Sigma2Process):
//    """
//A derived class for q g -> q gamma (q = u, d, s, c, b).
//Use massless approximation also for Q since no alternative.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qg2qgamma, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qg2qgamma, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qg2qgamma()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qg2qgamma_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qg2qgamma_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qg2qgamma_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qg2qgamma_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qg2qgamma_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qg2qgamma_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qg2qgamma
//    __del__ = lambda self: None
//Sigma2qg2qgamma_swigregister = _pythia8.Sigma2qg2qgamma_swigregister
//Sigma2qg2qgamma_swigregister(Sigma2qg2qgamma)
//
//class Sigma2qqbar2ggamma(Sigma2Process):
//    """
//A derived class for q qbar -> g gamma.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2ggamma, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2ggamma, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qqbar2ggamma()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qqbar2ggamma_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qqbar2ggamma_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qqbar2ggamma_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qqbar2ggamma_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2ggamma_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2ggamma_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2ggamma
//    __del__ = lambda self: None
//Sigma2qqbar2ggamma_swigregister = _pythia8.Sigma2qqbar2ggamma_swigregister
//Sigma2qqbar2ggamma_swigregister(Sigma2qqbar2ggamma)
//
//class Sigma2gg2ggamma(Sigma2Process):
//    """
//A derived class for g g -> g gamma.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2gg2ggamma, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2gg2ggamma, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2gg2ggamma()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2gg2ggamma_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2gg2ggamma_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2gg2ggamma_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2gg2ggamma_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2gg2ggamma_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2gg2ggamma_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2gg2ggamma_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2gg2ggamma
//    __del__ = lambda self: None
//Sigma2gg2ggamma_swigregister = _pythia8.Sigma2gg2ggamma_swigregister
//Sigma2gg2ggamma_swigregister(Sigma2gg2ggamma)
//
//class Sigma2ffbar2gammagamma(Sigma2Process):
//    """
//A derived class for f fbar -> gamma gamma.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbar2gammagamma, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbar2gammagamma, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ffbar2gammagamma()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2ffbar2gammagamma_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2ffbar2gammagamma_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ffbar2gammagamma_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ffbar2gammagamma_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2gammagamma_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2gammagamma_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbar2gammagamma
//    __del__ = lambda self: None
//Sigma2ffbar2gammagamma_swigregister = _pythia8.Sigma2ffbar2gammagamma_swigregister
//Sigma2ffbar2gammagamma_swigregister(Sigma2ffbar2gammagamma)
//
//class Sigma2gg2gammagamma(Sigma2Process):
//    """
//A derived class for g g -> gamma gamma.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2gg2gammagamma, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2gg2gammagamma, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2gg2gammagamma()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2gg2gammagamma_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2gg2gammagamma_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2gg2gammagamma_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2gg2gammagamma_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2gg2gammagamma_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2gg2gammagamma_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2gg2gammagamma_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2gg2gammagamma
//    __del__ = lambda self: None
//Sigma2gg2gammagamma_swigregister = _pythia8.Sigma2gg2gammagamma_swigregister
//Sigma2gg2gammagamma_swigregister(Sigma2gg2gammagamma)
//
//class Sigma2ff2fftgmZ(Sigma2Process):
//    """
//A derived class for f f' -> f f' via t-channel gamma*/Z0 exchange.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ff2fftgmZ, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ff2fftgmZ, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ff2fftgmZ()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2ff2fftgmZ_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2ff2fftgmZ_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2ff2fftgmZ_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ff2fftgmZ_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ff2fftgmZ_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ff2fftgmZ_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ff2fftgmZ_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ff2fftgmZ
//    __del__ = lambda self: None
//Sigma2ff2fftgmZ_swigregister = _pythia8.Sigma2ff2fftgmZ_swigregister
//Sigma2ff2fftgmZ_swigregister(Sigma2ff2fftgmZ)
//
//class Sigma2ff2fftW(Sigma2Process):
//    """
//A derived class for f_1 f_2 -> f_3 f_4 via t-channel W+- exchange.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ff2fftW, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ff2fftW, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ff2fftW()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2ff2fftW_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2ff2fftW_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2ff2fftW_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ff2fftW_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ff2fftW_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ff2fftW_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ff2fftW_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ff2fftW
//    __del__ = lambda self: None
//Sigma2ff2fftW_swigregister = _pythia8.Sigma2ff2fftW_swigregister
//Sigma2ff2fftW_swigregister(Sigma2ff2fftW)
//
//class Sigma2qq2QqtW(Sigma2Process):
//    """
//A derived class for q q' -> Q q" via t-channel W+- exchange.
//Related to Sigma2ff2fftW class, but with massive matrix elements.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qq2QqtW, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qq2QqtW, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idIn, codeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qq2QqtW(idIn, codeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qq2QqtW_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qq2QqtW_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2qq2QqtW_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qq2QqtW_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for W decay angles in top decay (else inactive).
//"""
//        return _pythia8.Sigma2qq2QqtW_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qq2QqtW_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qq2QqtW_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qq2QqtW_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qq2QqtW_id3Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qq2QqtW
//    __del__ = lambda self: None
//Sigma2qq2QqtW_swigregister = _pythia8.Sigma2qq2QqtW_swigregister
//Sigma2qq2QqtW_swigregister(Sigma2qq2QqtW)
//
//class Sigma1ffbar2gmZ(Sigma1Process):
//    """
//A derived class for f fbar -> gamma*/Z0.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma1ffbar2gmZ, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma1ffbar2gmZ, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma1ffbar2gmZ()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma1ffbar2gmZ_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma1ffbar2gmZ_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma1ffbar2gmZ_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma1ffbar2gmZ_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for Z decay angle.
//"""
//        return _pythia8.Sigma1ffbar2gmZ_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma1ffbar2gmZ_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2gmZ_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2gmZ_inFlux(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2gmZ_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma1ffbar2gmZ
//    __del__ = lambda self: None
//Sigma1ffbar2gmZ_swigregister = _pythia8.Sigma1ffbar2gmZ_swigregister
//Sigma1ffbar2gmZ_swigregister(Sigma1ffbar2gmZ)
//
//class Sigma1ffbar2W(Sigma1Process):
//    """
//A derived class for f fbar' -> W+-.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma1ffbar2W, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma1ffbar2W, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma1ffbar2W()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma1ffbar2W_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma1ffbar2W_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma1ffbar2W_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma1ffbar2W_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for W decay angle.
//"""
//        return _pythia8.Sigma1ffbar2W_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma1ffbar2W_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2W_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2W_inFlux(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2W_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma1ffbar2W
//    __del__ = lambda self: None
//Sigma1ffbar2W_swigregister = _pythia8.Sigma1ffbar2W_swigregister
//Sigma1ffbar2W_swigregister(Sigma1ffbar2W)
//
//class Sigma2ffbar2ffbarsgm(Sigma2Process):
//    """
//A derived class for f fbar -> gamma* -> f' fbar', summed over light f'.
//Allows pT-ordered evolution for multiparton interactions.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbar2ffbarsgm, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbar2ffbarsgm, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ffbar2ffbarsgm()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2ffbar2ffbarsgm_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2ffbar2ffbarsgm_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ffbar2ffbarsgm_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ffbar2ffbarsgm_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2ffbarsgm_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2ffbarsgm_inFlux(self)
//
//    def isSChannel(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2ffbarsgm_isSChannel(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbar2ffbarsgm
//    __del__ = lambda self: None
//Sigma2ffbar2ffbarsgm_swigregister = _pythia8.Sigma2ffbar2ffbarsgm_swigregister
//Sigma2ffbar2ffbarsgm_swigregister(Sigma2ffbar2ffbarsgm)
//
//class Sigma2ffbar2ffbarsgmZ(Sigma2Process):
//    """
//A derived class for f fbar -> gamma*/Z0 -> f' fbar', summed over light f.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbar2ffbarsgmZ, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbar2ffbarsgmZ, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ffbar2ffbarsgmZ()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2ffbar2ffbarsgmZ_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2ffbar2ffbarsgmZ_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2ffbar2ffbarsgmZ_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ffbar2ffbarsgmZ_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ffbar2ffbarsgmZ_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2ffbarsgmZ_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2ffbarsgmZ_inFlux(self)
//
//    def isSChannel(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2ffbarsgmZ_isSChannel(self)
//
//    def idSChannel(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2ffbarsgmZ_idSChannel(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2ffbarsgmZ_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbar2ffbarsgmZ
//    __del__ = lambda self: None
//Sigma2ffbar2ffbarsgmZ_swigregister = _pythia8.Sigma2ffbar2ffbarsgmZ_swigregister
//Sigma2ffbar2ffbarsgmZ_swigregister(Sigma2ffbar2ffbarsgmZ)
//
//class Sigma2ffbar2ffbarsW(Sigma2Process):
//    """
//A derived class for f_1 fbar_2 -> W+- -> f_3 fbar_4, summed over light f.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbar2ffbarsW, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbar2ffbarsW, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ffbar2ffbarsW()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2ffbar2ffbarsW_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2ffbar2ffbarsW_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2ffbar2ffbarsW_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ffbar2ffbarsW_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ffbar2ffbarsW_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2ffbarsW_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2ffbarsW_inFlux(self)
//
//    def isSChannel(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2ffbarsW_isSChannel(self)
//
//    def idSChannel(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2ffbarsW_idSChannel(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2ffbarsW_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbar2ffbarsW
//    __del__ = lambda self: None
//Sigma2ffbar2ffbarsW_swigregister = _pythia8.Sigma2ffbar2ffbarsW_swigregister
//Sigma2ffbar2ffbarsW_swigregister(Sigma2ffbar2ffbarsW)
//
//class Sigma2ffbar2FFbarsgmZ(Sigma2Process):
//    """
//A derived class for f fbar -> gamma*/Z0 -> F Fbar, for one heavy F.
//Allows pT cuts as for other 2 -> 2 processes.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbar2FFbarsgmZ, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbar2FFbarsgmZ, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idIn, codeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ffbar2FFbarsgmZ(idIn, codeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2ffbar2FFbarsgmZ_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2ffbar2FFbarsgmZ_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2ffbar2FFbarsgmZ_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ffbar2FFbarsgmZ_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for W decay angles in top decay (else inactive).
//"""
//        return _pythia8.Sigma2ffbar2FFbarsgmZ_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ffbar2FFbarsgmZ_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2FFbarsgmZ_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2FFbarsgmZ_inFlux(self)
//
//    def isSChannel(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2FFbarsgmZ_isSChannel(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2FFbarsgmZ_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2FFbarsgmZ_id4Mass(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2FFbarsgmZ_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbar2FFbarsgmZ
//    __del__ = lambda self: None
//Sigma2ffbar2FFbarsgmZ_swigregister = _pythia8.Sigma2ffbar2FFbarsgmZ_swigregister
//Sigma2ffbar2FFbarsgmZ_swigregister(Sigma2ffbar2FFbarsgmZ)
//
//class Sigma2ffbar2FfbarsW(Sigma2Process):
//    """
//A derived class for f fbar' -> W+- -> F fbar", for one or two heavy F.
//Allows pT cuts as for other 2 -> 2 processes.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbar2FfbarsW, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbar2FfbarsW, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idIn, idIn2, codeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ffbar2FfbarsW(idIn, idIn2, codeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2ffbar2FfbarsW_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2ffbar2FfbarsW_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2ffbar2FfbarsW_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ffbar2FfbarsW_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for W decay angles in top decay (else inactive).
//"""
//        return _pythia8.Sigma2ffbar2FfbarsW_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ffbar2FfbarsW_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2FfbarsW_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2FfbarsW_inFlux(self)
//
//    def isSChannel(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2FfbarsW_isSChannel(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2FfbarsW_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2FfbarsW_id4Mass(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2FfbarsW_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbar2FfbarsW
//    __del__ = lambda self: None
//Sigma2ffbar2FfbarsW_swigregister = _pythia8.Sigma2ffbar2FfbarsW_swigregister
//Sigma2ffbar2FfbarsW_swigregister(Sigma2ffbar2FfbarsW)
//
//class Sigma2ffbargmZWgmZW(Sigma2Process):
//    """
//An intermediate class for f fbar -> gamma*/Z0/W+- gamma*/Z0/W-+.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbargmZWgmZW, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbargmZWgmZW, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ffbargmZWgmZW()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbargmZWgmZW
//    __del__ = lambda self: None
//Sigma2ffbargmZWgmZW_swigregister = _pythia8.Sigma2ffbargmZWgmZW_swigregister
//Sigma2ffbargmZWgmZW_swigregister(Sigma2ffbargmZWgmZW)
//
//class Sigma2ffbar2gmZgmZ(Sigma2ffbargmZWgmZW):
//    """
//A derived class for f fbar -> gamma*/Z0 gamma*/Z0.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2ffbargmZWgmZW]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbar2gmZgmZ, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2ffbargmZWgmZW]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbar2gmZgmZ, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ffbar2gmZgmZ()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2ffbar2gmZgmZ_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2ffbar2gmZgmZ_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2ffbar2gmZgmZ_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ffbar2gmZgmZ_setIdColAcol(self)
//
//    def weightDecayFlav(self, process):
//        """
//Evaluate weight for simultaneous flavour choices.
//"""
//        return _pythia8.Sigma2ffbar2gmZgmZ_weightDecayFlav(self, process)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for decay angles of the two gamma*/Z0.
//"""
//        return _pythia8.Sigma2ffbar2gmZgmZ_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ffbar2gmZgmZ_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2gmZgmZ_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2gmZgmZ_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2gmZgmZ_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2gmZgmZ_id4Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbar2gmZgmZ
//    __del__ = lambda self: None
//Sigma2ffbar2gmZgmZ_swigregister = _pythia8.Sigma2ffbar2gmZgmZ_swigregister
//Sigma2ffbar2gmZgmZ_swigregister(Sigma2ffbar2gmZgmZ)
//
//class Sigma2ffbar2ZW(Sigma2ffbargmZWgmZW):
//    """
//A derived class for f fbar' -> Z0 W+-. (Here pure Z0, unfortunately.)
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2ffbargmZWgmZW]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbar2ZW, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2ffbargmZWgmZW]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbar2ZW, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ffbar2ZW()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2ffbar2ZW_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2ffbar2ZW_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2ffbar2ZW_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ffbar2ZW_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for Z0 and W+- decay angles.
//"""
//        return _pythia8.Sigma2ffbar2ZW_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ffbar2ZW_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2ZW_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2ZW_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2ZW_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2ZW_id4Mass(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2ZW_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbar2ZW
//    __del__ = lambda self: None
//Sigma2ffbar2ZW_swigregister = _pythia8.Sigma2ffbar2ZW_swigregister
//Sigma2ffbar2ZW_swigregister(Sigma2ffbar2ZW)
//
//class Sigma2ffbar2WW(Sigma2ffbargmZWgmZW):
//    """
//A derived class for f fbar -> W+ W-.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2ffbargmZWgmZW]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbar2WW, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2ffbargmZWgmZW]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbar2WW, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ffbar2WW()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2ffbar2WW_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2ffbar2WW_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2ffbar2WW_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ffbar2WW_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for W+ and W- decay angles.
//"""
//        return _pythia8.Sigma2ffbar2WW_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ffbar2WW_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2WW_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2WW_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2WW_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2WW_id4Mass(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2WW_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbar2WW
//    __del__ = lambda self: None
//Sigma2ffbar2WW_swigregister = _pythia8.Sigma2ffbar2WW_swigregister
//Sigma2ffbar2WW_swigregister(Sigma2ffbar2WW)
//
//class Sigma2ffbargmZggm(Sigma2Process):
//    """
//An intermediate class for f fbar -> gamma*/Z0 g/gamma and permutations.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbargmZggm, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbargmZggm, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ffbargmZggm()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2ffbargmZggm_initProc(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for gamma&/Z0 decay angle.
//"""
//        return _pythia8.Sigma2ffbargmZggm_weightDecay(self, process, iResBeg, iResEnd)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbargmZggm
//    __del__ = lambda self: None
//Sigma2ffbargmZggm_swigregister = _pythia8.Sigma2ffbargmZggm_swigregister
//Sigma2ffbargmZggm_swigregister(Sigma2ffbargmZggm)
//
//class Sigma2qqbar2gmZg(Sigma2ffbargmZggm):
//    """
//A derived class for q qbar -> gamma*/Z0 g.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2ffbargmZggm]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2gmZg, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2ffbargmZggm]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2gmZg, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qqbar2gmZg()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qqbar2gmZg_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qqbar2gmZg_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qqbar2gmZg_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qqbar2gmZg_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2gmZg_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2gmZg_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2gmZg_id3Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2gmZg
//    __del__ = lambda self: None
//Sigma2qqbar2gmZg_swigregister = _pythia8.Sigma2qqbar2gmZg_swigregister
//Sigma2qqbar2gmZg_swigregister(Sigma2qqbar2gmZg)
//
//class Sigma2qg2gmZq(Sigma2ffbargmZggm):
//    """
//A derived class for q g -> gamma*/Z0 q.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2ffbargmZggm]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qg2gmZq, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2ffbargmZggm]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qg2gmZq, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qg2gmZq()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qg2gmZq_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qg2gmZq_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qg2gmZq_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qg2gmZq_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qg2gmZq_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qg2gmZq_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qg2gmZq_id3Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qg2gmZq
//    __del__ = lambda self: None
//Sigma2qg2gmZq_swigregister = _pythia8.Sigma2qg2gmZq_swigregister
//Sigma2qg2gmZq_swigregister(Sigma2qg2gmZq)
//
//class Sigma2ffbar2gmZgm(Sigma2ffbargmZggm):
//    """
//A derived class for f fbar' -> gamma*/Z0 gamma.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2ffbargmZggm]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbar2gmZgm, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2ffbargmZggm]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbar2gmZgm, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ffbar2gmZgm()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2ffbar2gmZgm_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2ffbar2gmZgm_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ffbar2gmZgm_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ffbar2gmZgm_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2gmZgm_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2gmZgm_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2gmZgm_id3Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbar2gmZgm
//    __del__ = lambda self: None
//Sigma2ffbar2gmZgm_swigregister = _pythia8.Sigma2ffbar2gmZgm_swigregister
//Sigma2ffbar2gmZgm_swigregister(Sigma2ffbar2gmZgm)
//
//class Sigma2fgm2gmZf(Sigma2ffbargmZggm):
//    """
//A derived class for f gamma -> gamma*/Z0 f.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2ffbargmZggm]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2fgm2gmZf, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2ffbargmZggm]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2fgm2gmZf, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2fgm2gmZf()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2fgm2gmZf_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2fgm2gmZf_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2fgm2gmZf_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2fgm2gmZf_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2fgm2gmZf_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2fgm2gmZf_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2fgm2gmZf_id3Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2fgm2gmZf
//    __del__ = lambda self: None
//Sigma2fgm2gmZf_swigregister = _pythia8.Sigma2fgm2gmZf_swigregister
//Sigma2fgm2gmZf_swigregister(Sigma2fgm2gmZf)
//
//class Sigma2ffbarWggm(Sigma2Process):
//    """
//An intermediate class for f fbar -> W+- g/gamma and permutations.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbarWggm, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbarWggm, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ffbarWggm()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for gamma&/Z0 decay angle.
//"""
//        return _pythia8.Sigma2ffbarWggm_weightDecay(self, process, iResBeg, iResEnd)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbarWggm
//    __del__ = lambda self: None
//Sigma2ffbarWggm_swigregister = _pythia8.Sigma2ffbarWggm_swigregister
//Sigma2ffbarWggm_swigregister(Sigma2ffbarWggm)
//
//class Sigma2qqbar2Wg(Sigma2ffbarWggm):
//    """
//A derived class for q qbar' -> W+- g.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2ffbarWggm]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2Wg, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2ffbarWggm]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2Wg, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qqbar2Wg()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qqbar2Wg_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qqbar2Wg_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qqbar2Wg_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qqbar2Wg_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qqbar2Wg_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2Wg_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2Wg_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2Wg_id3Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2Wg
//    __del__ = lambda self: None
//Sigma2qqbar2Wg_swigregister = _pythia8.Sigma2qqbar2Wg_swigregister
//Sigma2qqbar2Wg_swigregister(Sigma2qqbar2Wg)
//
//class Sigma2qg2Wq(Sigma2ffbarWggm):
//    """
//A derived class for q g -> W+- q'.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2ffbarWggm]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qg2Wq, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2ffbarWggm]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qg2Wq, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qg2Wq()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qg2Wq_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qg2Wq_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qg2Wq_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qg2Wq_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qg2Wq_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qg2Wq_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qg2Wq_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qg2Wq_id3Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qg2Wq
//    __del__ = lambda self: None
//Sigma2qg2Wq_swigregister = _pythia8.Sigma2qg2Wq_swigregister
//Sigma2qg2Wq_swigregister(Sigma2qg2Wq)
//
//class Sigma2ffbar2Wgm(Sigma2ffbarWggm):
//    """
//A derived class for f fbar' -> W+- gamma.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2ffbarWggm]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbar2Wgm, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2ffbarWggm]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbar2Wgm, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ffbar2Wgm()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2ffbar2Wgm_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2ffbar2Wgm_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2ffbar2Wgm_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ffbar2Wgm_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ffbar2Wgm_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2Wgm_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2Wgm_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2Wgm_id3Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbar2Wgm
//    __del__ = lambda self: None
//Sigma2ffbar2Wgm_swigregister = _pythia8.Sigma2ffbar2Wgm_swigregister
//Sigma2ffbar2Wgm_swigregister(Sigma2ffbar2Wgm)
//
//class Sigma2fgm2Wf(Sigma2ffbarWggm):
//    """
//A derived class for f gamma -> W+- f'.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2ffbarWggm]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2fgm2Wf, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2ffbarWggm]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2fgm2Wf, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2fgm2Wf()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2fgm2Wf_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2fgm2Wf_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2fgm2Wf_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2fgm2Wf_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2fgm2Wf_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2fgm2Wf_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2fgm2Wf_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2fgm2Wf_id3Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2fgm2Wf
//    __del__ = lambda self: None
//Sigma2fgm2Wf_swigregister = _pythia8.Sigma2fgm2Wf_swigregister
//Sigma2fgm2Wf_swigregister(Sigma2fgm2Wf)
//
//class Sigma2gmgm2ffbar(Sigma2Process):
//    """
//A derived class for gamma gamma -> f fbar.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2gmgm2ffbar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2gmgm2ffbar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idIn, codeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2gmgm2ffbar(idIn, codeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2gmgm2ffbar_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2gmgm2ffbar_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2gmgm2ffbar_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2gmgm2ffbar_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2gmgm2ffbar_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2gmgm2ffbar_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2gmgm2ffbar_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2gmgm2ffbar_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2gmgm2ffbar_id4Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2gmgm2ffbar
//    __del__ = lambda self: None
//Sigma2gmgm2ffbar_swigregister = _pythia8.Sigma2gmgm2ffbar_swigregister
//Sigma2gmgm2ffbar_swigregister(Sigma2gmgm2ffbar)
//
//class Sigma2ggm2qqbar(Sigma2Process):
//    """
//A derived class for g gamma -> q qbar (q = u, d, s, c, b).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ggm2qqbar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ggm2qqbar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ggm2qqbar(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2ggm2qqbar_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2ggm2qqbar_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2ggm2qqbar_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ggm2qqbar_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ggm2qqbar_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ggm2qqbar_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ggm2qqbar_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ggm2qqbar_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ggm2qqbar_id4Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ggm2qqbar
//    __del__ = lambda self: None
//Sigma2ggm2qqbar_swigregister = _pythia8.Sigma2ggm2qqbar_swigregister
//Sigma2ggm2qqbar_swigregister(Sigma2ggm2qqbar)
//
//class Sigma2qgm2qg(Sigma2Process):
//    """
//A derived class for q gamma -> q g (q = u, d, s, c, b).
//Use massless approximation also for Q since no alternative.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qgm2qg, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qgm2qg, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qgm2qg(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process according to in flux.
//"""
//        return _pythia8.Sigma2qgm2qg_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qgm2qg_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qgm2qg_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qgm2qg_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qgm2qg_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qgm2qg_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qgm2qg_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qgm2qg
//    __del__ = lambda self: None
//Sigma2qgm2qg_swigregister = _pythia8.Sigma2qgm2qg_swigregister
//Sigma2qgm2qg_swigregister(Sigma2qgm2qg)
//
//class Sigma2qgm2qgm(Sigma2Process):
//    """
//A derived class for q gamma -> q gamma (q = u, d, s, c, b).
//Use massless approximation also for Q since no alternative.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qgm2qgm, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qgm2qgm, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qgm2qgm(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qgm2qgm_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qgm2qgm_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qgm2qgm_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qgm2qgm_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qgm2qgm_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qgm2qgm_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qgm2qgm_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qgm2qgm
//    __del__ = lambda self: None
//Sigma2qgm2qgm_swigregister = _pythia8.Sigma2qgm2qgm_swigregister
//Sigma2qgm2qgm_swigregister(Sigma2qgm2qgm)
//
//class Sigma1gg2GravitonStar(Sigma1Process):
//    """
//A derived class for g g -> G^* (excited graviton state).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma1gg2GravitonStar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma1gg2GravitonStar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma1gg2GravitonStar()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma1gg2GravitonStar_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma1gg2GravitonStar_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma1gg2GravitonStar_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma1gg2GravitonStar_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for G* decay angle.
//"""
//        return _pythia8.Sigma1gg2GravitonStar_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma1gg2GravitonStar_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma1gg2GravitonStar_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma1gg2GravitonStar_inFlux(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma1gg2GravitonStar_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma1gg2GravitonStar
//    __del__ = lambda self: None
//Sigma1gg2GravitonStar_swigregister = _pythia8.Sigma1gg2GravitonStar_swigregister
//Sigma1gg2GravitonStar_swigregister(Sigma1gg2GravitonStar)
//
//class Sigma1ffbar2GravitonStar(Sigma1Process):
//    """
//A derived class for f fbar -> G^* (excited graviton state).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma1ffbar2GravitonStar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma1ffbar2GravitonStar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma1ffbar2GravitonStar()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma1ffbar2GravitonStar_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma1ffbar2GravitonStar_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma1ffbar2GravitonStar_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma1ffbar2GravitonStar_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for G* decay angle.
//"""
//        return _pythia8.Sigma1ffbar2GravitonStar_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma1ffbar2GravitonStar_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2GravitonStar_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2GravitonStar_inFlux(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2GravitonStar_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma1ffbar2GravitonStar
//    __del__ = lambda self: None
//Sigma1ffbar2GravitonStar_swigregister = _pythia8.Sigma1ffbar2GravitonStar_swigregister
//Sigma1ffbar2GravitonStar_swigregister(Sigma1ffbar2GravitonStar)
//
//class Sigma1qqbar2KKgluonStar(Sigma1Process):
//    """
//A derived class for q qbar -> g^*/KK-gluon^* (excited kk-gluon state).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma1qqbar2KKgluonStar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma1qqbar2KKgluonStar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma1qqbar2KKgluonStar()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma1qqbar2KKgluonStar_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma1qqbar2KKgluonStar_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma1qqbar2KKgluonStar_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma1qqbar2KKgluonStar_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for g* decay angle.
//"""
//        return _pythia8.Sigma1qqbar2KKgluonStar_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma1qqbar2KKgluonStar_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma1qqbar2KKgluonStar_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma1qqbar2KKgluonStar_inFlux(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma1qqbar2KKgluonStar_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma1qqbar2KKgluonStar
//    __del__ = lambda self: None
//Sigma1qqbar2KKgluonStar_swigregister = _pythia8.Sigma1qqbar2KKgluonStar_swigregister
//Sigma1qqbar2KKgluonStar_swigregister(Sigma1qqbar2KKgluonStar)
//
//class Sigma2gg2GravitonStarg(Sigma2Process):
//    """
//A derived class for g g -> G^* g (excited graviton state).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2gg2GravitonStarg, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2gg2GravitonStarg, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2gg2GravitonStarg()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2gg2GravitonStarg_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2gg2GravitonStarg_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2gg2GravitonStarg_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2gg2GravitonStarg_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight: currently isotropic (except secondary top decay)..
//"""
//        return _pythia8.Sigma2gg2GravitonStarg_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2gg2GravitonStarg_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2gg2GravitonStarg_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2gg2GravitonStarg_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2gg2GravitonStarg_id3Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2gg2GravitonStarg
//    __del__ = lambda self: None
//Sigma2gg2GravitonStarg_swigregister = _pythia8.Sigma2gg2GravitonStarg_swigregister
//Sigma2gg2GravitonStarg_swigregister(Sigma2gg2GravitonStarg)
//
//class Sigma2qg2GravitonStarq(Sigma2Process):
//    """
//A derived class for q g -> G^* q (excited graviton state).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qg2GravitonStarq, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qg2GravitonStarq, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qg2GravitonStarq()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qg2GravitonStarq_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qg2GravitonStarq_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2qg2GravitonStarq_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qg2GravitonStarq_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight: currently isotropic (except secondary top decay).
//"""
//        return _pythia8.Sigma2qg2GravitonStarq_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qg2GravitonStarq_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qg2GravitonStarq_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qg2GravitonStarq_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qg2GravitonStarq_id3Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qg2GravitonStarq
//    __del__ = lambda self: None
//Sigma2qg2GravitonStarq_swigregister = _pythia8.Sigma2qg2GravitonStarq_swigregister
//Sigma2qg2GravitonStarq_swigregister(Sigma2qg2GravitonStarq)
//
//class Sigma2qqbar2GravitonStarg(Sigma2Process):
//    """
//A derived class for q qbar -> G^* g (excited graviton state).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2GravitonStarg, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2GravitonStarg, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qqbar2GravitonStarg()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qqbar2GravitonStarg_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qqbar2GravitonStarg_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2qqbar2GravitonStarg_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qqbar2GravitonStarg_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight: currently isotropic (except secondary top decay).
//"""
//        return _pythia8.Sigma2qqbar2GravitonStarg_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qqbar2GravitonStarg_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2GravitonStarg_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2GravitonStarg_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2GravitonStarg_id3Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2GravitonStarg
//    __del__ = lambda self: None
//Sigma2qqbar2GravitonStarg_swigregister = _pythia8.Sigma2qqbar2GravitonStarg_swigregister
//Sigma2qqbar2GravitonStarg_swigregister(Sigma2qqbar2GravitonStarg)
//
//class Sigma2ffbar2TEVffbar(Sigma2Process):
//    """
//NOAM: A derived class for, f fbar -> (gamma/Z)_KKTower -> F Fbar,
//for one heavy F.
//Process provided by N. Hod et al. and is described in arXiv:XXXX.YYYY
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbar2TEVffbar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbar2TEVffbar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idIn, codeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ffbar2TEVffbar(idIn, codeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2ffbar2TEVffbar_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2ffbar2TEVffbar_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2ffbar2TEVffbar_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ffbar2TEVffbar_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for W decay angles in top decay (else inactive).
//"""
//        return _pythia8.Sigma2ffbar2TEVffbar_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ffbar2TEVffbar_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2TEVffbar_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2TEVffbar_inFlux(self)
//
//    def isSChannel(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2TEVffbar_isSChannel(self)
//
//    def idSChannel(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2TEVffbar_idSChannel(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2TEVffbar_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2TEVffbar_id4Mass(self)
//
//    def resonanceA(self, *args):
//        """
//Add phase-space sampling also around the Z_KK resonance.
//"""
//        return _pythia8.Sigma2ffbar2TEVffbar_resonanceA(self, *args)
//
//    def resonanceB(self, *args):
//        """
//"""
//        return _pythia8.Sigma2ffbar2TEVffbar_resonanceB(self, *args)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbar2TEVffbar
//    __del__ = lambda self: None
//Sigma2ffbar2TEVffbar_swigregister = _pythia8.Sigma2ffbar2TEVffbar_swigregister
//Sigma2ffbar2TEVffbar_swigregister(Sigma2ffbar2TEVffbar)
//
//class Sigma2gg2LEDUnparticleg(Sigma2Process):
//    """
//A derived class for g g -> U/G g (real graviton emission in
//large extra dimensions or unparticle emission).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2gg2LEDUnparticleg, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2gg2LEDUnparticleg, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, Graviton):
//        """
//Constructor: bool Graviton  = true, to use LED graviton settings.
//"""
//        this = _pythia8.new_Sigma2gg2LEDUnparticleg(Graviton)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2gg2LEDUnparticleg_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section;
//first step when inflavours unknown.
//"""
//        return _pythia8.Sigma2gg2LEDUnparticleg_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat); second step for given inflavours.
//"""
//        return _pythia8.Sigma2gg2LEDUnparticleg_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2gg2LEDUnparticleg_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2gg2LEDUnparticleg_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2gg2LEDUnparticleg_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2gg2LEDUnparticleg_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2gg2LEDUnparticleg_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2gg2LEDUnparticleg_id4Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2gg2LEDUnparticleg
//    __del__ = lambda self: None
//Sigma2gg2LEDUnparticleg_swigregister = _pythia8.Sigma2gg2LEDUnparticleg_swigregister
//Sigma2gg2LEDUnparticleg_swigregister(Sigma2gg2LEDUnparticleg)
//
//class Sigma2qg2LEDUnparticleq(Sigma2Process):
//    """
//A derived class for q g -> U/G q (real graviton emission in
//large extra dimensions or unparticle emission).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qg2LEDUnparticleq, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qg2LEDUnparticleq, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, Graviton):
//        """
//Constructor: bool Graviton  = true, to use LED graviton settings.
//"""
//        this = _pythia8.new_Sigma2qg2LEDUnparticleq(Graviton)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qg2LEDUnparticleq_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section;
//first step when inflavours unknown.
//"""
//        return _pythia8.Sigma2qg2LEDUnparticleq_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat); second step for given inflavours.
//"""
//        return _pythia8.Sigma2qg2LEDUnparticleq_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qg2LEDUnparticleq_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qg2LEDUnparticleq_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qg2LEDUnparticleq_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qg2LEDUnparticleq_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qg2LEDUnparticleq_id3Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qg2LEDUnparticleq
//    __del__ = lambda self: None
//Sigma2qg2LEDUnparticleq_swigregister = _pythia8.Sigma2qg2LEDUnparticleq_swigregister
//Sigma2qg2LEDUnparticleq_swigregister(Sigma2qg2LEDUnparticleq)
//
//class Sigma2qqbar2LEDUnparticleg(Sigma2Process):
//    """
//A derived class for q qbar -> U/G g (real graviton emission in
//large extra dimensions or unparticle emission).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2LEDUnparticleg, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2LEDUnparticleg, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, Graviton):
//        """
//Constructor: bool Graviton  = true, to use LED graviton settings.
//"""
//        this = _pythia8.new_Sigma2qqbar2LEDUnparticleg(Graviton)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qqbar2LEDUnparticleg_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section;
//first step when inflavours unknown.
//"""
//        return _pythia8.Sigma2qqbar2LEDUnparticleg_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat); second step for given inflavours.
//"""
//        return _pythia8.Sigma2qqbar2LEDUnparticleg_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qqbar2LEDUnparticleg_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qqbar2LEDUnparticleg_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2LEDUnparticleg_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2LEDUnparticleg_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2LEDUnparticleg_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2LEDUnparticleg_id4Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2LEDUnparticleg
//    __del__ = lambda self: None
//Sigma2qqbar2LEDUnparticleg_swigregister = _pythia8.Sigma2qqbar2LEDUnparticleg_swigregister
//Sigma2qqbar2LEDUnparticleg_swigregister(Sigma2qqbar2LEDUnparticleg)
//
//class Sigma2ffbar2LEDUnparticleZ(Sigma2Process):
//    """
//A derived class for f fbar -> U/G Z (real graviton emission in
//large extra dimensions or unparticle emission).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbar2LEDUnparticleZ, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbar2LEDUnparticleZ, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, Graviton):
//        """
//Constructor: bool Graviton  = true, to use LED graviton settings.
//"""
//        this = _pythia8.new_Sigma2ffbar2LEDUnparticleZ(Graviton)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2ffbar2LEDUnparticleZ_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section;
//first step when inflavours unknown.
//"""
//        return _pythia8.Sigma2ffbar2LEDUnparticleZ_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat); second step for given inflavours.
//"""
//        return _pythia8.Sigma2ffbar2LEDUnparticleZ_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ffbar2LEDUnparticleZ_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ffbar2LEDUnparticleZ_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2LEDUnparticleZ_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2LEDUnparticleZ_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2LEDUnparticleZ_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2LEDUnparticleZ_id4Mass(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2LEDUnparticleZ_resonanceA(self)
//
//    def gmZmode(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2LEDUnparticleZ_gmZmode(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbar2LEDUnparticleZ
//    __del__ = lambda self: None
//Sigma2ffbar2LEDUnparticleZ_swigregister = _pythia8.Sigma2ffbar2LEDUnparticleZ_swigregister
//Sigma2ffbar2LEDUnparticleZ_swigregister(Sigma2ffbar2LEDUnparticleZ)
//
//class Sigma2ffbar2LEDUnparticlegamma(Sigma2Process):
//    """
//A derived class for f fbar -> U/G gamma (real graviton emission in
//large extra dimensions or unparticle emission).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbar2LEDUnparticlegamma, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbar2LEDUnparticlegamma, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, Graviton):
//        """
//Constructor: bool Graviton  = true, to use LED graviton settings.
//"""
//        this = _pythia8.new_Sigma2ffbar2LEDUnparticlegamma(Graviton)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2ffbar2LEDUnparticlegamma_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section;
//first step when inflavours unknown.
//"""
//        return _pythia8.Sigma2ffbar2LEDUnparticlegamma_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat); second step for given inflavours.
//"""
//        return _pythia8.Sigma2ffbar2LEDUnparticlegamma_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ffbar2LEDUnparticlegamma_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ffbar2LEDUnparticlegamma_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2LEDUnparticlegamma_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2LEDUnparticlegamma_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2LEDUnparticlegamma_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2LEDUnparticlegamma_id4Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbar2LEDUnparticlegamma
//    __del__ = lambda self: None
//Sigma2ffbar2LEDUnparticlegamma_swigregister = _pythia8.Sigma2ffbar2LEDUnparticlegamma_swigregister
//Sigma2ffbar2LEDUnparticlegamma_swigregister(Sigma2ffbar2LEDUnparticlegamma)
//
//class Sigma2ffbar2LEDgammagamma(Sigma2Process):
//    """
//A derived class for f fbar -> (LED G*/U*) -> gamma gamma
//(virtual graviton/unparticle exchange).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbar2LEDgammagamma, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbar2LEDgammagamma, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, Graviton):
//        """
//Constructor: bool Graviton  = true, to use LED graviton settings.
//"""
//        this = _pythia8.new_Sigma2ffbar2LEDgammagamma(Graviton)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2ffbar2LEDgammagamma_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section;
//first step when inflavours unknown.
//"""
//        return _pythia8.Sigma2ffbar2LEDgammagamma_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat); second step for given inflavours.
//"""
//        return _pythia8.Sigma2ffbar2LEDgammagamma_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ffbar2LEDgammagamma_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ffbar2LEDgammagamma_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2LEDgammagamma_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2LEDgammagamma_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbar2LEDgammagamma
//    __del__ = lambda self: None
//Sigma2ffbar2LEDgammagamma_swigregister = _pythia8.Sigma2ffbar2LEDgammagamma_swigregister
//Sigma2ffbar2LEDgammagamma_swigregister(Sigma2ffbar2LEDgammagamma)
//
//class Sigma2gg2LEDgammagamma(Sigma2Process):
//    """
//A derived class for g g -> (LED G*/U*) -> gamma gamma
//(virtual graviton/unparticle exchange).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2gg2LEDgammagamma, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2gg2LEDgammagamma, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, Graviton):
//        """
//Constructor: bool Graviton  = true, to use LED graviton settings.
//"""
//        this = _pythia8.new_Sigma2gg2LEDgammagamma(Graviton)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2gg2LEDgammagamma_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section;
//first step when inflavours unknown.
//"""
//        return _pythia8.Sigma2gg2LEDgammagamma_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat); second step for given inflavours.
//"""
//        return _pythia8.Sigma2gg2LEDgammagamma_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2gg2LEDgammagamma_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2gg2LEDgammagamma_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2gg2LEDgammagamma_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2gg2LEDgammagamma_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2gg2LEDgammagamma
//    __del__ = lambda self: None
//Sigma2gg2LEDgammagamma_swigregister = _pythia8.Sigma2gg2LEDgammagamma_swigregister
//Sigma2gg2LEDgammagamma_swigregister(Sigma2gg2LEDgammagamma)
//
//class Sigma2ffbar2LEDllbar(Sigma2Process):
//    """
//A derived class for f fbar -> (LED G*/U*) -> l lbar
//(virtual graviton/unparticle exchange).
//Does not include t-channel contributions relevant for e^+e^- to e^+e^-
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbar2LEDllbar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbar2LEDllbar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, Graviton):
//        """
//Constructor: bool Graviton  = true, to use LED graviton settings.
//"""
//        this = _pythia8.new_Sigma2ffbar2LEDllbar(Graviton)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2ffbar2LEDllbar_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section;
//first step when inflavours unknown.
//"""
//        return _pythia8.Sigma2ffbar2LEDllbar_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat); second step for given inflavours.
//"""
//        return _pythia8.Sigma2ffbar2LEDllbar_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ffbar2LEDllbar_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ffbar2LEDllbar_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2LEDllbar_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2LEDllbar_inFlux(self)
//
//    def isSChannel(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2LEDllbar_isSChannel(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbar2LEDllbar
//    __del__ = lambda self: None
//Sigma2ffbar2LEDllbar_swigregister = _pythia8.Sigma2ffbar2LEDllbar_swigregister
//Sigma2ffbar2LEDllbar_swigregister(Sigma2ffbar2LEDllbar)
//
//class Sigma2gg2LEDllbar(Sigma2Process):
//    """
//A derived class for g g -> (LED G*/U*) -> l lbar
//(virtual graviton/unparticle exchange).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2gg2LEDllbar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2gg2LEDllbar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, Graviton):
//        """
//Constructor: bool Graviton  = true, to use LED graviton settings.
//"""
//        this = _pythia8.new_Sigma2gg2LEDllbar(Graviton)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2gg2LEDllbar_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section;
//first step when inflavours unknown.
//"""
//        return _pythia8.Sigma2gg2LEDllbar_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat); second step for given inflavours.
//"""
//        return _pythia8.Sigma2gg2LEDllbar_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2gg2LEDllbar_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2gg2LEDllbar_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2gg2LEDllbar_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2gg2LEDllbar_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2gg2LEDllbar
//    __del__ = lambda self: None
//Sigma2gg2LEDllbar_swigregister = _pythia8.Sigma2gg2LEDllbar_swigregister
//Sigma2gg2LEDllbar_swigregister(Sigma2gg2LEDllbar)
//
//class Sigma2gg2LEDgg(Sigma2Process):
//    """
//A derived class for g g -> (LED G*) -> g g.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2gg2LEDgg, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2gg2LEDgg, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2gg2LEDgg()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2gg2LEDgg_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2gg2LEDgg_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2gg2LEDgg_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2gg2LEDgg_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2gg2LEDgg_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2gg2LEDgg_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2gg2LEDgg_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2gg2LEDgg
//    __del__ = lambda self: None
//Sigma2gg2LEDgg_swigregister = _pythia8.Sigma2gg2LEDgg_swigregister
//Sigma2gg2LEDgg_swigregister(Sigma2gg2LEDgg)
//
//class Sigma2gg2LEDqqbar(Sigma2Process):
//    """
//A derived class for g g -> (LED G*) -> q qbar.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2gg2LEDqqbar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2gg2LEDqqbar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2gg2LEDqqbar()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2gg2LEDqqbar_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2gg2LEDqqbar_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2gg2LEDqqbar_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2gg2LEDqqbar_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2gg2LEDqqbar_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2gg2LEDqqbar_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2gg2LEDqqbar_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2gg2LEDqqbar
//    __del__ = lambda self: None
//Sigma2gg2LEDqqbar_swigregister = _pythia8.Sigma2gg2LEDqqbar_swigregister
//Sigma2gg2LEDqqbar_swigregister(Sigma2gg2LEDqqbar)
//
//class Sigma2qg2LEDqg(Sigma2Process):
//    """
//A derived class for q g -> (LED G*) -> q g.
//Use massless approximation also for Q since no alternative.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qg2LEDqg, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qg2LEDqg, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qg2LEDqg()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qg2LEDqg_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qg2LEDqg_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qg2LEDqg_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qg2LEDqg_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qg2LEDqg_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qg2LEDqg_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qg2LEDqg_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qg2LEDqg
//    __del__ = lambda self: None
//Sigma2qg2LEDqg_swigregister = _pythia8.Sigma2qg2LEDqg_swigregister
//Sigma2qg2LEDqg_swigregister(Sigma2qg2LEDqg)
//
//class Sigma2qq2LEDqq(Sigma2Process):
//    """
//A derived class for q q(bar)' -> (LED G*) -> q q(bar)'.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qq2LEDqq, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qq2LEDqq, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qq2LEDqq()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qq2LEDqq_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qq2LEDqq_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qq2LEDqq_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qq2LEDqq_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qq2LEDqq_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qq2LEDqq_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qq2LEDqq_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qq2LEDqq
//    __del__ = lambda self: None
//Sigma2qq2LEDqq_swigregister = _pythia8.Sigma2qq2LEDqq_swigregister
//Sigma2qq2LEDqq_swigregister(Sigma2qq2LEDqq)
//
//class Sigma2qqbar2LEDgg(Sigma2Process):
//    """
//A derived class for q qbar -> (LED G*) -> g g.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2LEDgg, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2LEDgg, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qqbar2LEDgg()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qqbar2LEDgg_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qqbar2LEDgg_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qqbar2LEDgg_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qqbar2LEDgg_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qqbar2LEDgg_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2LEDgg_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2LEDgg_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2LEDgg
//    __del__ = lambda self: None
//Sigma2qqbar2LEDgg_swigregister = _pythia8.Sigma2qqbar2LEDgg_swigregister
//Sigma2qqbar2LEDgg_swigregister(Sigma2qqbar2LEDgg)
//
//class Sigma2qqbar2LEDqqbarNew(Sigma2Process):
//    """
//A derived class for q qbar -> (LED G*) -> q' qbar'.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2LEDqqbarNew, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2LEDqqbarNew, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qqbar2LEDqqbarNew()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qqbar2LEDqqbarNew_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qqbar2LEDqqbarNew_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qqbar2LEDqqbarNew_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qqbar2LEDqqbarNew_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qqbar2LEDqqbarNew_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2LEDqqbarNew_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2LEDqqbarNew_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2LEDqqbarNew
//    __del__ = lambda self: None
//Sigma2qqbar2LEDqqbarNew_swigregister = _pythia8.Sigma2qqbar2LEDqqbarNew_swigregister
//Sigma2qqbar2LEDqqbarNew_swigregister(Sigma2qqbar2LEDqqbarNew)
//
//class Sigma2gg2qGqGbar(Sigma2Process):
//    """
//A derived class for g g -> qG qGbar (generic quark of spin 0, 1/2 or 1).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2gg2qGqGbar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2gg2qGqGbar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2gg2qGqGbar(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2gg2qGqGbar_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2gg2qGqGbar_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2gg2qGqGbar_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2gg2qGqGbar_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2gg2qGqGbar_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2gg2qGqGbar_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2gg2qGqGbar_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2gg2qGqGbar_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2gg2qGqGbar_id4Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2gg2qGqGbar
//    __del__ = lambda self: None
//Sigma2gg2qGqGbar_swigregister = _pythia8.Sigma2gg2qGqGbar_swigregister
//Sigma2gg2qGqGbar_swigregister(Sigma2gg2qGqGbar)
//
//class Sigma2qqbar2qGqGbar(Sigma2Process):
//    """
//A derived class for q qbar -> qG qGbar (generic quark of spin 0, 1/2 or 1).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2qGqGbar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2qGqGbar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qqbar2qGqGbar(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qqbar2qGqGbar_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qqbar2qGqGbar_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2qqbar2qGqGbar_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qqbar2qGqGbar_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qqbar2qGqGbar_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2qGqGbar_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2qGqGbar_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2qGqGbar_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2qGqGbar_id4Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2qGqGbar
//    __del__ = lambda self: None
//Sigma2qqbar2qGqGbar_swigregister = _pythia8.Sigma2qqbar2qGqGbar_swigregister
//Sigma2qqbar2qGqGbar_swigregister(Sigma2qqbar2qGqGbar)
//
//class Sigma2ffbar2fGfGbar(Sigma2Process):
//    """
//A derived class for f fbar -> fG fGbar (generic spin 0, 1/2 or 1 particle)
//via gamma^*/Z^* s-channel exchange. Still under development!! ??
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbar2fGfGbar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbar2fGfGbar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ffbar2fGfGbar(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2ffbar2fGfGbar_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2ffbar2fGfGbar_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2ffbar2fGfGbar_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ffbar2fGfGbar_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ffbar2fGfGbar_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2fGfGbar_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2fGfGbar_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2fGfGbar_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2fGfGbar_id4Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbar2fGfGbar
//    __del__ = lambda self: None
//Sigma2ffbar2fGfGbar_swigregister = _pythia8.Sigma2ffbar2fGfGbar_swigregister
//Sigma2ffbar2fGfGbar_swigregister(Sigma2ffbar2fGfGbar)
//
//class Sigma1ffbar2Zv(Sigma1Process):
//    """
//A derived class for f fbar -> Zv, where Zv couples both to the SM and
//to a hidden sector. Primitive coupling structure.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma1ffbar2Zv, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma1ffbar2Zv, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma1ffbar2Zv()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma1ffbar2Zv_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma1ffbar2Zv_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat) for given inflavours.
//"""
//        return _pythia8.Sigma1ffbar2Zv_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma1ffbar2Zv_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for decay angles.
//"""
//        return _pythia8.Sigma1ffbar2Zv_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma1ffbar2Zv_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2Zv_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2Zv_inFlux(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2Zv_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma1ffbar2Zv
//    __del__ = lambda self: None
//Sigma1ffbar2Zv_swigregister = _pythia8.Sigma1ffbar2Zv_swigregister
//Sigma1ffbar2Zv_swigregister(Sigma1ffbar2Zv)
//
//class Sigma1ffbar2H(Sigma1Process):
//    """
//A derived class for f fbar -> H0 (SM), H1, H2 or A3 (BSM).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma1ffbar2H, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma1ffbar2H, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, higgsTypeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma1ffbar2H(higgsTypeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma1ffbar2H_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma1ffbar2H_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma1ffbar2H_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma1ffbar2H_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for decay angles.
//"""
//        return _pythia8.Sigma1ffbar2H_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma1ffbar2H_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2H_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2H_inFlux(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2H_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma1ffbar2H
//    __del__ = lambda self: None
//Sigma1ffbar2H_swigregister = _pythia8.Sigma1ffbar2H_swigregister
//Sigma1ffbar2H_swigregister(Sigma1ffbar2H)
//
//class Sigma1gg2H(Sigma1Process):
//    """
//A derived class for g g -> H0 (SM), H1, H2 or A3 (BSM).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma1gg2H, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma1gg2H, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, higgsTypeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma1gg2H(higgsTypeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma1gg2H_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma1gg2H_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma1gg2H_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma1gg2H_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for decay angles.
//"""
//        return _pythia8.Sigma1gg2H_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma1gg2H_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma1gg2H_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma1gg2H_inFlux(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma1gg2H_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma1gg2H
//    __del__ = lambda self: None
//Sigma1gg2H_swigregister = _pythia8.Sigma1gg2H_swigregister
//Sigma1gg2H_swigregister(Sigma1gg2H)
//
//class Sigma1gmgm2H(Sigma1Process):
//    """
//A derived class for gamma gamma -> H0 (SM Higgs), H1, H2 or A3 (BSM Higgs).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma1gmgm2H, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma1gmgm2H, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, higgsTypeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma1gmgm2H(higgsTypeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma1gmgm2H_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma1gmgm2H_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma1gmgm2H_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma1gmgm2H_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for decay angles.
//"""
//        return _pythia8.Sigma1gmgm2H_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma1gmgm2H_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma1gmgm2H_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma1gmgm2H_inFlux(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma1gmgm2H_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma1gmgm2H
//    __del__ = lambda self: None
//Sigma1gmgm2H_swigregister = _pythia8.Sigma1gmgm2H_swigregister
//Sigma1gmgm2H_swigregister(Sigma1gmgm2H)
//
//class Sigma2ffbar2HZ(Sigma2Process):
//    """
//A derived class for f fbar -> H Z0.
//(H can be H0 SM or H1, H2, A3 from BSM).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbar2HZ, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbar2HZ, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, higgsTypeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ffbar2HZ(higgsTypeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2ffbar2HZ_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2ffbar2HZ_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2ffbar2HZ_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ffbar2HZ_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for decay angles.
//"""
//        return _pythia8.Sigma2ffbar2HZ_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ffbar2HZ_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HZ_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HZ_inFlux(self)
//
//    def isSChannel(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HZ_isSChannel(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HZ_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HZ_id4Mass(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HZ_resonanceA(self)
//
//    def gmZmode(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HZ_gmZmode(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbar2HZ
//    __del__ = lambda self: None
//Sigma2ffbar2HZ_swigregister = _pythia8.Sigma2ffbar2HZ_swigregister
//Sigma2ffbar2HZ_swigregister(Sigma2ffbar2HZ)
//
//class Sigma2ffbar2HW(Sigma2Process):
//    """
//A derived class for f fbar -> H W+- (Standard Model Higgs).
//(H can be H0 SM or H1, H2, A3 from BSM).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbar2HW, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbar2HW, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, higgsTypeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ffbar2HW(higgsTypeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2ffbar2HW_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2ffbar2HW_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2ffbar2HW_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ffbar2HW_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for decay angles.
//"""
//        return _pythia8.Sigma2ffbar2HW_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ffbar2HW_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HW_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HW_inFlux(self)
//
//    def isSChannel(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HW_isSChannel(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HW_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HW_id4Mass(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HW_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbar2HW
//    __del__ = lambda self: None
//Sigma2ffbar2HW_swigregister = _pythia8.Sigma2ffbar2HW_swigregister
//Sigma2ffbar2HW_swigregister(Sigma2ffbar2HW)
//
//class Sigma3ff2HfftZZ(Sigma3Process):
//    """
//A derived class for f f' -> H f f' (Z0 Z0 fusion of SM or BSM Higgs).
//(H can be H0 SM or H1, H2, A3 from BSM).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma3Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma3ff2HfftZZ, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma3Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma3ff2HfftZZ, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, higgsTypeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma3ff2HfftZZ(higgsTypeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma3ff2HfftZZ_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma3ff2HfftZZ_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma3ff2HfftZZ_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma3ff2HfftZZ_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for decay angles.
//"""
//        return _pythia8.Sigma3ff2HfftZZ_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma3ff2HfftZZ_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma3ff2HfftZZ_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma3ff2HfftZZ_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma3ff2HfftZZ_id3Mass(self)
//
//    def idTchan1(self):
//        """
//Instructions for 3-body phase space with t-channel propagators.
//"""
//        return _pythia8.Sigma3ff2HfftZZ_idTchan1(self)
//
//    def idTchan2(self):
//        """
//"""
//        return _pythia8.Sigma3ff2HfftZZ_idTchan2(self)
//
//    def tChanFracPow1(self):
//        """
//"""
//        return _pythia8.Sigma3ff2HfftZZ_tChanFracPow1(self)
//
//    def tChanFracPow2(self):
//        """
//"""
//        return _pythia8.Sigma3ff2HfftZZ_tChanFracPow2(self)
//
//    def useMirrorWeight(self):
//        """
//"""
//        return _pythia8.Sigma3ff2HfftZZ_useMirrorWeight(self)
//    __swig_destroy__ = _pythia8.delete_Sigma3ff2HfftZZ
//    __del__ = lambda self: None
//Sigma3ff2HfftZZ_swigregister = _pythia8.Sigma3ff2HfftZZ_swigregister
//Sigma3ff2HfftZZ_swigregister(Sigma3ff2HfftZZ)
//
//class Sigma3ff2HfftWW(Sigma3Process):
//    """
//A derived class for f_1 f_2 -> H f_3 f_4 (W+ W- fusion of SM or BSM Higgs).
//(H can be H0 SM or H1, H2, A3 from BSM).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma3Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma3ff2HfftWW, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma3Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma3ff2HfftWW, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, higgsTypeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma3ff2HfftWW(higgsTypeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma3ff2HfftWW_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma3ff2HfftWW_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma3ff2HfftWW_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma3ff2HfftWW_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for decay angles.
//"""
//        return _pythia8.Sigma3ff2HfftWW_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma3ff2HfftWW_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma3ff2HfftWW_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma3ff2HfftWW_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma3ff2HfftWW_id3Mass(self)
//
//    def idTchan1(self):
//        """
//Instructions for 3-body phase space with t-channel propagators.
//"""
//        return _pythia8.Sigma3ff2HfftWW_idTchan1(self)
//
//    def idTchan2(self):
//        """
//"""
//        return _pythia8.Sigma3ff2HfftWW_idTchan2(self)
//
//    def tChanFracPow1(self):
//        """
//"""
//        return _pythia8.Sigma3ff2HfftWW_tChanFracPow1(self)
//
//    def tChanFracPow2(self):
//        """
//"""
//        return _pythia8.Sigma3ff2HfftWW_tChanFracPow2(self)
//
//    def useMirrorWeight(self):
//        """
//"""
//        return _pythia8.Sigma3ff2HfftWW_useMirrorWeight(self)
//    __swig_destroy__ = _pythia8.delete_Sigma3ff2HfftWW
//    __del__ = lambda self: None
//Sigma3ff2HfftWW_swigregister = _pythia8.Sigma3ff2HfftWW_swigregister
//Sigma3ff2HfftWW_swigregister(Sigma3ff2HfftWW)
//
//class Sigma3gg2HQQbar(Sigma3Process):
//    """
//A derived class for g g -> H Q Qbar (Q Qbar fusion of SM or BSM Higgs).
//(H can be H0 SM or H1, H2, A3 from BSM).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma3Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma3gg2HQQbar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma3Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma3gg2HQQbar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idIn, higgsTypeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma3gg2HQQbar(idIn, higgsTypeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma3gg2HQQbar_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma3gg2HQQbar_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma3gg2HQQbar_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma3gg2HQQbar_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for decay angles.
//"""
//        return _pythia8.Sigma3gg2HQQbar_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma3gg2HQQbar_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma3gg2HQQbar_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma3gg2HQQbar_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma3gg2HQQbar_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma3gg2HQQbar_id4Mass(self)
//
//    def id5Mass(self):
//        """
//"""
//        return _pythia8.Sigma3gg2HQQbar_id5Mass(self)
//
//    def idTchan1(self):
//        """
//Instructions for 3-body phase space with t-channel propagators.
//"""
//        return _pythia8.Sigma3gg2HQQbar_idTchan1(self)
//
//    def idTchan2(self):
//        """
//"""
//        return _pythia8.Sigma3gg2HQQbar_idTchan2(self)
//
//    def tChanFracPow1(self):
//        """
//"""
//        return _pythia8.Sigma3gg2HQQbar_tChanFracPow1(self)
//
//    def tChanFracPow2(self):
//        """
//"""
//        return _pythia8.Sigma3gg2HQQbar_tChanFracPow2(self)
//
//    def useMirrorWeight(self):
//        """
//"""
//        return _pythia8.Sigma3gg2HQQbar_useMirrorWeight(self)
//    __swig_destroy__ = _pythia8.delete_Sigma3gg2HQQbar
//    __del__ = lambda self: None
//Sigma3gg2HQQbar_swigregister = _pythia8.Sigma3gg2HQQbar_swigregister
//Sigma3gg2HQQbar_swigregister(Sigma3gg2HQQbar)
//
//class Sigma3qqbar2HQQbar(Sigma3Process):
//    """
//A derived class for q qbar -> H Q Qbar (Q Qbar fusion of SM or BSM Higgs).
//(H can be H0 SM or H1, H2, A3 from BSM).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma3Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma3qqbar2HQQbar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma3Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma3qqbar2HQQbar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idIn, higgsTypeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma3qqbar2HQQbar(idIn, higgsTypeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma3qqbar2HQQbar_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma3qqbar2HQQbar_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma3qqbar2HQQbar_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma3qqbar2HQQbar_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for decay angles.
//"""
//        return _pythia8.Sigma3qqbar2HQQbar_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma3qqbar2HQQbar_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma3qqbar2HQQbar_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma3qqbar2HQQbar_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma3qqbar2HQQbar_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma3qqbar2HQQbar_id4Mass(self)
//
//    def id5Mass(self):
//        """
//"""
//        return _pythia8.Sigma3qqbar2HQQbar_id5Mass(self)
//
//    def idTchan1(self):
//        """
//Instructions for 3-body phase space with t-channel propagators.
//"""
//        return _pythia8.Sigma3qqbar2HQQbar_idTchan1(self)
//
//    def idTchan2(self):
//        """
//"""
//        return _pythia8.Sigma3qqbar2HQQbar_idTchan2(self)
//
//    def tChanFracPow1(self):
//        """
//"""
//        return _pythia8.Sigma3qqbar2HQQbar_tChanFracPow1(self)
//
//    def tChanFracPow2(self):
//        """
//"""
//        return _pythia8.Sigma3qqbar2HQQbar_tChanFracPow2(self)
//
//    def useMirrorWeight(self):
//        """
//"""
//        return _pythia8.Sigma3qqbar2HQQbar_useMirrorWeight(self)
//    __swig_destroy__ = _pythia8.delete_Sigma3qqbar2HQQbar
//    __del__ = lambda self: None
//Sigma3qqbar2HQQbar_swigregister = _pythia8.Sigma3qqbar2HQQbar_swigregister
//Sigma3qqbar2HQQbar_swigregister(Sigma3qqbar2HQQbar)
//
//class Sigma2qg2Hq(Sigma2Process):
//    """
//A derived class for q g -> H q (SM or BSM Higgs).
//(H can be H0 SM or H1, H2, A3 from BSM).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qg2Hq, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qg2Hq, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idIn, higgsTypeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qg2Hq(idIn, higgsTypeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qg2Hq_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qg2Hq_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2qg2Hq_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qg2Hq_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for decay angles.
//"""
//        return _pythia8.Sigma2qg2Hq_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qg2Hq_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qg2Hq_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qg2Hq_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qg2Hq_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qg2Hq_id4Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qg2Hq
//    __del__ = lambda self: None
//Sigma2qg2Hq_swigregister = _pythia8.Sigma2qg2Hq_swigregister
//Sigma2qg2Hq_swigregister(Sigma2qg2Hq)
//
//class Sigma2gg2Hglt(Sigma2Process):
//    """
//A derived class for g g -> H0 g (SM or BSM Higgs via heavy top loop).
//(H can be H0 SM or H1, H2, A3 from BSM).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2gg2Hglt, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2gg2Hglt, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, higgsTypeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2gg2Hglt(higgsTypeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2gg2Hglt_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2gg2Hglt_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2gg2Hglt_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2gg2Hglt_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for decay angles.
//"""
//        return _pythia8.Sigma2gg2Hglt_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2gg2Hglt_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2gg2Hglt_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2gg2Hglt_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2gg2Hglt_id3Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2gg2Hglt
//    __del__ = lambda self: None
//Sigma2gg2Hglt_swigregister = _pythia8.Sigma2gg2Hglt_swigregister
//Sigma2gg2Hglt_swigregister(Sigma2gg2Hglt)
//
//class Sigma2qg2Hqlt(Sigma2Process):
//    """
//A derived class for q g -> H q (SM or BSM Higgs via heavy top loop).
//(H can be H0 SM or H1, H2, A3 from BSM).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qg2Hqlt, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qg2Hqlt, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, higgsTypeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qg2Hqlt(higgsTypeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qg2Hqlt_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qg2Hqlt_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qg2Hqlt_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qg2Hqlt_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for decay angles.
//"""
//        return _pythia8.Sigma2qg2Hqlt_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qg2Hqlt_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qg2Hqlt_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qg2Hqlt_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qg2Hqlt_id3Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qg2Hqlt
//    __del__ = lambda self: None
//Sigma2qg2Hqlt_swigregister = _pythia8.Sigma2qg2Hqlt_swigregister
//Sigma2qg2Hqlt_swigregister(Sigma2qg2Hqlt)
//
//class Sigma2qqbar2Hglt(Sigma2Process):
//    """
//A derived class for q qbar -> H g (SM or BSM Higgs via heavy top loop).
//(H can be H0 SM or H1, H2, A3 from BSM).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2Hglt, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2Hglt, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, higgsTypeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qqbar2Hglt(higgsTypeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qqbar2Hglt_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qqbar2Hglt_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qqbar2Hglt_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qqbar2Hglt_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for decay angles.
//"""
//        return _pythia8.Sigma2qqbar2Hglt_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qqbar2Hglt_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2Hglt_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2Hglt_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2Hglt_id3Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2Hglt
//    __del__ = lambda self: None
//Sigma2qqbar2Hglt_swigregister = _pythia8.Sigma2qqbar2Hglt_swigregister
//Sigma2qqbar2Hglt_swigregister(Sigma2qqbar2Hglt)
//
//class Sigma1ffbar2Hchg(Sigma1Process):
//    """
//A derived class for f fbar' -> H+-.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma1ffbar2Hchg, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma1ffbar2Hchg, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma1ffbar2Hchg()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma1ffbar2Hchg_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma1ffbar2Hchg_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma1ffbar2Hchg_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma1ffbar2Hchg_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for decay angles.
//"""
//        return _pythia8.Sigma1ffbar2Hchg_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma1ffbar2Hchg_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2Hchg_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2Hchg_inFlux(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2Hchg_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma1ffbar2Hchg
//    __del__ = lambda self: None
//Sigma1ffbar2Hchg_swigregister = _pythia8.Sigma1ffbar2Hchg_swigregister
//Sigma1ffbar2Hchg_swigregister(Sigma1ffbar2Hchg)
//
//class Sigma2qg2Hchgq(Sigma2Process):
//    """
//A derived class for q g -> H+- q'.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qg2Hchgq, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qg2Hchgq, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idIn, codeIn, nameIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qg2Hchgq(idIn, codeIn, nameIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qg2Hchgq_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qg2Hchgq_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2qg2Hchgq_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qg2Hchgq_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for decay angles.
//"""
//        return _pythia8.Sigma2qg2Hchgq_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qg2Hchgq_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qg2Hchgq_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qg2Hchgq_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qg2Hchgq_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qg2Hchgq_id4Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qg2Hchgq
//    __del__ = lambda self: None
//Sigma2qg2Hchgq_swigregister = _pythia8.Sigma2qg2Hchgq_swigregister
//Sigma2qg2Hchgq_swigregister(Sigma2qg2Hchgq)
//
//class Sigma2ffbar2A3H12(Sigma2Process):
//    """
//A derived class for f fbar -> A0(H_3) h0(H_1) or A0(H_3) H0(H_2).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbar2A3H12, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbar2A3H12, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, higgsTypeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ffbar2A3H12(higgsTypeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2ffbar2A3H12_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2ffbar2A3H12_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2ffbar2A3H12_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ffbar2A3H12_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for decay angles.
//"""
//        return _pythia8.Sigma2ffbar2A3H12_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ffbar2A3H12_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2A3H12_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2A3H12_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2A3H12_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2A3H12_id4Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbar2A3H12
//    __del__ = lambda self: None
//Sigma2ffbar2A3H12_swigregister = _pythia8.Sigma2ffbar2A3H12_swigregister
//Sigma2ffbar2A3H12_swigregister(Sigma2ffbar2A3H12)
//
//class Sigma2ffbar2HchgH12(Sigma2Process):
//    """
//A derived class for f fbar -> H+- h0(H_1) or H+- H0(H_2).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbar2HchgH12, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbar2HchgH12, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, higgsTypeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ffbar2HchgH12(higgsTypeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2ffbar2HchgH12_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2ffbar2HchgH12_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2ffbar2HchgH12_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ffbar2HchgH12_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for decay angles.
//"""
//        return _pythia8.Sigma2ffbar2HchgH12_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ffbar2HchgH12_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HchgH12_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HchgH12_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HchgH12_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HchgH12_id4Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbar2HchgH12
//    __del__ = lambda self: None
//Sigma2ffbar2HchgH12_swigregister = _pythia8.Sigma2ffbar2HchgH12_swigregister
//Sigma2ffbar2HchgH12_swigregister(Sigma2ffbar2HchgH12)
//
//class Sigma2ffbar2HposHneg(Sigma2Process):
//    """
//A derived class for f fbar -> H+ H-.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbar2HposHneg, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbar2HposHneg, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ffbar2HposHneg()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2ffbar2HposHneg_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2ffbar2HposHneg_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2ffbar2HposHneg_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ffbar2HposHneg_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for decay angles.
//"""
//        return _pythia8.Sigma2ffbar2HposHneg_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ffbar2HposHneg_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HposHneg_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HposHneg_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HposHneg_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HposHneg_id4Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbar2HposHneg
//    __del__ = lambda self: None
//Sigma2ffbar2HposHneg_swigregister = _pythia8.Sigma2ffbar2HposHneg_swigregister
//Sigma2ffbar2HposHneg_swigregister(Sigma2ffbar2HposHneg)
//
//class Sigma1ffbar2ZRight(Sigma1Process):
//    """
//A derived class for f fbar -> Z_R^0 (righthanded gauge boson).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma1ffbar2ZRight, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma1ffbar2ZRight, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma1ffbar2ZRight()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma1ffbar2ZRight_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma1ffbar2ZRight_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma1ffbar2ZRight_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma1ffbar2ZRight_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for G* decay angle.
//"""
//        return _pythia8.Sigma1ffbar2ZRight_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma1ffbar2ZRight_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2ZRight_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2ZRight_inFlux(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2ZRight_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma1ffbar2ZRight
//    __del__ = lambda self: None
//Sigma1ffbar2ZRight_swigregister = _pythia8.Sigma1ffbar2ZRight_swigregister
//Sigma1ffbar2ZRight_swigregister(Sigma1ffbar2ZRight)
//
//class Sigma1ffbar2WRight(Sigma1Process):
//    """
//A derived class for f fbar' -> W_R^+- (righthanded gauge boson).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma1ffbar2WRight, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma1ffbar2WRight, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma1ffbar2WRight()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma1ffbar2WRight_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma1ffbar2WRight_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma1ffbar2WRight_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma1ffbar2WRight_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for W decay angle.
//"""
//        return _pythia8.Sigma1ffbar2WRight_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma1ffbar2WRight_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2WRight_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2WRight_inFlux(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2WRight_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma1ffbar2WRight
//    __del__ = lambda self: None
//Sigma1ffbar2WRight_swigregister = _pythia8.Sigma1ffbar2WRight_swigregister
//Sigma1ffbar2WRight_swigregister(Sigma1ffbar2WRight)
//
//class Sigma1ll2Hchgchg(Sigma1Process):
//    """
//A derived class for l l -> H_L^++-- or H_R^++-- (doubly charged Higgs).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma1ll2Hchgchg, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma1ll2Hchgchg, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, leftRightIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma1ll2Hchgchg(leftRightIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma1ll2Hchgchg_initProc(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma1ll2Hchgchg_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma1ll2Hchgchg_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for W decay angle.
//"""
//        return _pythia8.Sigma1ll2Hchgchg_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma1ll2Hchgchg_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma1ll2Hchgchg_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma1ll2Hchgchg_inFlux(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma1ll2Hchgchg_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma1ll2Hchgchg
//    __del__ = lambda self: None
//Sigma1ll2Hchgchg_swigregister = _pythia8.Sigma1ll2Hchgchg_swigregister
//Sigma1ll2Hchgchg_swigregister(Sigma1ll2Hchgchg)
//
//class Sigma2lgm2Hchgchgl(Sigma2Process):
//    """
//A derived class for l- gamma -> H_(L/R)^-- l+  (doubly charged Higgs).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2lgm2Hchgchgl, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2lgm2Hchgchgl, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, leftRightIn, idLepIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2lgm2Hchgchgl(leftRightIn, idLepIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2lgm2Hchgchgl_initProc(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2lgm2Hchgchgl_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2lgm2Hchgchgl_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for W decay angle.
//"""
//        return _pythia8.Sigma2lgm2Hchgchgl_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2lgm2Hchgchgl_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2lgm2Hchgchgl_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2lgm2Hchgchgl_inFlux(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma2lgm2Hchgchgl_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2lgm2Hchgchgl
//    __del__ = lambda self: None
//Sigma2lgm2Hchgchgl_swigregister = _pythia8.Sigma2lgm2Hchgchgl_swigregister
//Sigma2lgm2Hchgchgl_swigregister(Sigma2lgm2Hchgchgl)
//
//class Sigma3ff2HchgchgfftWW(Sigma3Process):
//    """
//A derived class for f_1 f_2 -> H_(L/R)^++-- f_3 f_4 (W+- W+- fusion).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma3Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma3ff2HchgchgfftWW, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma3Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma3ff2HchgchgfftWW, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, leftRightIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma3ff2HchgchgfftWW(leftRightIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma3ff2HchgchgfftWW_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma3ff2HchgchgfftWW_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma3ff2HchgchgfftWW_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma3ff2HchgchgfftWW_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for decay angles.
//"""
//        return _pythia8.Sigma3ff2HchgchgfftWW_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma3ff2HchgchgfftWW_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma3ff2HchgchgfftWW_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma3ff2HchgchgfftWW_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma3ff2HchgchgfftWW_id3Mass(self)
//
//    def idTchan1(self):
//        """
//Instructions for 3-body phase space with t-channel propagators.
//"""
//        return _pythia8.Sigma3ff2HchgchgfftWW_idTchan1(self)
//
//    def idTchan2(self):
//        """
//"""
//        return _pythia8.Sigma3ff2HchgchgfftWW_idTchan2(self)
//
//    def tChanFracPow1(self):
//        """
//"""
//        return _pythia8.Sigma3ff2HchgchgfftWW_tChanFracPow1(self)
//
//    def tChanFracPow2(self):
//        """
//"""
//        return _pythia8.Sigma3ff2HchgchgfftWW_tChanFracPow2(self)
//
//    def useMirrorWeight(self):
//        """
//"""
//        return _pythia8.Sigma3ff2HchgchgfftWW_useMirrorWeight(self)
//    __swig_destroy__ = _pythia8.delete_Sigma3ff2HchgchgfftWW
//    __del__ = lambda self: None
//Sigma3ff2HchgchgfftWW_swigregister = _pythia8.Sigma3ff2HchgchgfftWW_swigregister
//Sigma3ff2HchgchgfftWW_swigregister(Sigma3ff2HchgchgfftWW)
//
//class Sigma2ffbar2HchgchgHchgchg(Sigma2Process):
//    """
//A derived class for f fbar -> H_(L/R)^++ H_(L/R)^--  (doubly charged Higgs).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2ffbar2HchgchgHchgchg, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2ffbar2HchgchgHchgchg, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, leftRightIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2ffbar2HchgchgHchgchg(leftRightIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2ffbar2HchgchgHchgchg_initProc(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2ffbar2HchgchgHchgchg_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2ffbar2HchgchgHchgchg_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for W decay angle.
//"""
//        return _pythia8.Sigma2ffbar2HchgchgHchgchg_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2ffbar2HchgchgHchgchg_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HchgchgHchgchg_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HchgchgHchgchg_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HchgchgHchgchg_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HchgchgHchgchg_id4Mass(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma2ffbar2HchgchgHchgchg_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2ffbar2HchgchgHchgchg
//    __del__ = lambda self: None
//Sigma2ffbar2HchgchgHchgchg_swigregister = _pythia8.Sigma2ffbar2HchgchgHchgchg_swigregister
//Sigma2ffbar2HchgchgHchgchg_swigregister(Sigma2ffbar2HchgchgHchgchg)
//
//class Sigma1ql2LeptoQuark(Sigma1Process):
//    """
//A derived class for q l -> LQ (leptoquark).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma1ql2LeptoQuark, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma1ql2LeptoQuark, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma1ql2LeptoQuark()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma1ql2LeptoQuark_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma1ql2LeptoQuark_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma1ql2LeptoQuark_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma1ql2LeptoQuark_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma1ql2LeptoQuark_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma1ql2LeptoQuark_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma1ql2LeptoQuark_inFlux(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma1ql2LeptoQuark_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma1ql2LeptoQuark
//    __del__ = lambda self: None
//Sigma1ql2LeptoQuark_swigregister = _pythia8.Sigma1ql2LeptoQuark_swigregister
//Sigma1ql2LeptoQuark_swigregister(Sigma1ql2LeptoQuark)
//
//class Sigma2qg2LeptoQuarkl(Sigma2Process):
//    """
//A derived class for q g -> LQ l (leptoquark).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qg2LeptoQuarkl, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qg2LeptoQuarkl, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qg2LeptoQuarkl()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qg2LeptoQuarkl_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qg2LeptoQuarkl_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2qg2LeptoQuarkl_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qg2LeptoQuarkl_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qg2LeptoQuarkl_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qg2LeptoQuarkl_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qg2LeptoQuarkl_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qg2LeptoQuarkl_id3Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qg2LeptoQuarkl
//    __del__ = lambda self: None
//Sigma2qg2LeptoQuarkl_swigregister = _pythia8.Sigma2qg2LeptoQuarkl_swigregister
//Sigma2qg2LeptoQuarkl_swigregister(Sigma2qg2LeptoQuarkl)
//
//class Sigma2gg2LQLQbar(Sigma2Process):
//    """
//A derived class for g g -> LQ LQbar (leptoquark).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2gg2LQLQbar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2gg2LQLQbar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2gg2LQLQbar()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2gg2LQLQbar_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2gg2LQLQbar_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2gg2LQLQbar_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2gg2LQLQbar_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2gg2LQLQbar_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2gg2LQLQbar_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2gg2LQLQbar_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2gg2LQLQbar_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2gg2LQLQbar_id4Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2gg2LQLQbar
//    __del__ = lambda self: None
//Sigma2gg2LQLQbar_swigregister = _pythia8.Sigma2gg2LQLQbar_swigregister
//Sigma2gg2LQLQbar_swigregister(Sigma2gg2LQLQbar)
//
//class Sigma2qqbar2LQLQbar(Sigma2Process):
//    """
//A derived class for q qbar -> LQ LQbar (leptoquark).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2LQLQbar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2LQLQbar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qqbar2LQLQbar()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qqbar2LQLQbar_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qqbar2LQLQbar_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma2qqbar2LQLQbar_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qqbar2LQLQbar_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qqbar2LQLQbar_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2LQLQbar_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2LQLQbar_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2LQLQbar_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2LQLQbar_id4Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2LQLQbar
//    __del__ = lambda self: None
//Sigma2qqbar2LQLQbar_swigregister = _pythia8.Sigma2qqbar2LQLQbar_swigregister
//Sigma2qqbar2LQLQbar_swigregister(Sigma2qqbar2LQLQbar)
//
//class Sigma1ffbarZprimeWprime(Sigma1Process):
//    __swig_setmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma1ffbarZprimeWprime, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma1ffbarZprimeWprime, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        this = _pythia8.new_Sigma1ffbarZprimeWprime()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_Sigma1ffbarZprimeWprime
//    __del__ = lambda self: None
//Sigma1ffbarZprimeWprime_swigregister = _pythia8.Sigma1ffbarZprimeWprime_swigregister
//Sigma1ffbarZprimeWprime_swigregister(Sigma1ffbarZprimeWprime)
//
//class Sigma1ffbar2gmZZprime(Sigma1ffbarZprimeWprime):
//    """
//A derived class for f fbar -> gamma*/Z0/Z'0.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma1ffbarZprimeWprime]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma1ffbar2gmZZprime, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma1ffbarZprimeWprime]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma1ffbar2gmZZprime, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma1ffbar2gmZZprime()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma1ffbar2gmZZprime_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma1ffbar2gmZZprime_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma1ffbar2gmZZprime_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma1ffbar2gmZZprime_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for Z' decay angle.
//"""
//        return _pythia8.Sigma1ffbar2gmZZprime_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma1ffbar2gmZZprime_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2gmZZprime_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2gmZZprime_inFlux(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2gmZZprime_resonanceA(self)
//
//    def resonanceB(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2gmZZprime_resonanceB(self)
//    __swig_destroy__ = _pythia8.delete_Sigma1ffbar2gmZZprime
//    __del__ = lambda self: None
//Sigma1ffbar2gmZZprime_swigregister = _pythia8.Sigma1ffbar2gmZZprime_swigregister
//Sigma1ffbar2gmZZprime_swigregister(Sigma1ffbar2gmZZprime)
//
//class Sigma1ffbar2Wprime(Sigma1ffbarZprimeWprime):
//    """
//A derived class for f fbar' -> W'+-.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma1ffbarZprimeWprime]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma1ffbar2Wprime, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma1ffbarZprimeWprime]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma1ffbar2Wprime, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma1ffbar2Wprime()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma1ffbar2Wprime_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma1ffbar2Wprime_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma1ffbar2Wprime_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma1ffbar2Wprime_setIdColAcol(self)
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for W decay angle.
//"""
//        return _pythia8.Sigma1ffbar2Wprime_weightDecay(self, process, iResBeg, iResEnd)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma1ffbar2Wprime_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2Wprime_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2Wprime_inFlux(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2Wprime_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma1ffbar2Wprime
//    __del__ = lambda self: None
//Sigma1ffbar2Wprime_swigregister = _pythia8.Sigma1ffbar2Wprime_swigregister
//Sigma1ffbar2Wprime_swigregister(Sigma1ffbar2Wprime)
//
//class Sigma1ffbar2Rhorizontal(Sigma1Process):
//    """
//A derived class for f fbar' -> R^0 (horizontal gauge boson).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma1ffbar2Rhorizontal, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma1ffbar2Rhorizontal, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma1ffbar2Rhorizontal()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma1ffbar2Rhorizontal_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma1ffbar2Rhorizontal_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate sigmaHat(sHat).
//"""
//        return _pythia8.Sigma1ffbar2Rhorizontal_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma1ffbar2Rhorizontal_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma1ffbar2Rhorizontal_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2Rhorizontal_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2Rhorizontal_inFlux(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma1ffbar2Rhorizontal_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma1ffbar2Rhorizontal
//    __del__ = lambda self: None
//Sigma1ffbar2Rhorizontal_swigregister = _pythia8.Sigma1ffbar2Rhorizontal_swigregister
//Sigma1ffbar2Rhorizontal_swigregister(Sigma1ffbar2Rhorizontal)
//
//class SigmaOniaSetup(_object):
//    """
//A helper class used to setup the onia processes.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SigmaOniaSetup, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, SigmaOniaSetup, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_SigmaOniaSetup(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def setupSigma2gg(self, procs, oniaIn=False):
//        """
//Initialise the SigmaProcesses for gg, qg, qqbar, or double production.
//"""
//        return _pythia8.SigmaOniaSetup_setupSigma2gg(self, procs, oniaIn)
//
//    def setupSigma2qg(self, procs, oniaIn=False):
//        """
//"""
//        return _pythia8.SigmaOniaSetup_setupSigma2qg(self, procs, oniaIn)
//
//    def setupSigma2qq(self, procs, oniaIn=False):
//        """
//"""
//        return _pythia8.SigmaOniaSetup_setupSigma2qq(self, procs, oniaIn)
//
//    def setupSigma2dbl(self, procs, oniaIn=False):
//        """
//"""
//        return _pythia8.SigmaOniaSetup_setupSigma2dbl(self, procs, oniaIn)
//    __swig_destroy__ = _pythia8.delete_SigmaOniaSetup
//    __del__ = lambda self: None
//SigmaOniaSetup_swigregister = _pythia8.SigmaOniaSetup_swigregister
//SigmaOniaSetup_swigregister(SigmaOniaSetup)
//
//class Sigma2gg2QQbar3S11g(Sigma2Process):
//    """
//A derived class for g g -> QQbar[3S1(1)] g (Q = c or b).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2gg2QQbar3S11g, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2gg2QQbar3S11g, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idHadIn, oniumMEIn, codeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2gg2QQbar3S11g(idHadIn, oniumMEIn, codeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2gg2QQbar3S11g_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2gg2QQbar3S11g_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2gg2QQbar3S11g_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2gg2QQbar3S11g_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2gg2QQbar3S11g_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2gg2QQbar3S11g_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2gg2QQbar3S11g_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2gg2QQbar3S11g_id3Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2gg2QQbar3S11g
//    __del__ = lambda self: None
//Sigma2gg2QQbar3S11g_swigregister = _pythia8.Sigma2gg2QQbar3S11g_swigregister
//Sigma2gg2QQbar3S11g_swigregister(Sigma2gg2QQbar3S11g)
//
//class Sigma2gg2QQbar3S11gm(Sigma2Process):
//    """
//A derived class for g g -> QQbar[3S1(1)] gamma (Q = c or b).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2gg2QQbar3S11gm, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2gg2QQbar3S11gm, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idHadIn, oniumMEIn, codeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2gg2QQbar3S11gm(idHadIn, oniumMEIn, codeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2gg2QQbar3S11gm_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2gg2QQbar3S11gm_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2gg2QQbar3S11gm_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2gg2QQbar3S11gm_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2gg2QQbar3S11gm_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2gg2QQbar3S11gm_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2gg2QQbar3S11gm_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2gg2QQbar3S11gm_id3Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2gg2QQbar3S11gm
//    __del__ = lambda self: None
//Sigma2gg2QQbar3S11gm_swigregister = _pythia8.Sigma2gg2QQbar3S11gm_swigregister
//Sigma2gg2QQbar3S11gm_swigregister(Sigma2gg2QQbar3S11gm)
//
//class Sigma2gg2QQbar3PJ1g(Sigma2Process):
//    """
//A derived class for g g -> QQbar[3PJ(1)] g (Q = c or b, J = 0, 1 or 2).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2gg2QQbar3PJ1g, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2gg2QQbar3PJ1g, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idHadIn, oniumMEIn, jIn, codeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2gg2QQbar3PJ1g(idHadIn, oniumMEIn, jIn, codeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2gg2QQbar3PJ1g_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2gg2QQbar3PJ1g_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2gg2QQbar3PJ1g_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2gg2QQbar3PJ1g_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2gg2QQbar3PJ1g_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2gg2QQbar3PJ1g_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2gg2QQbar3PJ1g_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2gg2QQbar3PJ1g_id3Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2gg2QQbar3PJ1g
//    __del__ = lambda self: None
//Sigma2gg2QQbar3PJ1g_swigregister = _pythia8.Sigma2gg2QQbar3PJ1g_swigregister
//Sigma2gg2QQbar3PJ1g_swigregister(Sigma2gg2QQbar3PJ1g)
//
//class Sigma2qg2QQbar3PJ1q(Sigma2gg2QQbar3PJ1g):
//    """
//A derived class for q g -> QQbar[3PJ(1)] q (Q = c or b, J = 0, 1 or 2).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2gg2QQbar3PJ1g]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qg2QQbar3PJ1q, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2gg2QQbar3PJ1g]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qg2QQbar3PJ1q, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idHadIn, oniumMEIn, jIn, codeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qg2QQbar3PJ1q(idHadIn, oniumMEIn, jIn, codeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qg2QQbar3PJ1q_sigmaKin(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qg2QQbar3PJ1q_setIdColAcol(self)
//
//    def inFlux(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qg2QQbar3PJ1q_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qg2QQbar3PJ1q
//    __del__ = lambda self: None
//Sigma2qg2QQbar3PJ1q_swigregister = _pythia8.Sigma2qg2QQbar3PJ1q_swigregister
//Sigma2qg2QQbar3PJ1q_swigregister(Sigma2qg2QQbar3PJ1q)
//
//class Sigma2qqbar2QQbar3PJ1g(Sigma2gg2QQbar3PJ1g):
//    """
//A derived class for q qbar -> QQbar[3PJ(1)] g (Q = c or b, J = 0, 1 or 2).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2gg2QQbar3PJ1g]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2QQbar3PJ1g, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2gg2QQbar3PJ1g]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2QQbar3PJ1g, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idHadIn, oniumMEIn, jIn, codeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qqbar2QQbar3PJ1g(idHadIn, oniumMEIn, jIn, codeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qqbar2QQbar3PJ1g_sigmaKin(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qqbar2QQbar3PJ1g_setIdColAcol(self)
//
//    def inFlux(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qqbar2QQbar3PJ1g_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2QQbar3PJ1g
//    __del__ = lambda self: None
//Sigma2qqbar2QQbar3PJ1g_swigregister = _pythia8.Sigma2qqbar2QQbar3PJ1g_swigregister
//Sigma2qqbar2QQbar3PJ1g_swigregister(Sigma2qqbar2QQbar3PJ1g)
//
//class Sigma2gg2QQbar3DJ1g(Sigma2gg2QQbar3PJ1g):
//    """
//A derived class for g g -> QQbar[3DJ(1)] g (Q = c or b).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2gg2QQbar3PJ1g]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2gg2QQbar3DJ1g, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2gg2QQbar3PJ1g]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2gg2QQbar3DJ1g, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idHadIn, oniumMEIn, jIn, codeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2gg2QQbar3DJ1g(idHadIn, oniumMEIn, jIn, codeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2gg2QQbar3DJ1g_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2gg2QQbar3DJ1g_sigmaKin(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2gg2QQbar3DJ1g
//    __del__ = lambda self: None
//Sigma2gg2QQbar3DJ1g_swigregister = _pythia8.Sigma2gg2QQbar3DJ1g_swigregister
//Sigma2gg2QQbar3DJ1g_swigregister(Sigma2gg2QQbar3DJ1g)
//
//class Sigma2gg2QQbarX8g(Sigma2Process):
//    """
//A derived class for g g -> QQbar[X(8)] g (Q = c or b, X = 3S1, 1S0 or 3PJ).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2gg2QQbarX8g, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2gg2QQbarX8g, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idHadIn, oniumMEIn, stateIn, mSplitIn, codeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2gg2QQbarX8g(idHadIn, oniumMEIn, stateIn, mSplitIn, codeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2gg2QQbarX8g_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2gg2QQbarX8g_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2gg2QQbarX8g_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2gg2QQbarX8g_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2gg2QQbarX8g_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2gg2QQbarX8g_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2gg2QQbarX8g_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2gg2QQbarX8g_id3Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2gg2QQbarX8g
//    __del__ = lambda self: None
//Sigma2gg2QQbarX8g_swigregister = _pythia8.Sigma2gg2QQbarX8g_swigregister
//Sigma2gg2QQbarX8g_swigregister(Sigma2gg2QQbarX8g)
//
//class Sigma2qg2QQbarX8q(Sigma2gg2QQbarX8g):
//    """
//A derived class for q g -> QQbar[X(8)] q (Q = c or b, X = 3S1, 1S0 or 3PJ).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2gg2QQbarX8g]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qg2QQbarX8q, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2gg2QQbarX8g]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qg2QQbarX8q, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idHadIn, oniumMEIn, stateIn, mSplitIn, codeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qg2QQbarX8q(idHadIn, oniumMEIn, stateIn, mSplitIn, codeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qg2QQbarX8q_sigmaKin(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qg2QQbarX8q_setIdColAcol(self)
//
//    def inFlux(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qg2QQbarX8q_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qg2QQbarX8q
//    __del__ = lambda self: None
//Sigma2qg2QQbarX8q_swigregister = _pythia8.Sigma2qg2QQbarX8q_swigregister
//Sigma2qg2QQbarX8q_swigregister(Sigma2qg2QQbarX8q)
//
//class Sigma2qqbar2QQbarX8g(Sigma2gg2QQbarX8g):
//    """
//A derived class for q qbar -> QQbar[X(8)] g (Q = c or b,
//  X = 3S1, 1S0 or 3PJ).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2gg2QQbarX8g]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2QQbarX8g, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2gg2QQbarX8g]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2QQbarX8g, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idHadIn, oniumMEIn, stateIn, mSplitIn, codeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qqbar2QQbarX8g(idHadIn, oniumMEIn, stateIn, mSplitIn, codeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qqbar2QQbarX8g_sigmaKin(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qqbar2QQbarX8g_setIdColAcol(self)
//
//    def inFlux(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qqbar2QQbarX8g_inFlux(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2QQbarX8g
//    __del__ = lambda self: None
//Sigma2qqbar2QQbarX8g_swigregister = _pythia8.Sigma2qqbar2QQbarX8g_swigregister
//Sigma2qqbar2QQbarX8g_swigregister(Sigma2qqbar2QQbarX8g)
//
//class Sigma2gg2QQbar3S11QQbar3S11(Sigma2Process):
//    """
//A derived class for g g -> QQbar[3S1(1)] QQbar[3S1(1)] (Q = c or b).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2gg2QQbar3S11QQbar3S11, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2gg2QQbar3S11QQbar3S11, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idHad1In, idHad2In, oniumME1In, oniumME2In, codeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2gg2QQbar3S11QQbar3S11(idHad1In, idHad2In, oniumME1In, oniumME2In, codeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2gg2QQbar3S11QQbar3S11_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2gg2QQbar3S11QQbar3S11_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2gg2QQbar3S11QQbar3S11_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2gg2QQbar3S11QQbar3S11_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2gg2QQbar3S11QQbar3S11_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2gg2QQbar3S11QQbar3S11_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2gg2QQbar3S11QQbar3S11_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2gg2QQbar3S11QQbar3S11_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2gg2QQbar3S11QQbar3S11_id4Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2gg2QQbar3S11QQbar3S11
//    __del__ = lambda self: None
//Sigma2gg2QQbar3S11QQbar3S11_swigregister = _pythia8.Sigma2gg2QQbar3S11QQbar3S11_swigregister
//Sigma2gg2QQbar3S11QQbar3S11_swigregister(Sigma2gg2QQbar3S11QQbar3S11)
//
//class Sigma2qqbar2QQbar3S11QQbar3S11(Sigma2Process):
//    """
//A derived class for q qbar -> QQbar[3S1(1)] QQbar[3S1(1)] (Q = c or b).
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2QQbar3S11QQbar3S11, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2QQbar3S11QQbar3S11, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, idHad1In, idHad2In, oniumME1In, oniumME2In, codeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qqbar2QQbar3S11QQbar3S11(idHad1In, idHad2In, oniumME1In, oniumME2In, codeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qqbar2QQbar3S11QQbar3S11_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qqbar2QQbar3S11QQbar3S11_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qqbar2QQbar3S11QQbar3S11_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qqbar2QQbar3S11QQbar3S11_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qqbar2QQbar3S11QQbar3S11_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2QQbar3S11QQbar3S11_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2QQbar3S11QQbar3S11_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2QQbar3S11QQbar3S11_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2QQbar3S11QQbar3S11_id4Mass(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2QQbar3S11QQbar3S11
//    __del__ = lambda self: None
//Sigma2qqbar2QQbar3S11QQbar3S11_swigregister = _pythia8.Sigma2qqbar2QQbar3S11QQbar3S11_swigregister
//Sigma2qqbar2QQbar3S11QQbar3S11_swigregister(Sigma2qqbar2QQbar3S11QQbar3S11)
//
//class Sigma2SUSY(Sigma2Process):
//    """
//An intermediate class for SUSY 2 -> 2 with nontrivial decay angles.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2SUSY, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2SUSY, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2SUSY()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def weightDecay(self, process, iResBeg, iResEnd):
//        """
//Evaluate weight for decay angles.
//"""
//        return _pythia8.Sigma2SUSY_weightDecay(self, process, iResBeg, iResEnd)
//    __swig_destroy__ = _pythia8.delete_Sigma2SUSY
//    __del__ = lambda self: None
//Sigma2SUSY_swigregister = _pythia8.Sigma2SUSY_swigregister
//Sigma2SUSY_swigregister(Sigma2SUSY)
//
//class Sigma2qqbar2chi0chi0(Sigma2SUSY):
//    """
//A derived class for q qbar -> neutralino_i neutralino_j.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2SUSY]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2chi0chi0, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2SUSY]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2chi0chi0, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qqbar2chi0chi0(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qqbar2chi0chi0_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qqbar2chi0chi0_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qqbar2chi0chi0_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qqbar2chi0chi0_setIdColAcol(self)
//
//    def name(self):
//        """
//Evaluate weight for decay angles.
// virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qqbar2chi0chi0_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2chi0chi0_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2chi0chi0_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2chi0chi0_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2chi0chi0_id4Mass(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2chi0chi0_resonanceA(self)
//
//    def isSUSY(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2chi0chi0_isSUSY(self)
//
//    def getSigma0(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2chi0chi0_getSigma0(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2chi0chi0
//    __del__ = lambda self: None
//Sigma2qqbar2chi0chi0_swigregister = _pythia8.Sigma2qqbar2chi0chi0_swigregister
//Sigma2qqbar2chi0chi0_swigregister(Sigma2qqbar2chi0chi0)
//
//class Sigma2qqbar2charchi0(Sigma2qqbar2chi0chi0):
//    """
//A derived class for q qbar -> neutralino_i chargino_j.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2qqbar2chi0chi0]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2charchi0, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2qqbar2chi0chi0]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2charchi0, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, id3chiIn, id4chiIn, codeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qqbar2charchi0(id3chiIn, id4chiIn, codeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qqbar2charchi0_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qqbar2charchi0_sigmaHat(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2charchi0_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2charchi0
//    __del__ = lambda self: None
//Sigma2qqbar2charchi0_swigregister = _pythia8.Sigma2qqbar2charchi0_swigregister
//Sigma2qqbar2charchi0_swigregister(Sigma2qqbar2charchi0)
//
//class Sigma2qqbar2charchar(Sigma2qqbar2chi0chi0):
//    """
//A derived class for q qbar -> chargino+_i chargino-_j.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2qqbar2chi0chi0]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2charchar, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2qqbar2chi0chi0]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2charchar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, id3chiIn, id4chiIn, codeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qqbar2charchar(id3chiIn, id4chiIn, codeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qqbar2charchar_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qqbar2charchar_sigmaHat(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2charchar
//    __del__ = lambda self: None
//Sigma2qqbar2charchar_swigregister = _pythia8.Sigma2qqbar2charchar_swigregister
//Sigma2qqbar2charchar_swigregister(Sigma2qqbar2charchar)
//
//class Sigma2qg2chi0squark(Sigma2Process):
//    """
//A derived class for q g -> neutralino_i squark_j (and cc)
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qg2chi0squark, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qg2chi0squark, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qg2chi0squark(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qg2chi0squark_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qg2chi0squark_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qg2chi0squark_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qg2chi0squark_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qg2chi0squark_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qg2chi0squark_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qg2chi0squark_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qg2chi0squark_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qg2chi0squark_id4Mass(self)
//
//    def isSUSY(self):
//        """
//"""
//        return _pythia8.Sigma2qg2chi0squark_isSUSY(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qg2chi0squark
//    __del__ = lambda self: None
//Sigma2qg2chi0squark_swigregister = _pythia8.Sigma2qg2chi0squark_swigregister
//Sigma2qg2chi0squark_swigregister(Sigma2qg2chi0squark)
//
//class Sigma2qg2charsquark(Sigma2qg2chi0squark):
//    """
//A derived class for q g -> chargino_i squark_j (incl cc)
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2qg2chi0squark]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qg2charsquark, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2qg2chi0squark]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qg2charsquark, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, id3chiIn, id4sqIn, isUp, codeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qg2charsquark(id3chiIn, id4sqIn, isUp, codeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initial values, can be swapped to charge conjugates event by event.
//Initialize process.
//"""
//        return _pythia8.Sigma2qg2charsquark_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qg2charsquark_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qg2charsquark_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qg2charsquark_setIdColAcol(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qg2charsquark
//    __del__ = lambda self: None
//Sigma2qg2charsquark_swigregister = _pythia8.Sigma2qg2charsquark_swigregister
//Sigma2qg2charsquark_swigregister(Sigma2qg2charsquark)
//
//class Sigma2qq2squarksquark(Sigma2Process):
//    """
//A derived class for q q' -> ~q_i ~q_j
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qq2squarksquark, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qq2squarksquark, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qq2squarksquark(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Save ordering indices and process code
//Initial values (flipped for c.c.)
//Initialize process.
//"""
//        return _pythia8.Sigma2qq2squarksquark_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qq2squarksquark_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qq2squarksquark_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qq2squarksquark_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qq2squarksquark_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qq2squarksquark_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qq2squarksquark_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qq2squarksquark_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qq2squarksquark_id4Mass(self)
//
//    def isSUSY(self):
//        """
//"""
//        return _pythia8.Sigma2qq2squarksquark_isSUSY(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qq2squarksquark
//    __del__ = lambda self: None
//Sigma2qq2squarksquark_swigregister = _pythia8.Sigma2qq2squarksquark_swigregister
//Sigma2qq2squarksquark_swigregister(Sigma2qq2squarksquark)
//
//class Sigma2qqbar2squarkantisquark(Sigma2Process):
//    """
//A derived class for q qbar' -> ~q_i ~q*_j
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2squarkantisquark, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2squarkantisquark, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qqbar2squarkantisquark(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initial values
//Initialize process.
//"""
//        return _pythia8.Sigma2qqbar2squarkantisquark_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qqbar2squarkantisquark_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qqbar2squarkantisquark_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qqbar2squarkantisquark_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qqbar2squarkantisquark_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2squarkantisquark_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2squarkantisquark_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2squarkantisquark_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2squarkantisquark_id4Mass(self)
//
//    def isSUSY(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2squarkantisquark_isSUSY(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2squarkantisquark
//    __del__ = lambda self: None
//Sigma2qqbar2squarkantisquark_swigregister = _pythia8.Sigma2qqbar2squarkantisquark_swigregister
//Sigma2qqbar2squarkantisquark_swigregister(Sigma2qqbar2squarkantisquark)
//
//class Sigma2gg2squarkantisquark(Sigma2Process):
//    """
//A derived class for g g -> ~q ~q*
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2gg2squarkantisquark, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2gg2squarkantisquark, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2gg2squarkantisquark(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initial values
//Initialize process.
//"""
//        return _pythia8.Sigma2gg2squarkantisquark_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2gg2squarkantisquark_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2gg2squarkantisquark_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2gg2squarkantisquark_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2gg2squarkantisquark_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2gg2squarkantisquark_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2gg2squarkantisquark_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2gg2squarkantisquark_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2gg2squarkantisquark_id4Mass(self)
//
//    def isSUSY(self):
//        """
//"""
//        return _pythia8.Sigma2gg2squarkantisquark_isSUSY(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2gg2squarkantisquark
//    __del__ = lambda self: None
//Sigma2gg2squarkantisquark_swigregister = _pythia8.Sigma2gg2squarkantisquark_swigregister
//Sigma2gg2squarkantisquark_swigregister(Sigma2gg2squarkantisquark)
//
//class Sigma2qg2squarkgluino(Sigma2Process):
//    """
//A derived class for q g -> ~q ~g
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qg2squarkgluino, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qg2squarkgluino, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qg2squarkgluino(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Save ordering indices and process code
//Initial values
//Initialize process.
//"""
//        return _pythia8.Sigma2qg2squarkgluino_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qg2squarkgluino_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qg2squarkgluino_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qg2squarkgluino_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qg2squarkgluino_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qg2squarkgluino_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qg2squarkgluino_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qg2squarkgluino_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qg2squarkgluino_id4Mass(self)
//
//    def isSUSY(self):
//        """
//"""
//        return _pythia8.Sigma2qg2squarkgluino_isSUSY(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qg2squarkgluino
//    __del__ = lambda self: None
//Sigma2qg2squarkgluino_swigregister = _pythia8.Sigma2qg2squarkgluino_swigregister
//Sigma2qg2squarkgluino_swigregister(Sigma2qg2squarkgluino)
//
//class Sigma2gg2gluinogluino(Sigma2Process):
//    """
//A derived class for g g -> gluino gluino.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2gg2gluinogluino, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2gg2gluinogluino, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2gg2gluinogluino()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2gg2gluinogluino_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2gg2gluinogluino_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2gg2gluinogluino_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2gg2gluinogluino_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2gg2gluinogluino_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2gg2gluinogluino_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2gg2gluinogluino_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2gg2gluinogluino_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2gg2gluinogluino_id4Mass(self)
//
//    def isSUSY(self):
//        """
//"""
//        return _pythia8.Sigma2gg2gluinogluino_isSUSY(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2gg2gluinogluino
//    __del__ = lambda self: None
//Sigma2gg2gluinogluino_swigregister = _pythia8.Sigma2gg2gluinogluino_swigregister
//Sigma2gg2gluinogluino_swigregister(Sigma2gg2gluinogluino)
//
//class Sigma2qqbar2gluinogluino(Sigma2Process):
//    """
//A derived class for q qbar -> gluino gluino.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2gluinogluino, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2gluinogluino, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qqbar2gluinogluino()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qqbar2gluinogluino_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qqbar2gluinogluino_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qqbar2gluinogluino_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qqbar2gluinogluino_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qqbar2gluinogluino_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2gluinogluino_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2gluinogluino_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2gluinogluino_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2gluinogluino_id4Mass(self)
//
//    def isSUSY(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2gluinogluino_isSUSY(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2gluinogluino
//    __del__ = lambda self: None
//Sigma2qqbar2gluinogluino_swigregister = _pythia8.Sigma2qqbar2gluinogluino_swigregister
//Sigma2qqbar2gluinogluino_swigregister(Sigma2qqbar2gluinogluino)
//
//class Sigma1qq2antisquark(Sigma1Process):
//    """
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma1qq2antisquark, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma1Process]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma1qq2antisquark, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_Sigma1qq2antisquark(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma1qq2antisquark_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma1qq2antisquark_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma1qq2antisquark_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma1qq2antisquark_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma1qq2antisquark_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma1qq2antisquark_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma1qq2antisquark_inFlux(self)
//
//    def isSUSY(self):
//        """
//"""
//        return _pythia8.Sigma1qq2antisquark_isSUSY(self)
//
//    def isRPV(self):
//        """
//"""
//        return _pythia8.Sigma1qq2antisquark_isRPV(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma1qq2antisquark_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma1qq2antisquark
//    __del__ = lambda self: None
//Sigma1qq2antisquark_swigregister = _pythia8.Sigma1qq2antisquark_swigregister
//Sigma1qq2antisquark_swigregister(Sigma1qq2antisquark)
//
//class Sigma2qqbar2chi0gluino(Sigma2SUSY):
//    """
//A derived class for q qbar -> neutralino_i gluino.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2SUSY]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2chi0gluino, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2SUSY]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2chi0gluino, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qqbar2chi0gluino(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qqbar2chi0gluino_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qqbar2chi0gluino_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qqbar2chi0gluino_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qqbar2chi0gluino_setIdColAcol(self)
//
//    def name(self):
//        """
//Evaluate weight for decay angles.
// virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qqbar2chi0gluino_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2chi0gluino_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2chi0gluino_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2chi0gluino_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2chi0gluino_id4Mass(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2chi0gluino_resonanceA(self)
//
//    def isSUSY(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2chi0gluino_isSUSY(self)
//
//    def getSigma0(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2chi0gluino_getSigma0(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2chi0gluino
//    __del__ = lambda self: None
//Sigma2qqbar2chi0gluino_swigregister = _pythia8.Sigma2qqbar2chi0gluino_swigregister
//Sigma2qqbar2chi0gluino_swigregister(Sigma2qqbar2chi0gluino)
//
//class Sigma2qqbar2chargluino(Sigma2qqbar2chi0gluino):
//    """
//A derived class for q qbar -> neutralino_i chargino_j.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2qqbar2chi0gluino]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2chargluino, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2qqbar2chi0gluino]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2chargluino, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, id4chiIn, codeIn):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qqbar2chargluino(id4chiIn, codeIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initialize process.
//"""
//        return _pythia8.Sigma2qqbar2chargluino_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qqbar2chargluino_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qqbar2chargluino_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qqbar2chargluino_setIdColAcol(self)
//
//    def resonanceA(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2chargluino_resonanceA(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2chargluino
//    __del__ = lambda self: None
//Sigma2qqbar2chargluino_swigregister = _pythia8.Sigma2qqbar2chargluino_swigregister
//Sigma2qqbar2chargluino_swigregister(Sigma2qqbar2chargluino)
//
//class Sigma2qqbar2sleptonantislepton(Sigma2qqbar2squarkantisquark):
//    """
//A derived class for q qbar' -> ~q_i ~q*_j
//"""
//    __swig_setmethods__ = {}
//    for _s in [Sigma2qqbar2squarkantisquark]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Sigma2qqbar2sleptonantislepton, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Sigma2qqbar2squarkantisquark]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Sigma2qqbar2sleptonantislepton, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor.
//"""
//        this = _pythia8.new_Sigma2qqbar2sleptonantislepton(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def initProc(self):
//        """
//Initial values
//Initialize process.
//"""
//        return _pythia8.Sigma2qqbar2sleptonantislepton_initProc(self)
//
//    def sigmaKin(self):
//        """
//Calculate flavour-independent parts of cross section.
//"""
//        return _pythia8.Sigma2qqbar2sleptonantislepton_sigmaKin(self)
//
//    def sigmaHat(self):
//        """
//Evaluate d(sigmaHat)/d(tHat).
//"""
//        return _pythia8.Sigma2qqbar2sleptonantislepton_sigmaHat(self)
//
//    def setIdColAcol(self):
//        """
//Select flavour, colour and anticolour.
//"""
//        return _pythia8.Sigma2qqbar2sleptonantislepton_setIdColAcol(self)
//
//    def name(self):
//        """
//Info on the subprocess.
//"""
//        return _pythia8.Sigma2qqbar2sleptonantislepton_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2sleptonantislepton_code(self)
//
//    def inFlux(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2sleptonantislepton_inFlux(self)
//
//    def id3Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2sleptonantislepton_id3Mass(self)
//
//    def id4Mass(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2sleptonantislepton_id4Mass(self)
//
//    def isSUSY(self):
//        """
//"""
//        return _pythia8.Sigma2qqbar2sleptonantislepton_isSUSY(self)
//    __swig_destroy__ = _pythia8.delete_Sigma2qqbar2sleptonantislepton
//    __del__ = lambda self: None
//Sigma2qqbar2sleptonantislepton_swigregister = _pythia8.Sigma2qqbar2sleptonantislepton_swigregister
//Sigma2qqbar2sleptonantislepton_swigregister(Sigma2qqbar2sleptonantislepton)
//
//class SpaceDipoleEnd(_object):
//    """
//Data on radiating dipole ends, only used inside SpaceShower.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SpaceDipoleEnd, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, SpaceDipoleEnd, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, systemIn=0, sideIn=0, iRadiatorIn=0, iRecoilerIn=0, pTmaxIn=0., colTypeIn=0, chgTypeIn=0, weakTypeIn=0, MEtypeIn=0, normalRecoilIn=True, weakPolIn=0, iColPartnerIn=0, idColPartnerIn=0):
//        """
//Constructor.
//"""
//        this = _pythia8.new_SpaceDipoleEnd(systemIn, sideIn, iRadiatorIn, iRecoilerIn, pTmaxIn, colTypeIn, chgTypeIn, weakTypeIn, MEtypeIn, normalRecoilIn, weakPolIn, iColPartnerIn, idColPartnerIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def store(self, idDaughterIn, idMotherIn, idSisterIn, x1In, x2In, m2DipIn, pT2In, zIn, xMoIn, Q2In, mSisterIn, m2SisterIn, pT2corrIn, iColPartnerIn, m2IFIn, mColPartnerIn):
//        """
//Store values for trial emission.
//"""
//        return _pythia8.SpaceDipoleEnd_store(self, idDaughterIn, idMotherIn, idSisterIn, x1In, x2In, m2DipIn, pT2In, zIn, xMoIn, Q2In, mSisterIn, m2SisterIn, pT2corrIn, iColPartnerIn, m2IFIn, mColPartnerIn)
//    __swig_setmethods__["system"] = _pythia8.SpaceDipoleEnd_system_set
//    __swig_getmethods__["system"] = _pythia8.SpaceDipoleEnd_system_get
//    if _newclass:
//        system = _swig_property(_pythia8.SpaceDipoleEnd_system_get, _pythia8.SpaceDipoleEnd_system_set)
//    __swig_setmethods__["side"] = _pythia8.SpaceDipoleEnd_side_set
//    __swig_getmethods__["side"] = _pythia8.SpaceDipoleEnd_side_get
//    if _newclass:
//        side = _swig_property(_pythia8.SpaceDipoleEnd_side_get, _pythia8.SpaceDipoleEnd_side_set)
//    __swig_setmethods__["iRadiator"] = _pythia8.SpaceDipoleEnd_iRadiator_set
//    __swig_getmethods__["iRadiator"] = _pythia8.SpaceDipoleEnd_iRadiator_get
//    if _newclass:
//        iRadiator = _swig_property(_pythia8.SpaceDipoleEnd_iRadiator_get, _pythia8.SpaceDipoleEnd_iRadiator_set)
//    __swig_setmethods__["iRecoiler"] = _pythia8.SpaceDipoleEnd_iRecoiler_set
//    __swig_getmethods__["iRecoiler"] = _pythia8.SpaceDipoleEnd_iRecoiler_get
//    if _newclass:
//        iRecoiler = _swig_property(_pythia8.SpaceDipoleEnd_iRecoiler_get, _pythia8.SpaceDipoleEnd_iRecoiler_set)
//    __swig_setmethods__["pTmax"] = _pythia8.SpaceDipoleEnd_pTmax_set
//    __swig_getmethods__["pTmax"] = _pythia8.SpaceDipoleEnd_pTmax_get
//    if _newclass:
//        pTmax = _swig_property(_pythia8.SpaceDipoleEnd_pTmax_get, _pythia8.SpaceDipoleEnd_pTmax_set)
//    __swig_setmethods__["colType"] = _pythia8.SpaceDipoleEnd_colType_set
//    __swig_getmethods__["colType"] = _pythia8.SpaceDipoleEnd_colType_get
//    if _newclass:
//        colType = _swig_property(_pythia8.SpaceDipoleEnd_colType_get, _pythia8.SpaceDipoleEnd_colType_set)
//    __swig_setmethods__["chgType"] = _pythia8.SpaceDipoleEnd_chgType_set
//    __swig_getmethods__["chgType"] = _pythia8.SpaceDipoleEnd_chgType_get
//    if _newclass:
//        chgType = _swig_property(_pythia8.SpaceDipoleEnd_chgType_get, _pythia8.SpaceDipoleEnd_chgType_set)
//    __swig_setmethods__["weakType"] = _pythia8.SpaceDipoleEnd_weakType_set
//    __swig_getmethods__["weakType"] = _pythia8.SpaceDipoleEnd_weakType_get
//    if _newclass:
//        weakType = _swig_property(_pythia8.SpaceDipoleEnd_weakType_get, _pythia8.SpaceDipoleEnd_weakType_set)
//    __swig_setmethods__["MEtype"] = _pythia8.SpaceDipoleEnd_MEtype_set
//    __swig_getmethods__["MEtype"] = _pythia8.SpaceDipoleEnd_MEtype_get
//    if _newclass:
//        MEtype = _swig_property(_pythia8.SpaceDipoleEnd_MEtype_get, _pythia8.SpaceDipoleEnd_MEtype_set)
//    __swig_setmethods__["normalRecoil"] = _pythia8.SpaceDipoleEnd_normalRecoil_set
//    __swig_getmethods__["normalRecoil"] = _pythia8.SpaceDipoleEnd_normalRecoil_get
//    if _newclass:
//        normalRecoil = _swig_property(_pythia8.SpaceDipoleEnd_normalRecoil_get, _pythia8.SpaceDipoleEnd_normalRecoil_set)
//    __swig_setmethods__["weakPol"] = _pythia8.SpaceDipoleEnd_weakPol_set
//    __swig_getmethods__["weakPol"] = _pythia8.SpaceDipoleEnd_weakPol_get
//    if _newclass:
//        weakPol = _swig_property(_pythia8.SpaceDipoleEnd_weakPol_get, _pythia8.SpaceDipoleEnd_weakPol_set)
//    __swig_setmethods__["iColPartner"] = _pythia8.SpaceDipoleEnd_iColPartner_set
//    __swig_getmethods__["iColPartner"] = _pythia8.SpaceDipoleEnd_iColPartner_get
//    if _newclass:
//        iColPartner = _swig_property(_pythia8.SpaceDipoleEnd_iColPartner_get, _pythia8.SpaceDipoleEnd_iColPartner_set)
//    __swig_setmethods__["idColPartner"] = _pythia8.SpaceDipoleEnd_idColPartner_set
//    __swig_getmethods__["idColPartner"] = _pythia8.SpaceDipoleEnd_idColPartner_get
//    if _newclass:
//        idColPartner = _swig_property(_pythia8.SpaceDipoleEnd_idColPartner_get, _pythia8.SpaceDipoleEnd_idColPartner_set)
//    __swig_setmethods__["nBranch"] = _pythia8.SpaceDipoleEnd_nBranch_set
//    __swig_getmethods__["nBranch"] = _pythia8.SpaceDipoleEnd_nBranch_get
//    if _newclass:
//        nBranch = _swig_property(_pythia8.SpaceDipoleEnd_nBranch_get, _pythia8.SpaceDipoleEnd_nBranch_set)
//    __swig_setmethods__["idDaughter"] = _pythia8.SpaceDipoleEnd_idDaughter_set
//    __swig_getmethods__["idDaughter"] = _pythia8.SpaceDipoleEnd_idDaughter_get
//    if _newclass:
//        idDaughter = _swig_property(_pythia8.SpaceDipoleEnd_idDaughter_get, _pythia8.SpaceDipoleEnd_idDaughter_set)
//    __swig_setmethods__["idMother"] = _pythia8.SpaceDipoleEnd_idMother_set
//    __swig_getmethods__["idMother"] = _pythia8.SpaceDipoleEnd_idMother_get
//    if _newclass:
//        idMother = _swig_property(_pythia8.SpaceDipoleEnd_idMother_get, _pythia8.SpaceDipoleEnd_idMother_set)
//    __swig_setmethods__["idSister"] = _pythia8.SpaceDipoleEnd_idSister_set
//    __swig_getmethods__["idSister"] = _pythia8.SpaceDipoleEnd_idSister_get
//    if _newclass:
//        idSister = _swig_property(_pythia8.SpaceDipoleEnd_idSister_get, _pythia8.SpaceDipoleEnd_idSister_set)
//    __swig_setmethods__["iFinPol"] = _pythia8.SpaceDipoleEnd_iFinPol_set
//    __swig_getmethods__["iFinPol"] = _pythia8.SpaceDipoleEnd_iFinPol_get
//    if _newclass:
//        iFinPol = _swig_property(_pythia8.SpaceDipoleEnd_iFinPol_get, _pythia8.SpaceDipoleEnd_iFinPol_set)
//    __swig_setmethods__["x1"] = _pythia8.SpaceDipoleEnd_x1_set
//    __swig_getmethods__["x1"] = _pythia8.SpaceDipoleEnd_x1_get
//    if _newclass:
//        x1 = _swig_property(_pythia8.SpaceDipoleEnd_x1_get, _pythia8.SpaceDipoleEnd_x1_set)
//    __swig_setmethods__["x2"] = _pythia8.SpaceDipoleEnd_x2_set
//    __swig_getmethods__["x2"] = _pythia8.SpaceDipoleEnd_x2_get
//    if _newclass:
//        x2 = _swig_property(_pythia8.SpaceDipoleEnd_x2_get, _pythia8.SpaceDipoleEnd_x2_set)
//    __swig_setmethods__["m2Dip"] = _pythia8.SpaceDipoleEnd_m2Dip_set
//    __swig_getmethods__["m2Dip"] = _pythia8.SpaceDipoleEnd_m2Dip_get
//    if _newclass:
//        m2Dip = _swig_property(_pythia8.SpaceDipoleEnd_m2Dip_get, _pythia8.SpaceDipoleEnd_m2Dip_set)
//    __swig_setmethods__["pT2"] = _pythia8.SpaceDipoleEnd_pT2_set
//    __swig_getmethods__["pT2"] = _pythia8.SpaceDipoleEnd_pT2_get
//    if _newclass:
//        pT2 = _swig_property(_pythia8.SpaceDipoleEnd_pT2_get, _pythia8.SpaceDipoleEnd_pT2_set)
//    __swig_setmethods__["z"] = _pythia8.SpaceDipoleEnd_z_set
//    __swig_getmethods__["z"] = _pythia8.SpaceDipoleEnd_z_get
//    if _newclass:
//        z = _swig_property(_pythia8.SpaceDipoleEnd_z_get, _pythia8.SpaceDipoleEnd_z_set)
//    __swig_setmethods__["xMo"] = _pythia8.SpaceDipoleEnd_xMo_set
//    __swig_getmethods__["xMo"] = _pythia8.SpaceDipoleEnd_xMo_get
//    if _newclass:
//        xMo = _swig_property(_pythia8.SpaceDipoleEnd_xMo_get, _pythia8.SpaceDipoleEnd_xMo_set)
//    __swig_setmethods__["Q2"] = _pythia8.SpaceDipoleEnd_Q2_set
//    __swig_getmethods__["Q2"] = _pythia8.SpaceDipoleEnd_Q2_get
//    if _newclass:
//        Q2 = _swig_property(_pythia8.SpaceDipoleEnd_Q2_get, _pythia8.SpaceDipoleEnd_Q2_set)
//    __swig_setmethods__["mSister"] = _pythia8.SpaceDipoleEnd_mSister_set
//    __swig_getmethods__["mSister"] = _pythia8.SpaceDipoleEnd_mSister_get
//    if _newclass:
//        mSister = _swig_property(_pythia8.SpaceDipoleEnd_mSister_get, _pythia8.SpaceDipoleEnd_mSister_set)
//    __swig_setmethods__["m2Sister"] = _pythia8.SpaceDipoleEnd_m2Sister_set
//    __swig_getmethods__["m2Sister"] = _pythia8.SpaceDipoleEnd_m2Sister_get
//    if _newclass:
//        m2Sister = _swig_property(_pythia8.SpaceDipoleEnd_m2Sister_get, _pythia8.SpaceDipoleEnd_m2Sister_set)
//    __swig_setmethods__["pT2corr"] = _pythia8.SpaceDipoleEnd_pT2corr_set
//    __swig_getmethods__["pT2corr"] = _pythia8.SpaceDipoleEnd_pT2corr_get
//    if _newclass:
//        pT2corr = _swig_property(_pythia8.SpaceDipoleEnd_pT2corr_get, _pythia8.SpaceDipoleEnd_pT2corr_set)
//    __swig_setmethods__["pT2Old"] = _pythia8.SpaceDipoleEnd_pT2Old_set
//    __swig_getmethods__["pT2Old"] = _pythia8.SpaceDipoleEnd_pT2Old_get
//    if _newclass:
//        pT2Old = _swig_property(_pythia8.SpaceDipoleEnd_pT2Old_get, _pythia8.SpaceDipoleEnd_pT2Old_set)
//    __swig_setmethods__["zOld"] = _pythia8.SpaceDipoleEnd_zOld_set
//    __swig_getmethods__["zOld"] = _pythia8.SpaceDipoleEnd_zOld_get
//    if _newclass:
//        zOld = _swig_property(_pythia8.SpaceDipoleEnd_zOld_get, _pythia8.SpaceDipoleEnd_zOld_set)
//    __swig_setmethods__["asymPol"] = _pythia8.SpaceDipoleEnd_asymPol_set
//    __swig_getmethods__["asymPol"] = _pythia8.SpaceDipoleEnd_asymPol_get
//    if _newclass:
//        asymPol = _swig_property(_pythia8.SpaceDipoleEnd_asymPol_get, _pythia8.SpaceDipoleEnd_asymPol_set)
//    __swig_setmethods__["m2IF"] = _pythia8.SpaceDipoleEnd_m2IF_set
//    __swig_getmethods__["m2IF"] = _pythia8.SpaceDipoleEnd_m2IF_get
//    if _newclass:
//        m2IF = _swig_property(_pythia8.SpaceDipoleEnd_m2IF_get, _pythia8.SpaceDipoleEnd_m2IF_set)
//    __swig_setmethods__["mColPartner"] = _pythia8.SpaceDipoleEnd_mColPartner_set
//    __swig_getmethods__["mColPartner"] = _pythia8.SpaceDipoleEnd_mColPartner_get
//    if _newclass:
//        mColPartner = _swig_property(_pythia8.SpaceDipoleEnd_mColPartner_get, _pythia8.SpaceDipoleEnd_mColPartner_set)
//    __swig_setmethods__["pAccept"] = _pythia8.SpaceDipoleEnd_pAccept_set
//    __swig_getmethods__["pAccept"] = _pythia8.SpaceDipoleEnd_pAccept_get
//    if _newclass:
//        pAccept = _swig_property(_pythia8.SpaceDipoleEnd_pAccept_get, _pythia8.SpaceDipoleEnd_pAccept_set)
//    __swig_destroy__ = _pythia8.delete_SpaceDipoleEnd
//    __del__ = lambda self: None
//SpaceDipoleEnd_swigregister = _pythia8.SpaceDipoleEnd_swigregister
//SpaceDipoleEnd_swigregister(SpaceDipoleEnd)
//
//class SpaceShower(_object):
//    """
//The SpaceShower class does spacelike showers.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SpaceShower, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, SpaceShower, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        if self.__class__ == SpaceShower:
//            _self = None
//        else:
//            _self = self
//        this = _pythia8.new_SpaceShower(_self, )
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_SpaceShower
//    __del__ = lambda self: None
//
//    def initPtr(self, infoPtrIn, settingsPtrIn, particleDataPtrIn, rndmPtrIn, coupSMPtrIn, partonSystemsPtrIn, userHooksPtrIn, mergingHooksPtrIn, partonVertexPtrIn):
//        """
//Initialize various pointers.
//(Separated from rest of init since not virtual.)
//"""
//        return _pythia8.SpaceShower_initPtr(self, infoPtrIn, settingsPtrIn, particleDataPtrIn, rndmPtrIn, coupSMPtrIn, partonSystemsPtrIn, userHooksPtrIn, mergingHooksPtrIn, partonVertexPtrIn)
//
//    def init(self, beamAPtrIn, beamBPtrIn):
//        """
//Initialize generation. Possibility to force re-initialization by hand.
//"""
//        return _pythia8.SpaceShower_init(self, beamAPtrIn, beamBPtrIn)
//
//    def reassignBeamPtrs(self, beamAPtrIn, beamBPtrIn, beamOffsetIn=0):
//        """
//New beams possible for handling of hard diffraction. (Not virtual.)
//"""
//        return _pythia8.SpaceShower_reassignBeamPtrs(self, beamAPtrIn, beamBPtrIn, beamOffsetIn)
//
//    def limitPTmax(self, event, Q2Fac=0., Q2Ren=0.):
//        """
//Find whether to limit maximum scale of emissions, and whether to dampen.
//"""
//        return _pythia8.SpaceShower_limitPTmax(self, event, Q2Fac, Q2Ren)
//
//    def enhancePTmax(self):
//        """
//Potential enhancement factor of pTmax scale for hardest emission.
//"""
//        return _pythia8.SpaceShower_enhancePTmax(self)
//
//    def prepare(self, iSys, event, limitPTmaxIn=True):
//        """
//Prepare system for evolution; identify ME.
//"""
//        return _pythia8.SpaceShower_prepare(self, iSys, event, limitPTmaxIn)
//
//    def update(self, arg0, arg1, hasWeakRad=False):
//        """
//Update dipole list after each FSR emission.
//Usage: update( iSys, event).
//"""
//        return _pythia8.SpaceShower_update(self, arg0, arg1, hasWeakRad)
//
//    def pTnext(self, event, pTbegAll, pTendAll, nRadIn=-1, doTrialIn=False):
//        """
//Select next pT in downwards evolution.
//"""
//        return _pythia8.SpaceShower_pTnext(self, event, pTbegAll, pTendAll, nRadIn, doTrialIn)
//
//    def branch(self, event):
//        """
//ME corrections and kinematics that may give failure.
//"""
//        return _pythia8.SpaceShower_branch(self, event)
//
//    def initUncertainties(self):
//        """
//Initialize data members for calculation of uncertainty bands.
//"""
//        return _pythia8.SpaceShower_initUncertainties(self)
//
//    def calcUncertainties(self, accept, pAcceptIn, pT20in, enhance, vp, dip, motherPtr, sisterPtr):
//        """
//Calculate uncertainty-band weights for accepted/rejected trial branching.
//"""
//        return _pythia8.SpaceShower_calcUncertainties(self, accept, pAcceptIn, pT20in, enhance, vp, dip, motherPtr, sisterPtr)
//
//    def wasGamma2qqbar(self):
//        """
//Tell if latest scattering was a gamma->qqbar.
//"""
//        return _pythia8.SpaceShower_wasGamma2qqbar(self)
//
//    def system(self):
//        """
//Tell which system was the last processed one.
//"""
//        return _pythia8.SpaceShower_system(self)
//
//    def doRestart(self):
//        """
//Flag for failure in branch(...) that will force a retry of parton level.
//"""
//        return _pythia8.SpaceShower_doRestart(self)
//
//    def getHasWeaklyRadiated(self):
//        """
//Tell whether ISR has done a weak emission.
//"""
//        return _pythia8.SpaceShower_getHasWeaklyRadiated(self)
//
//    def clustered(self, arg0, arg1, arg2, arg3, arg4):
//        """
//Functions to allow usage of shower kinematics, evolution variables,
//and splitting probabilities outside of shower.
//Virtual so that shower plugins can overwrite these functions.
//This makes it possible for another piece of the code to request
//these - which is very convenient for merging.
//Function variable names are not included to avoid compiler warnings.
//Please see the documentation under "Implement New Showers" for details.
//Return clustering kinematics - as needed form merging.
//"""
//        return _pythia8.SpaceShower_clustered(self, arg0, arg1, arg2, arg3, arg4)
//
//    def getStateVariables(self, arg0, arg1, arg2, arg3, arg4):
//        """
//Return the evolution variable(s).
//Important note: this map must contain the following entries
//- a key "t" for the value of the shower evolution variable;
//- a key "tRS" for the value of the shower evolution variable
//  from which the shower would be restarted after a branching;
//- a key "scaleAS" for the argument of alpha_s used for the branching;
//- a key "scalePDF" for the argument of the PDFs used for the branching.
//Usage: getStateVariables( event, iRad, iEmt, iRec,  name)
//"""
//        return _pythia8.SpaceShower_getStateVariables(self, arg0, arg1, arg2, arg3, arg4)
//
//    def isSpacelike(self, arg0, arg1, arg2, arg3, arg4):
//        """
//Check if attempted clustering is handled by spacelike shower.
//Usage: isSpacelike( event, iRad, iEmt, iRec, name)
//"""
//        return _pythia8.SpaceShower_isSpacelike(self, arg0, arg1, arg2, arg3, arg4)
//
//    def getSplittingName(self, arg0, arg1, arg2, arg3):
//        """
//Return a string identifier of a splitting.
//Usage: getSplittingName( event, iRad, iEmt, iRec)
//"""
//        return _pythia8.SpaceShower_getSplittingName(self, arg0, arg1, arg2, arg3)
//
//    def getSplittingProb(self, arg0, arg1, arg2, arg3, arg4):
//        """
//Return the splitting probability.
//Usage: getSplittingProb( event, iRad, iEmt, iRec)
//"""
//        return _pythia8.SpaceShower_getSplittingProb(self, arg0, arg1, arg2, arg3, arg4)
//
//    def allowedSplitting(self, arg0, arg1, arg2):
//        """
//"""
//        return _pythia8.SpaceShower_allowedSplitting(self, arg0, arg1, arg2)
//
//    def getRecoilers(self, arg0, arg1, arg2, arg3):
//        """
//"""
//        return _pythia8.SpaceShower_getRecoilers(self, arg0, arg1, arg2, arg3)
//    __swig_setmethods__["mergingHooksPtr"] = _pythia8.SpaceShower_mergingHooksPtr_set
//    __swig_getmethods__["mergingHooksPtr"] = _pythia8.SpaceShower_mergingHooksPtr_get
//    if _newclass:
//        mergingHooksPtr = _swig_property(_pythia8.SpaceShower_mergingHooksPtr_get, _pythia8.SpaceShower_mergingHooksPtr_set)
//    __swig_setmethods__["infoPtr"] = _pythia8.SpaceShower_infoPtr_set
//    __swig_getmethods__["infoPtr"] = _pythia8.SpaceShower_infoPtr_get
//    if _newclass:
//        infoPtr = _swig_property(_pythia8.SpaceShower_infoPtr_get, _pythia8.SpaceShower_infoPtr_set)
//    __swig_setmethods__["settingsPtr"] = _pythia8.SpaceShower_settingsPtr_set
//    __swig_getmethods__["settingsPtr"] = _pythia8.SpaceShower_settingsPtr_get
//    if _newclass:
//        settingsPtr = _swig_property(_pythia8.SpaceShower_settingsPtr_get, _pythia8.SpaceShower_settingsPtr_set)
//    __swig_setmethods__["particleDataPtr"] = _pythia8.SpaceShower_particleDataPtr_set
//    __swig_getmethods__["particleDataPtr"] = _pythia8.SpaceShower_particleDataPtr_get
//    if _newclass:
//        particleDataPtr = _swig_property(_pythia8.SpaceShower_particleDataPtr_get, _pythia8.SpaceShower_particleDataPtr_set)
//    __swig_setmethods__["rndmPtr"] = _pythia8.SpaceShower_rndmPtr_set
//    __swig_getmethods__["rndmPtr"] = _pythia8.SpaceShower_rndmPtr_get
//    if _newclass:
//        rndmPtr = _swig_property(_pythia8.SpaceShower_rndmPtr_get, _pythia8.SpaceShower_rndmPtr_set)
//    __swig_setmethods__["coupSMPtr"] = _pythia8.SpaceShower_coupSMPtr_set
//    __swig_getmethods__["coupSMPtr"] = _pythia8.SpaceShower_coupSMPtr_get
//    if _newclass:
//        coupSMPtr = _swig_property(_pythia8.SpaceShower_coupSMPtr_get, _pythia8.SpaceShower_coupSMPtr_set)
//    __swig_setmethods__["beamAPtr"] = _pythia8.SpaceShower_beamAPtr_set
//    __swig_getmethods__["beamAPtr"] = _pythia8.SpaceShower_beamAPtr_get
//    if _newclass:
//        beamAPtr = _swig_property(_pythia8.SpaceShower_beamAPtr_get, _pythia8.SpaceShower_beamAPtr_set)
//    __swig_setmethods__["beamBPtr"] = _pythia8.SpaceShower_beamBPtr_set
//    __swig_getmethods__["beamBPtr"] = _pythia8.SpaceShower_beamBPtr_get
//    if _newclass:
//        beamBPtr = _swig_property(_pythia8.SpaceShower_beamBPtr_get, _pythia8.SpaceShower_beamBPtr_set)
//    __swig_setmethods__["beamOffset"] = _pythia8.SpaceShower_beamOffset_set
//    __swig_getmethods__["beamOffset"] = _pythia8.SpaceShower_beamOffset_get
//    if _newclass:
//        beamOffset = _swig_property(_pythia8.SpaceShower_beamOffset_get, _pythia8.SpaceShower_beamOffset_set)
//    __swig_setmethods__["partonSystemsPtr"] = _pythia8.SpaceShower_partonSystemsPtr_set
//    __swig_getmethods__["partonSystemsPtr"] = _pythia8.SpaceShower_partonSystemsPtr_get
//    if _newclass:
//        partonSystemsPtr = _swig_property(_pythia8.SpaceShower_partonSystemsPtr_get, _pythia8.SpaceShower_partonSystemsPtr_set)
//    __swig_setmethods__["userHooksPtr"] = _pythia8.SpaceShower_userHooksPtr_set
//    __swig_getmethods__["userHooksPtr"] = _pythia8.SpaceShower_userHooksPtr_get
//    if _newclass:
//        userHooksPtr = _swig_property(_pythia8.SpaceShower_userHooksPtr_get, _pythia8.SpaceShower_userHooksPtr_set)
//    __swig_setmethods__["partonVertexPtr"] = _pythia8.SpaceShower_partonVertexPtr_set
//    __swig_getmethods__["partonVertexPtr"] = _pythia8.SpaceShower_partonVertexPtr_get
//    if _newclass:
//        partonVertexPtr = _swig_property(_pythia8.SpaceShower_partonVertexPtr_get, _pythia8.SpaceShower_partonVertexPtr_set)
//    __swig_setmethods__["weakShowerMEs"] = _pythia8.SpaceShower_weakShowerMEs_set
//    __swig_getmethods__["weakShowerMEs"] = _pythia8.SpaceShower_weakShowerMEs_get
//    if _newclass:
//        weakShowerMEs = _swig_property(_pythia8.SpaceShower_weakShowerMEs_get, _pythia8.SpaceShower_weakShowerMEs_set)
//    __swig_setmethods__["rescatterFail"] = _pythia8.SpaceShower_rescatterFail_set
//    __swig_getmethods__["rescatterFail"] = _pythia8.SpaceShower_rescatterFail_get
//    if _newclass:
//        rescatterFail = _swig_property(_pythia8.SpaceShower_rescatterFail_get, _pythia8.SpaceShower_rescatterFail_set)
//    __swig_setmethods__["iSysSel"] = _pythia8.SpaceShower_iSysSel_set
//    __swig_getmethods__["iSysSel"] = _pythia8.SpaceShower_iSysSel_get
//    if _newclass:
//        iSysSel = _swig_property(_pythia8.SpaceShower_iSysSel_get, _pythia8.SpaceShower_iSysSel_set)
//    __swig_setmethods__["pTmaxFudge"] = _pythia8.SpaceShower_pTmaxFudge_set
//    __swig_getmethods__["pTmaxFudge"] = _pythia8.SpaceShower_pTmaxFudge_get
//    if _newclass:
//        pTmaxFudge = _swig_property(_pythia8.SpaceShower_pTmaxFudge_get, _pythia8.SpaceShower_pTmaxFudge_set)
//
//    def __str__(self):
//        return _pythia8.SpaceShower___str__(self)
//    def __disown__(self):
//        self.this.disown()
//        _pythia8.disown_SpaceShower(self)
//        return weakref_proxy(self)
//SpaceShower_swigregister = _pythia8.SpaceShower_swigregister
//SpaceShower_swigregister(SpaceShower)
//
//class StringEnd(_object):
//    """
//The StringEnd class contains the information related to
//one of the current endpoints of the string system.
//Only to be used inside StringFragmentation, so no private members.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, StringEnd, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, StringEnd, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_StringEnd()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, particleDataPtrIn, flavSelPtrIn, pTSelPtrIn, zSelPtrIn, settings):
//        """
//Save pointers.
//"""
//        return _pythia8.StringEnd_init(self, particleDataPtrIn, flavSelPtrIn, pTSelPtrIn, zSelPtrIn, settings)
//
//    def setUp(self, fromPosIn, iEndIn, idOldIn, iMaxIn, pxIn, pyIn, GammaIn, xPosIn, xNegIn):
//        """
//Set up initial endpoint values from input.
//"""
//        return _pythia8.StringEnd_setUp(self, fromPosIn, iEndIn, idOldIn, iMaxIn, pxIn, pyIn, GammaIn, xPosIn, xNegIn)
//
//    def newHadron(self, nNSP=0.0):
//        """
//Fragment off one hadron from the string system, in flavour and pT.
//"""
//        return _pythia8.StringEnd_newHadron(self, nNSP)
//
//    def kinematicsHadron(self, system, stringVertices, useInputZ=False, zHadIn=0.):
//        """
//Fragment off one hadron from the string system, in momentum space,
//by taking steps either from positive or from negative end.
//"""
//        return _pythia8.StringEnd_kinematicsHadron(self, system, stringVertices, useInputZ, zHadIn)
//
//    def kinematicsHadronTmp(self, system, pRem, phi, mult):
//        """
//Generate momentum for some possible next hadron, based on mean values
//to get an estimate for rapidity and pT.
//"""
//        return _pythia8.StringEnd_kinematicsHadronTmp(self, system, pRem, phi, mult)
//
//    def update(self):
//        """
//Update string end information after a hadron has been removed.
//"""
//        return _pythia8.StringEnd_update(self)
//    __swig_setmethods__["particleDataPtr"] = _pythia8.StringEnd_particleDataPtr_set
//    __swig_getmethods__["particleDataPtr"] = _pythia8.StringEnd_particleDataPtr_get
//    if _newclass:
//        particleDataPtr = _swig_property(_pythia8.StringEnd_particleDataPtr_get, _pythia8.StringEnd_particleDataPtr_set)
//    __swig_setmethods__["flavSelPtr"] = _pythia8.StringEnd_flavSelPtr_set
//    __swig_getmethods__["flavSelPtr"] = _pythia8.StringEnd_flavSelPtr_get
//    if _newclass:
//        flavSelPtr = _swig_property(_pythia8.StringEnd_flavSelPtr_get, _pythia8.StringEnd_flavSelPtr_set)
//    __swig_setmethods__["pTSelPtr"] = _pythia8.StringEnd_pTSelPtr_set
//    __swig_getmethods__["pTSelPtr"] = _pythia8.StringEnd_pTSelPtr_get
//    if _newclass:
//        pTSelPtr = _swig_property(_pythia8.StringEnd_pTSelPtr_get, _pythia8.StringEnd_pTSelPtr_set)
//    __swig_setmethods__["zSelPtr"] = _pythia8.StringEnd_zSelPtr_set
//    __swig_getmethods__["zSelPtr"] = _pythia8.StringEnd_zSelPtr_get
//    if _newclass:
//        zSelPtr = _swig_property(_pythia8.StringEnd_zSelPtr_get, _pythia8.StringEnd_zSelPtr_set)
//    __swig_setmethods__["fromPos"] = _pythia8.StringEnd_fromPos_set
//    __swig_getmethods__["fromPos"] = _pythia8.StringEnd_fromPos_get
//    if _newclass:
//        fromPos = _swig_property(_pythia8.StringEnd_fromPos_get, _pythia8.StringEnd_fromPos_set)
//    __swig_setmethods__["thermalModel"] = _pythia8.StringEnd_thermalModel_set
//    __swig_getmethods__["thermalModel"] = _pythia8.StringEnd_thermalModel_get
//    if _newclass:
//        thermalModel = _swig_property(_pythia8.StringEnd_thermalModel_get, _pythia8.StringEnd_thermalModel_set)
//    __swig_setmethods__["mT2suppression"] = _pythia8.StringEnd_mT2suppression_set
//    __swig_getmethods__["mT2suppression"] = _pythia8.StringEnd_mT2suppression_get
//    if _newclass:
//        mT2suppression = _swig_property(_pythia8.StringEnd_mT2suppression_get, _pythia8.StringEnd_mT2suppression_set)
//    __swig_setmethods__["iEnd"] = _pythia8.StringEnd_iEnd_set
//    __swig_getmethods__["iEnd"] = _pythia8.StringEnd_iEnd_get
//    if _newclass:
//        iEnd = _swig_property(_pythia8.StringEnd_iEnd_get, _pythia8.StringEnd_iEnd_set)
//    __swig_setmethods__["iMax"] = _pythia8.StringEnd_iMax_set
//    __swig_getmethods__["iMax"] = _pythia8.StringEnd_iMax_get
//    if _newclass:
//        iMax = _swig_property(_pythia8.StringEnd_iMax_get, _pythia8.StringEnd_iMax_set)
//    __swig_setmethods__["idHad"] = _pythia8.StringEnd_idHad_set
//    __swig_getmethods__["idHad"] = _pythia8.StringEnd_idHad_get
//    if _newclass:
//        idHad = _swig_property(_pythia8.StringEnd_idHad_get, _pythia8.StringEnd_idHad_set)
//    __swig_setmethods__["iPosOld"] = _pythia8.StringEnd_iPosOld_set
//    __swig_getmethods__["iPosOld"] = _pythia8.StringEnd_iPosOld_get
//    if _newclass:
//        iPosOld = _swig_property(_pythia8.StringEnd_iPosOld_get, _pythia8.StringEnd_iPosOld_set)
//    __swig_setmethods__["iNegOld"] = _pythia8.StringEnd_iNegOld_set
//    __swig_getmethods__["iNegOld"] = _pythia8.StringEnd_iNegOld_get
//    if _newclass:
//        iNegOld = _swig_property(_pythia8.StringEnd_iNegOld_get, _pythia8.StringEnd_iNegOld_set)
//    __swig_setmethods__["iPosNew"] = _pythia8.StringEnd_iPosNew_set
//    __swig_getmethods__["iPosNew"] = _pythia8.StringEnd_iPosNew_get
//    if _newclass:
//        iPosNew = _swig_property(_pythia8.StringEnd_iPosNew_get, _pythia8.StringEnd_iPosNew_set)
//    __swig_setmethods__["iNegNew"] = _pythia8.StringEnd_iNegNew_set
//    __swig_getmethods__["iNegNew"] = _pythia8.StringEnd_iNegNew_get
//    if _newclass:
//        iNegNew = _swig_property(_pythia8.StringEnd_iNegNew_get, _pythia8.StringEnd_iNegNew_set)
//    __swig_setmethods__["hadSoFar"] = _pythia8.StringEnd_hadSoFar_set
//    __swig_getmethods__["hadSoFar"] = _pythia8.StringEnd_hadSoFar_get
//    if _newclass:
//        hadSoFar = _swig_property(_pythia8.StringEnd_hadSoFar_get, _pythia8.StringEnd_hadSoFar_set)
//    __swig_setmethods__["pxOld"] = _pythia8.StringEnd_pxOld_set
//    __swig_getmethods__["pxOld"] = _pythia8.StringEnd_pxOld_get
//    if _newclass:
//        pxOld = _swig_property(_pythia8.StringEnd_pxOld_get, _pythia8.StringEnd_pxOld_set)
//    __swig_setmethods__["pyOld"] = _pythia8.StringEnd_pyOld_set
//    __swig_getmethods__["pyOld"] = _pythia8.StringEnd_pyOld_get
//    if _newclass:
//        pyOld = _swig_property(_pythia8.StringEnd_pyOld_get, _pythia8.StringEnd_pyOld_set)
//    __swig_setmethods__["pxNew"] = _pythia8.StringEnd_pxNew_set
//    __swig_getmethods__["pxNew"] = _pythia8.StringEnd_pxNew_get
//    if _newclass:
//        pxNew = _swig_property(_pythia8.StringEnd_pxNew_get, _pythia8.StringEnd_pxNew_set)
//    __swig_setmethods__["pyNew"] = _pythia8.StringEnd_pyNew_set
//    __swig_getmethods__["pyNew"] = _pythia8.StringEnd_pyNew_get
//    if _newclass:
//        pyNew = _swig_property(_pythia8.StringEnd_pyNew_get, _pythia8.StringEnd_pyNew_set)
//    __swig_setmethods__["pxHad"] = _pythia8.StringEnd_pxHad_set
//    __swig_getmethods__["pxHad"] = _pythia8.StringEnd_pxHad_get
//    if _newclass:
//        pxHad = _swig_property(_pythia8.StringEnd_pxHad_get, _pythia8.StringEnd_pxHad_set)
//    __swig_setmethods__["pyHad"] = _pythia8.StringEnd_pyHad_set
//    __swig_getmethods__["pyHad"] = _pythia8.StringEnd_pyHad_get
//    if _newclass:
//        pyHad = _swig_property(_pythia8.StringEnd_pyHad_get, _pythia8.StringEnd_pyHad_set)
//    __swig_setmethods__["mHad"] = _pythia8.StringEnd_mHad_set
//    __swig_getmethods__["mHad"] = _pythia8.StringEnd_mHad_get
//    if _newclass:
//        mHad = _swig_property(_pythia8.StringEnd_mHad_get, _pythia8.StringEnd_mHad_set)
//    __swig_setmethods__["mT2Had"] = _pythia8.StringEnd_mT2Had_set
//    __swig_getmethods__["mT2Had"] = _pythia8.StringEnd_mT2Had_get
//    if _newclass:
//        mT2Had = _swig_property(_pythia8.StringEnd_mT2Had_get, _pythia8.StringEnd_mT2Had_set)
//    __swig_setmethods__["zHad"] = _pythia8.StringEnd_zHad_set
//    __swig_getmethods__["zHad"] = _pythia8.StringEnd_zHad_get
//    if _newclass:
//        zHad = _swig_property(_pythia8.StringEnd_zHad_get, _pythia8.StringEnd_zHad_set)
//    __swig_setmethods__["GammaOld"] = _pythia8.StringEnd_GammaOld_set
//    __swig_getmethods__["GammaOld"] = _pythia8.StringEnd_GammaOld_get
//    if _newclass:
//        GammaOld = _swig_property(_pythia8.StringEnd_GammaOld_get, _pythia8.StringEnd_GammaOld_set)
//    __swig_setmethods__["GammaNew"] = _pythia8.StringEnd_GammaNew_set
//    __swig_getmethods__["GammaNew"] = _pythia8.StringEnd_GammaNew_get
//    if _newclass:
//        GammaNew = _swig_property(_pythia8.StringEnd_GammaNew_get, _pythia8.StringEnd_GammaNew_set)
//    __swig_setmethods__["xPosOld"] = _pythia8.StringEnd_xPosOld_set
//    __swig_getmethods__["xPosOld"] = _pythia8.StringEnd_xPosOld_get
//    if _newclass:
//        xPosOld = _swig_property(_pythia8.StringEnd_xPosOld_get, _pythia8.StringEnd_xPosOld_set)
//    __swig_setmethods__["xPosNew"] = _pythia8.StringEnd_xPosNew_set
//    __swig_getmethods__["xPosNew"] = _pythia8.StringEnd_xPosNew_get
//    if _newclass:
//        xPosNew = _swig_property(_pythia8.StringEnd_xPosNew_get, _pythia8.StringEnd_xPosNew_set)
//    __swig_setmethods__["xPosHad"] = _pythia8.StringEnd_xPosHad_set
//    __swig_getmethods__["xPosHad"] = _pythia8.StringEnd_xPosHad_get
//    if _newclass:
//        xPosHad = _swig_property(_pythia8.StringEnd_xPosHad_get, _pythia8.StringEnd_xPosHad_set)
//    __swig_setmethods__["xNegOld"] = _pythia8.StringEnd_xNegOld_set
//    __swig_getmethods__["xNegOld"] = _pythia8.StringEnd_xNegOld_get
//    if _newclass:
//        xNegOld = _swig_property(_pythia8.StringEnd_xNegOld_get, _pythia8.StringEnd_xNegOld_set)
//    __swig_setmethods__["xNegNew"] = _pythia8.StringEnd_xNegNew_set
//    __swig_getmethods__["xNegNew"] = _pythia8.StringEnd_xNegNew_get
//    if _newclass:
//        xNegNew = _swig_property(_pythia8.StringEnd_xNegNew_get, _pythia8.StringEnd_xNegNew_set)
//    __swig_setmethods__["xNegHad"] = _pythia8.StringEnd_xNegHad_set
//    __swig_getmethods__["xNegHad"] = _pythia8.StringEnd_xNegHad_get
//    if _newclass:
//        xNegHad = _swig_property(_pythia8.StringEnd_xNegHad_get, _pythia8.StringEnd_xNegHad_set)
//    __swig_setmethods__["aLund"] = _pythia8.StringEnd_aLund_set
//    __swig_getmethods__["aLund"] = _pythia8.StringEnd_aLund_get
//    if _newclass:
//        aLund = _swig_property(_pythia8.StringEnd_aLund_get, _pythia8.StringEnd_aLund_set)
//    __swig_setmethods__["bLund"] = _pythia8.StringEnd_bLund_set
//    __swig_getmethods__["bLund"] = _pythia8.StringEnd_bLund_get
//    if _newclass:
//        bLund = _swig_property(_pythia8.StringEnd_bLund_get, _pythia8.StringEnd_bLund_set)
//    __swig_setmethods__["flavOld"] = _pythia8.StringEnd_flavOld_set
//    __swig_getmethods__["flavOld"] = _pythia8.StringEnd_flavOld_get
//    if _newclass:
//        flavOld = _swig_property(_pythia8.StringEnd_flavOld_get, _pythia8.StringEnd_flavOld_set)
//    __swig_setmethods__["flavNew"] = _pythia8.StringEnd_flavNew_set
//    __swig_getmethods__["flavNew"] = _pythia8.StringEnd_flavNew_get
//    if _newclass:
//        flavNew = _swig_property(_pythia8.StringEnd_flavNew_get, _pythia8.StringEnd_flavNew_set)
//    __swig_setmethods__["pHad"] = _pythia8.StringEnd_pHad_set
//    __swig_getmethods__["pHad"] = _pythia8.StringEnd_pHad_get
//    if _newclass:
//        pHad = _swig_property(_pythia8.StringEnd_pHad_get, _pythia8.StringEnd_pHad_set)
//    __swig_setmethods__["pSoFar"] = _pythia8.StringEnd_pSoFar_set
//    __swig_getmethods__["pSoFar"] = _pythia8.StringEnd_pSoFar_get
//    if _newclass:
//        pSoFar = _swig_property(_pythia8.StringEnd_pSoFar_get, _pythia8.StringEnd_pSoFar_set)
//    __swig_destroy__ = _pythia8.delete_StringEnd
//    __del__ = lambda self: None
//StringEnd_swigregister = _pythia8.StringEnd_swigregister
//StringEnd_swigregister(StringEnd)
//StringEnd.TINY = _pythia8.cvar.StringEnd_TINY
//StringEnd.PT2SAME = _pythia8.cvar.StringEnd_PT2SAME
//StringEnd.MEANMMIN = _pythia8.cvar.StringEnd_MEANMMIN
//StringEnd.MEANM = _pythia8.cvar.StringEnd_MEANM
//StringEnd.MEANPT = _pythia8.cvar.StringEnd_MEANPT
//
//class StringFragmentation(_object):
//    """
//The StringFragmentation class contains the top-level routines
//to fragment a colour singlet partonic system.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, StringFragmentation, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, StringFragmentation, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_StringFragmentation()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, infoPtrIn, settings, particleDataPtrIn, rndmPtrIn, flavSelPtrIn, pTSelPtrIn, zSelPtrIn, flavRopePtrIn=None, userHooksPtrIn=None):
//        """
//Initialize and save pointers.
//"""
//        return _pythia8.StringFragmentation_init(self, infoPtrIn, settings, particleDataPtrIn, rndmPtrIn, flavSelPtrIn, pTSelPtrIn, zSelPtrIn, flavRopePtrIn, userHooksPtrIn)
//
//    def fragment(self, iSub, colConfig, event):
//        """
//Do the fragmentation: driver routine.
//"""
//        return _pythia8.StringFragmentation_fragment(self, iSub, colConfig, event)
//
//    def junctionRestFrame(self, p0, p1, p2):
//        """
//Find the boost matrix to the rest frame of a junction.
//"""
//        return _pythia8.StringFragmentation_junctionRestFrame(self, p0, p1, p2)
//    __swig_destroy__ = _pythia8.delete_StringFragmentation
//    __del__ = lambda self: None
//StringFragmentation_swigregister = _pythia8.StringFragmentation_swigregister
//StringFragmentation_swigregister(StringFragmentation)
//
//class StringLength(_object):
//    """
//StringLength class. It is used to calculate the lambda measure.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, StringLength, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, StringLength, name)
//    __repr__ = _swig_repr
//
//    def init(self, infoPtrIn, settings):
//        """
//Initialize.
//"""
//        return _pythia8.StringLength_init(self, infoPtrIn, settings)
//
//    def getLength(self, p, v, isJunc=False):
//        """
//Calculate string length of a single particle.
//The first vector is the 4 vector of the particle.
//The second vector represents (1,0,0,0) in dipole restframe.
//"""
//        return _pythia8.StringLength_getLength(self, p, v, isJunc)
//
//    def getStringLength(self, *args):
//        """
//Calculate string length for two particles given their four-momenta.
//"""
//        return _pythia8.StringLength_getStringLength(self, *args)
//
//    def getJuncLength(self, *args):
//        """
//Calculate the length of a double junction given the 4 four-momenta.
//The first two are expected to be quarks, the second two to be antiquarks.
//"""
//        return _pythia8.StringLength_getJuncLength(self, *args)
//
//    def __init__(self):
//        this = _pythia8.new_StringLength()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_StringLength
//    __del__ = lambda self: None
//StringLength_swigregister = _pythia8.StringLength_swigregister
//StringLength_swigregister(StringLength)
//
//class TimeDipoleEnd(_object):
//    """
//Data on radiating dipole ends; only used inside TimeShower class.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, TimeDipoleEnd, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, TimeDipoleEnd, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_TimeDipoleEnd(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["iRadiator"] = _pythia8.TimeDipoleEnd_iRadiator_set
//    __swig_getmethods__["iRadiator"] = _pythia8.TimeDipoleEnd_iRadiator_get
//    if _newclass:
//        iRadiator = _swig_property(_pythia8.TimeDipoleEnd_iRadiator_get, _pythia8.TimeDipoleEnd_iRadiator_set)
//    __swig_setmethods__["iRecoiler"] = _pythia8.TimeDipoleEnd_iRecoiler_set
//    __swig_getmethods__["iRecoiler"] = _pythia8.TimeDipoleEnd_iRecoiler_get
//    if _newclass:
//        iRecoiler = _swig_property(_pythia8.TimeDipoleEnd_iRecoiler_get, _pythia8.TimeDipoleEnd_iRecoiler_set)
//    __swig_setmethods__["pTmax"] = _pythia8.TimeDipoleEnd_pTmax_set
//    __swig_getmethods__["pTmax"] = _pythia8.TimeDipoleEnd_pTmax_get
//    if _newclass:
//        pTmax = _swig_property(_pythia8.TimeDipoleEnd_pTmax_get, _pythia8.TimeDipoleEnd_pTmax_set)
//    __swig_setmethods__["colType"] = _pythia8.TimeDipoleEnd_colType_set
//    __swig_getmethods__["colType"] = _pythia8.TimeDipoleEnd_colType_get
//    if _newclass:
//        colType = _swig_property(_pythia8.TimeDipoleEnd_colType_get, _pythia8.TimeDipoleEnd_colType_set)
//    __swig_setmethods__["chgType"] = _pythia8.TimeDipoleEnd_chgType_set
//    __swig_getmethods__["chgType"] = _pythia8.TimeDipoleEnd_chgType_get
//    if _newclass:
//        chgType = _swig_property(_pythia8.TimeDipoleEnd_chgType_get, _pythia8.TimeDipoleEnd_chgType_set)
//    __swig_setmethods__["gamType"] = _pythia8.TimeDipoleEnd_gamType_set
//    __swig_getmethods__["gamType"] = _pythia8.TimeDipoleEnd_gamType_get
//    if _newclass:
//        gamType = _swig_property(_pythia8.TimeDipoleEnd_gamType_get, _pythia8.TimeDipoleEnd_gamType_set)
//    __swig_setmethods__["weakType"] = _pythia8.TimeDipoleEnd_weakType_set
//    __swig_getmethods__["weakType"] = _pythia8.TimeDipoleEnd_weakType_get
//    if _newclass:
//        weakType = _swig_property(_pythia8.TimeDipoleEnd_weakType_get, _pythia8.TimeDipoleEnd_weakType_set)
//    __swig_setmethods__["isrType"] = _pythia8.TimeDipoleEnd_isrType_set
//    __swig_getmethods__["isrType"] = _pythia8.TimeDipoleEnd_isrType_get
//    if _newclass:
//        isrType = _swig_property(_pythia8.TimeDipoleEnd_isrType_get, _pythia8.TimeDipoleEnd_isrType_set)
//    __swig_setmethods__["system"] = _pythia8.TimeDipoleEnd_system_set
//    __swig_getmethods__["system"] = _pythia8.TimeDipoleEnd_system_get
//    if _newclass:
//        system = _swig_property(_pythia8.TimeDipoleEnd_system_get, _pythia8.TimeDipoleEnd_system_set)
//    __swig_setmethods__["systemRec"] = _pythia8.TimeDipoleEnd_systemRec_set
//    __swig_getmethods__["systemRec"] = _pythia8.TimeDipoleEnd_systemRec_get
//    if _newclass:
//        systemRec = _swig_property(_pythia8.TimeDipoleEnd_systemRec_get, _pythia8.TimeDipoleEnd_systemRec_set)
//    __swig_setmethods__["MEtype"] = _pythia8.TimeDipoleEnd_MEtype_set
//    __swig_getmethods__["MEtype"] = _pythia8.TimeDipoleEnd_MEtype_get
//    if _newclass:
//        MEtype = _swig_property(_pythia8.TimeDipoleEnd_MEtype_get, _pythia8.TimeDipoleEnd_MEtype_set)
//    __swig_setmethods__["iMEpartner"] = _pythia8.TimeDipoleEnd_iMEpartner_set
//    __swig_getmethods__["iMEpartner"] = _pythia8.TimeDipoleEnd_iMEpartner_get
//    if _newclass:
//        iMEpartner = _swig_property(_pythia8.TimeDipoleEnd_iMEpartner_get, _pythia8.TimeDipoleEnd_iMEpartner_set)
//    __swig_setmethods__["weakPol"] = _pythia8.TimeDipoleEnd_weakPol_set
//    __swig_getmethods__["weakPol"] = _pythia8.TimeDipoleEnd_weakPol_get
//    if _newclass:
//        weakPol = _swig_property(_pythia8.TimeDipoleEnd_weakPol_get, _pythia8.TimeDipoleEnd_weakPol_set)
//    __swig_setmethods__["isOctetOnium"] = _pythia8.TimeDipoleEnd_isOctetOnium_set
//    __swig_getmethods__["isOctetOnium"] = _pythia8.TimeDipoleEnd_isOctetOnium_get
//    if _newclass:
//        isOctetOnium = _swig_property(_pythia8.TimeDipoleEnd_isOctetOnium_get, _pythia8.TimeDipoleEnd_isOctetOnium_set)
//    __swig_setmethods__["isHiddenValley"] = _pythia8.TimeDipoleEnd_isHiddenValley_set
//    __swig_getmethods__["isHiddenValley"] = _pythia8.TimeDipoleEnd_isHiddenValley_get
//    if _newclass:
//        isHiddenValley = _swig_property(_pythia8.TimeDipoleEnd_isHiddenValley_get, _pythia8.TimeDipoleEnd_isHiddenValley_set)
//    __swig_setmethods__["colvType"] = _pythia8.TimeDipoleEnd_colvType_set
//    __swig_getmethods__["colvType"] = _pythia8.TimeDipoleEnd_colvType_get
//    if _newclass:
//        colvType = _swig_property(_pythia8.TimeDipoleEnd_colvType_get, _pythia8.TimeDipoleEnd_colvType_set)
//    __swig_setmethods__["MEmix"] = _pythia8.TimeDipoleEnd_MEmix_set
//    __swig_getmethods__["MEmix"] = _pythia8.TimeDipoleEnd_MEmix_get
//    if _newclass:
//        MEmix = _swig_property(_pythia8.TimeDipoleEnd_MEmix_get, _pythia8.TimeDipoleEnd_MEmix_set)
//    __swig_setmethods__["MEorder"] = _pythia8.TimeDipoleEnd_MEorder_set
//    __swig_getmethods__["MEorder"] = _pythia8.TimeDipoleEnd_MEorder_get
//    if _newclass:
//        MEorder = _swig_property(_pythia8.TimeDipoleEnd_MEorder_get, _pythia8.TimeDipoleEnd_MEorder_set)
//    __swig_setmethods__["MEsplit"] = _pythia8.TimeDipoleEnd_MEsplit_set
//    __swig_getmethods__["MEsplit"] = _pythia8.TimeDipoleEnd_MEsplit_get
//    if _newclass:
//        MEsplit = _swig_property(_pythia8.TimeDipoleEnd_MEsplit_get, _pythia8.TimeDipoleEnd_MEsplit_set)
//    __swig_setmethods__["MEgluinoRec"] = _pythia8.TimeDipoleEnd_MEgluinoRec_set
//    __swig_getmethods__["MEgluinoRec"] = _pythia8.TimeDipoleEnd_MEgluinoRec_get
//    if _newclass:
//        MEgluinoRec = _swig_property(_pythia8.TimeDipoleEnd_MEgluinoRec_get, _pythia8.TimeDipoleEnd_MEgluinoRec_set)
//    __swig_setmethods__["isFlexible"] = _pythia8.TimeDipoleEnd_isFlexible_set
//    __swig_getmethods__["isFlexible"] = _pythia8.TimeDipoleEnd_isFlexible_get
//    if _newclass:
//        isFlexible = _swig_property(_pythia8.TimeDipoleEnd_isFlexible_get, _pythia8.TimeDipoleEnd_isFlexible_set)
//    __swig_setmethods__["flavour"] = _pythia8.TimeDipoleEnd_flavour_set
//    __swig_getmethods__["flavour"] = _pythia8.TimeDipoleEnd_flavour_get
//    if _newclass:
//        flavour = _swig_property(_pythia8.TimeDipoleEnd_flavour_get, _pythia8.TimeDipoleEnd_flavour_set)
//    __swig_setmethods__["iAunt"] = _pythia8.TimeDipoleEnd_iAunt_set
//    __swig_getmethods__["iAunt"] = _pythia8.TimeDipoleEnd_iAunt_get
//    if _newclass:
//        iAunt = _swig_property(_pythia8.TimeDipoleEnd_iAunt_get, _pythia8.TimeDipoleEnd_iAunt_set)
//    __swig_setmethods__["mRad"] = _pythia8.TimeDipoleEnd_mRad_set
//    __swig_getmethods__["mRad"] = _pythia8.TimeDipoleEnd_mRad_get
//    if _newclass:
//        mRad = _swig_property(_pythia8.TimeDipoleEnd_mRad_get, _pythia8.TimeDipoleEnd_mRad_set)
//    __swig_setmethods__["m2Rad"] = _pythia8.TimeDipoleEnd_m2Rad_set
//    __swig_getmethods__["m2Rad"] = _pythia8.TimeDipoleEnd_m2Rad_get
//    if _newclass:
//        m2Rad = _swig_property(_pythia8.TimeDipoleEnd_m2Rad_get, _pythia8.TimeDipoleEnd_m2Rad_set)
//    __swig_setmethods__["mRec"] = _pythia8.TimeDipoleEnd_mRec_set
//    __swig_getmethods__["mRec"] = _pythia8.TimeDipoleEnd_mRec_get
//    if _newclass:
//        mRec = _swig_property(_pythia8.TimeDipoleEnd_mRec_get, _pythia8.TimeDipoleEnd_mRec_set)
//    __swig_setmethods__["m2Rec"] = _pythia8.TimeDipoleEnd_m2Rec_set
//    __swig_getmethods__["m2Rec"] = _pythia8.TimeDipoleEnd_m2Rec_get
//    if _newclass:
//        m2Rec = _swig_property(_pythia8.TimeDipoleEnd_m2Rec_get, _pythia8.TimeDipoleEnd_m2Rec_set)
//    __swig_setmethods__["mDip"] = _pythia8.TimeDipoleEnd_mDip_set
//    __swig_getmethods__["mDip"] = _pythia8.TimeDipoleEnd_mDip_get
//    if _newclass:
//        mDip = _swig_property(_pythia8.TimeDipoleEnd_mDip_get, _pythia8.TimeDipoleEnd_mDip_set)
//    __swig_setmethods__["m2Dip"] = _pythia8.TimeDipoleEnd_m2Dip_set
//    __swig_getmethods__["m2Dip"] = _pythia8.TimeDipoleEnd_m2Dip_get
//    if _newclass:
//        m2Dip = _swig_property(_pythia8.TimeDipoleEnd_m2Dip_get, _pythia8.TimeDipoleEnd_m2Dip_set)
//    __swig_setmethods__["m2DipCorr"] = _pythia8.TimeDipoleEnd_m2DipCorr_set
//    __swig_getmethods__["m2DipCorr"] = _pythia8.TimeDipoleEnd_m2DipCorr_get
//    if _newclass:
//        m2DipCorr = _swig_property(_pythia8.TimeDipoleEnd_m2DipCorr_get, _pythia8.TimeDipoleEnd_m2DipCorr_set)
//    __swig_setmethods__["pT2"] = _pythia8.TimeDipoleEnd_pT2_set
//    __swig_getmethods__["pT2"] = _pythia8.TimeDipoleEnd_pT2_get
//    if _newclass:
//        pT2 = _swig_property(_pythia8.TimeDipoleEnd_pT2_get, _pythia8.TimeDipoleEnd_pT2_set)
//    __swig_setmethods__["m2"] = _pythia8.TimeDipoleEnd_m2_set
//    __swig_getmethods__["m2"] = _pythia8.TimeDipoleEnd_m2_get
//    if _newclass:
//        m2 = _swig_property(_pythia8.TimeDipoleEnd_m2_get, _pythia8.TimeDipoleEnd_m2_set)
//    __swig_setmethods__["z"] = _pythia8.TimeDipoleEnd_z_set
//    __swig_getmethods__["z"] = _pythia8.TimeDipoleEnd_z_get
//    if _newclass:
//        z = _swig_property(_pythia8.TimeDipoleEnd_z_get, _pythia8.TimeDipoleEnd_z_set)
//    __swig_setmethods__["mFlavour"] = _pythia8.TimeDipoleEnd_mFlavour_set
//    __swig_getmethods__["mFlavour"] = _pythia8.TimeDipoleEnd_mFlavour_get
//    if _newclass:
//        mFlavour = _swig_property(_pythia8.TimeDipoleEnd_mFlavour_get, _pythia8.TimeDipoleEnd_mFlavour_set)
//    __swig_setmethods__["asymPol"] = _pythia8.TimeDipoleEnd_asymPol_set
//    __swig_getmethods__["asymPol"] = _pythia8.TimeDipoleEnd_asymPol_get
//    if _newclass:
//        asymPol = _swig_property(_pythia8.TimeDipoleEnd_asymPol_get, _pythia8.TimeDipoleEnd_asymPol_set)
//    __swig_setmethods__["flexFactor"] = _pythia8.TimeDipoleEnd_flexFactor_set
//    __swig_getmethods__["flexFactor"] = _pythia8.TimeDipoleEnd_flexFactor_get
//    if _newclass:
//        flexFactor = _swig_property(_pythia8.TimeDipoleEnd_flexFactor_get, _pythia8.TimeDipoleEnd_flexFactor_set)
//    __swig_setmethods__["pAccept"] = _pythia8.TimeDipoleEnd_pAccept_set
//    __swig_getmethods__["pAccept"] = _pythia8.TimeDipoleEnd_pAccept_get
//    if _newclass:
//        pAccept = _swig_property(_pythia8.TimeDipoleEnd_pAccept_get, _pythia8.TimeDipoleEnd_pAccept_set)
//    __swig_destroy__ = _pythia8.delete_TimeDipoleEnd
//    __del__ = lambda self: None
//TimeDipoleEnd_swigregister = _pythia8.TimeDipoleEnd_swigregister
//TimeDipoleEnd_swigregister(TimeDipoleEnd)
//
//class TimeShower(_object):
//    """
//The TimeShower class does timelike showers.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, TimeShower, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, TimeShower, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        if self.__class__ == TimeShower:
//            _self = None
//        else:
//            _self = self
//        this = _pythia8.new_TimeShower(_self, )
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_TimeShower
//    __del__ = lambda self: None
//
//    def initPtr(self, infoPtrIn, settingsPtrIn, particleDataPtrIn, rndmPtrIn, coupSMPtrIn, partonSystemsPtrIn, userHooksPtrIn, mergingHooksPtrIn, partonVertexPtrIn):
//        """
//Initialize various pointers.
//(Separated from rest of init since not virtual.)
//"""
//        return _pythia8.TimeShower_initPtr(self, infoPtrIn, settingsPtrIn, particleDataPtrIn, rndmPtrIn, coupSMPtrIn, partonSystemsPtrIn, userHooksPtrIn, mergingHooksPtrIn, partonVertexPtrIn)
//
//    def init(self, beamAPtrIn=None, beamBPtrIn=None):
//        """
//Initialize alphaStrong and related pTmin parameters.
//"""
//        return _pythia8.TimeShower_init(self, beamAPtrIn, beamBPtrIn)
//
//    def reassignBeamPtrs(self, beamAPtrIn, beamBPtrIn, beamOffsetIn=0):
//        """
//New beams possible for handling of hard diffraction. (Not virtual.)
//"""
//        return _pythia8.TimeShower_reassignBeamPtrs(self, beamAPtrIn, beamBPtrIn, beamOffsetIn)
//
//    def limitPTmax(self, event, Q2Fac=0., Q2Ren=0.):
//        """
//Find whether to limit maximum scale of emissions, and whether to dampen.
//"""
//        return _pythia8.TimeShower_limitPTmax(self, event, Q2Fac, Q2Ren)
//
//    def enhancePTmax(self):
//        """
//Potential enhancement factor of pTmax scale for hardest emission.
//"""
//        return _pythia8.TimeShower_enhancePTmax(self)
//
//    def shower(self, iBeg, iEnd, event, pTmax, nBranchMax=0):
//        """
//Top-level routine to do a full time-like shower in resonance decay.
//"""
//        return _pythia8.TimeShower_shower(self, iBeg, iEnd, event, pTmax, nBranchMax)
//
//    def showerQED(self, i1, i2, event, pTmax):
//        """
//Top-level routine for QED radiation in hadronic decay to two leptons.
//"""
//        return _pythia8.TimeShower_showerQED(self, i1, i2, event, pTmax)
//
//    def pTLastInShower(self):
//        """
//Provide the pT scale of the last branching in the above shower.
//"""
//        return _pythia8.TimeShower_pTLastInShower(self)
//
//    def prepareGlobal(self, event):
//        """
//Global recoil: reset counters and store locations of outgoing partons.
//"""
//        return _pythia8.TimeShower_prepareGlobal(self, event)
//
//    def prepare(self, iSys, event, limitPTmaxIn=True):
//        """
//Prepare system for evolution after each new interaction; identify ME.
//"""
//        return _pythia8.TimeShower_prepare(self, iSys, event, limitPTmaxIn)
//
//    def rescatterUpdate(self, iSys, event):
//        """
//Update dipole list after a multiparton interactions rescattering.
//"""
//        return _pythia8.TimeShower_rescatterUpdate(self, iSys, event)
//
//    def update(self, iSys, event, hasWeakRad=False):
//        """
//Update dipole list after each ISR emission.
//"""
//        return _pythia8.TimeShower_update(self, iSys, event, hasWeakRad)
//
//    def pTnext(self, event, pTbegAll, pTendAll, isFirstTrial=False, doTrialIn=False):
//        """
//Select next pT in downwards evolution.
//"""
//        return _pythia8.TimeShower_pTnext(self, event, pTbegAll, pTendAll, isFirstTrial, doTrialIn)
//
//    def branch(self, event, isInterleaved=False):
//        """
//ME corrections and kinematics that may give failure.
//"""
//        return _pythia8.TimeShower_branch(self, event, isInterleaved)
//
//    def initUncertainties(self):
//        """
//Initialize data members for calculation of uncertainty bands.
//"""
//        return _pythia8.TimeShower_initUncertainties(self)
//
//    def calcUncertainties(self, accept, pAccept, enhance, vp, dip, radPtr, emtPtr, recPtr):
//        """
//Calculate uncertainty-band weights for accepted/rejected trial branching.
//"""
//        return _pythia8.TimeShower_calcUncertainties(self, accept, pAccept, enhance, vp, dip, radPtr, emtPtr, recPtr)
//
//    def system(self):
//        """
//Tell which system was the last processed one.
//"""
//        return _pythia8.TimeShower_system(self)
//
//    def getHasWeaklyRadiated(self):
//        """
//Tell whether FSR has done a weak emission.
//"""
//        return _pythia8.TimeShower_getHasWeaklyRadiated(self)
//
//    def clustered(self, arg0, arg1, arg2, arg3, arg4):
//        """
//Functions to allow usage of shower kinematics, evolution variables,
//and splitting probabilities outside of shower.
//Virtual so that shower plugins can overwrite these functions.
//This makes it possible for another piece of the code to request
//these - which is very convenient for merging.
//Function variable names are not included to avoid compiler warnings.
//Please see the documentation under "Implement New Showers" for details.
//Return clustering kinematics - as needed for merging.
//"""
//        return _pythia8.TimeShower_clustered(self, arg0, arg1, arg2, arg3, arg4)
//
//    def getStateVariables(self, arg0, arg1, arg2, arg3, arg4):
//        """
//Return the evolution variable(s).
//Important note: this map must contain the following entries
//- a key "t" for the value of the shower evolution variable;
//- a key "tRS" for the value of the shower evolution variable
//  from which the shower would be restarted after a branching;
//- a key "scaleAS" for the argument of alpha_s used for the branching;
//- a key "scalePDF" for the argument of the PDFs used for the branching.
//Usage: getStateVariables( event, iRad, iEmt, iRec,  name)
//"""
//        return _pythia8.TimeShower_getStateVariables(self, arg0, arg1, arg2, arg3, arg4)
//
//    def isTimelike(self, arg0, arg1, arg2, arg3, arg4):
//        """
//Check if attempted clustering is handled by timelike shower
//Usage: isTimelike( event, iRad, iEmt, iRec, name)
//"""
//        return _pythia8.TimeShower_isTimelike(self, arg0, arg1, arg2, arg3, arg4)
//
//    def getSplittingName(self, arg0, arg1, arg2, arg3):
//        """
//Return a string identifier of a splitting.
//Usage: getSplittingName( event, iRad, iEmt, iRec)
//"""
//        return _pythia8.TimeShower_getSplittingName(self, arg0, arg1, arg2, arg3)
//
//    def getSplittingProb(self, arg0, arg1, arg2, arg3, arg4):
//        """
//Return the splitting probability.
//Usage: getSplittingProb( event, iRad, iEmt, iRec)
//"""
//        return _pythia8.TimeShower_getSplittingProb(self, arg0, arg1, arg2, arg3, arg4)
//
//    def allowedSplitting(self, arg0, arg1, arg2):
//        """
//"""
//        return _pythia8.TimeShower_allowedSplitting(self, arg0, arg1, arg2)
//
//    def getRecoilers(self, arg0, arg1, arg2, arg3):
//        """
//"""
//        return _pythia8.TimeShower_getRecoilers(self, arg0, arg1, arg2, arg3)
//    __swig_setmethods__["mergingHooksPtr"] = _pythia8.TimeShower_mergingHooksPtr_set
//    __swig_getmethods__["mergingHooksPtr"] = _pythia8.TimeShower_mergingHooksPtr_get
//    if _newclass:
//        mergingHooksPtr = _swig_property(_pythia8.TimeShower_mergingHooksPtr_get, _pythia8.TimeShower_mergingHooksPtr_set)
//    __swig_setmethods__["infoPtr"] = _pythia8.TimeShower_infoPtr_set
//    __swig_getmethods__["infoPtr"] = _pythia8.TimeShower_infoPtr_get
//    if _newclass:
//        infoPtr = _swig_property(_pythia8.TimeShower_infoPtr_get, _pythia8.TimeShower_infoPtr_set)
//    __swig_setmethods__["settingsPtr"] = _pythia8.TimeShower_settingsPtr_set
//    __swig_getmethods__["settingsPtr"] = _pythia8.TimeShower_settingsPtr_get
//    if _newclass:
//        settingsPtr = _swig_property(_pythia8.TimeShower_settingsPtr_get, _pythia8.TimeShower_settingsPtr_set)
//    __swig_setmethods__["particleDataPtr"] = _pythia8.TimeShower_particleDataPtr_set
//    __swig_getmethods__["particleDataPtr"] = _pythia8.TimeShower_particleDataPtr_get
//    if _newclass:
//        particleDataPtr = _swig_property(_pythia8.TimeShower_particleDataPtr_get, _pythia8.TimeShower_particleDataPtr_set)
//    __swig_setmethods__["rndmPtr"] = _pythia8.TimeShower_rndmPtr_set
//    __swig_getmethods__["rndmPtr"] = _pythia8.TimeShower_rndmPtr_get
//    if _newclass:
//        rndmPtr = _swig_property(_pythia8.TimeShower_rndmPtr_get, _pythia8.TimeShower_rndmPtr_set)
//    __swig_setmethods__["coupSMPtr"] = _pythia8.TimeShower_coupSMPtr_set
//    __swig_getmethods__["coupSMPtr"] = _pythia8.TimeShower_coupSMPtr_get
//    if _newclass:
//        coupSMPtr = _swig_property(_pythia8.TimeShower_coupSMPtr_get, _pythia8.TimeShower_coupSMPtr_set)
//    __swig_setmethods__["beamAPtr"] = _pythia8.TimeShower_beamAPtr_set
//    __swig_getmethods__["beamAPtr"] = _pythia8.TimeShower_beamAPtr_get
//    if _newclass:
//        beamAPtr = _swig_property(_pythia8.TimeShower_beamAPtr_get, _pythia8.TimeShower_beamAPtr_set)
//    __swig_setmethods__["beamBPtr"] = _pythia8.TimeShower_beamBPtr_set
//    __swig_getmethods__["beamBPtr"] = _pythia8.TimeShower_beamBPtr_get
//    if _newclass:
//        beamBPtr = _swig_property(_pythia8.TimeShower_beamBPtr_get, _pythia8.TimeShower_beamBPtr_set)
//    __swig_setmethods__["beamOffset"] = _pythia8.TimeShower_beamOffset_set
//    __swig_getmethods__["beamOffset"] = _pythia8.TimeShower_beamOffset_get
//    if _newclass:
//        beamOffset = _swig_property(_pythia8.TimeShower_beamOffset_get, _pythia8.TimeShower_beamOffset_set)
//    __swig_setmethods__["partonSystemsPtr"] = _pythia8.TimeShower_partonSystemsPtr_set
//    __swig_getmethods__["partonSystemsPtr"] = _pythia8.TimeShower_partonSystemsPtr_get
//    if _newclass:
//        partonSystemsPtr = _swig_property(_pythia8.TimeShower_partonSystemsPtr_get, _pythia8.TimeShower_partonSystemsPtr_set)
//    __swig_setmethods__["userHooksPtr"] = _pythia8.TimeShower_userHooksPtr_set
//    __swig_getmethods__["userHooksPtr"] = _pythia8.TimeShower_userHooksPtr_get
//    if _newclass:
//        userHooksPtr = _swig_property(_pythia8.TimeShower_userHooksPtr_get, _pythia8.TimeShower_userHooksPtr_set)
//    __swig_setmethods__["partonVertexPtr"] = _pythia8.TimeShower_partonVertexPtr_set
//    __swig_getmethods__["partonVertexPtr"] = _pythia8.TimeShower_partonVertexPtr_get
//    if _newclass:
//        partonVertexPtr = _swig_property(_pythia8.TimeShower_partonVertexPtr_get, _pythia8.TimeShower_partonVertexPtr_set)
//    __swig_setmethods__["weakShowerMEs"] = _pythia8.TimeShower_weakShowerMEs_set
//    __swig_getmethods__["weakShowerMEs"] = _pythia8.TimeShower_weakShowerMEs_get
//    if _newclass:
//        weakShowerMEs = _swig_property(_pythia8.TimeShower_weakShowerMEs_get, _pythia8.TimeShower_weakShowerMEs_set)
//    __swig_setmethods__["iSysSel"] = _pythia8.TimeShower_iSysSel_set
//    __swig_getmethods__["iSysSel"] = _pythia8.TimeShower_iSysSel_get
//    if _newclass:
//        iSysSel = _swig_property(_pythia8.TimeShower_iSysSel_get, _pythia8.TimeShower_iSysSel_set)
//    __swig_setmethods__["pTmaxFudge"] = _pythia8.TimeShower_pTmaxFudge_set
//    __swig_getmethods__["pTmaxFudge"] = _pythia8.TimeShower_pTmaxFudge_get
//    if _newclass:
//        pTmaxFudge = _swig_property(_pythia8.TimeShower_pTmaxFudge_get, _pythia8.TimeShower_pTmaxFudge_set)
//    __swig_setmethods__["pTLastBranch"] = _pythia8.TimeShower_pTLastBranch_set
//    __swig_getmethods__["pTLastBranch"] = _pythia8.TimeShower_pTLastBranch_get
//    if _newclass:
//        pTLastBranch = _swig_property(_pythia8.TimeShower_pTLastBranch_get, _pythia8.TimeShower_pTLastBranch_set)
//
//    def __str__(self):
//        return _pythia8.TimeShower___str__(self)
//    def __disown__(self):
//        self.this.disown()
//        _pythia8.disown_TimeShower(self)
//        return weakref_proxy(self)
//TimeShower_swigregister = _pythia8.TimeShower_swigregister
//TimeShower_swigregister(TimeShower)
//
//class ColourDipole(_object):
//    """
//Contain a single colour chain. It always start from a quark and goes to
//an anti quark or from an anti-junction to at junction
//(or possible combinations).
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ColourDipole, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, ColourDipole, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, colIn=0, iColIn=0, iAcolIn=0, colReconnectionIn=0, isJunIn=False, isAntiJunIn=False, isActiveIn=True, isRealIn=False):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ColourDipole(colIn, iColIn, iAcolIn, colReconnectionIn, isJunIn, isAntiJunIn, isActiveIn, isRealIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def mDip(self, event):
//        """
//"""
//        return _pythia8.ColourDipole_mDip(self, event)
//    __swig_setmethods__["col"] = _pythia8.ColourDipole_col_set
//    __swig_getmethods__["col"] = _pythia8.ColourDipole_col_get
//    if _newclass:
//        col = _swig_property(_pythia8.ColourDipole_col_get, _pythia8.ColourDipole_col_set)
//    __swig_setmethods__["iCol"] = _pythia8.ColourDipole_iCol_set
//    __swig_getmethods__["iCol"] = _pythia8.ColourDipole_iCol_get
//    if _newclass:
//        iCol = _swig_property(_pythia8.ColourDipole_iCol_get, _pythia8.ColourDipole_iCol_set)
//    __swig_setmethods__["iAcol"] = _pythia8.ColourDipole_iAcol_set
//    __swig_getmethods__["iAcol"] = _pythia8.ColourDipole_iAcol_get
//    if _newclass:
//        iAcol = _swig_property(_pythia8.ColourDipole_iAcol_get, _pythia8.ColourDipole_iAcol_set)
//    __swig_setmethods__["iColLeg"] = _pythia8.ColourDipole_iColLeg_set
//    __swig_getmethods__["iColLeg"] = _pythia8.ColourDipole_iColLeg_get
//    if _newclass:
//        iColLeg = _swig_property(_pythia8.ColourDipole_iColLeg_get, _pythia8.ColourDipole_iColLeg_set)
//    __swig_setmethods__["iAcolLeg"] = _pythia8.ColourDipole_iAcolLeg_set
//    __swig_getmethods__["iAcolLeg"] = _pythia8.ColourDipole_iAcolLeg_get
//    if _newclass:
//        iAcolLeg = _swig_property(_pythia8.ColourDipole_iAcolLeg_get, _pythia8.ColourDipole_iAcolLeg_set)
//    __swig_setmethods__["colReconnection"] = _pythia8.ColourDipole_colReconnection_set
//    __swig_getmethods__["colReconnection"] = _pythia8.ColourDipole_colReconnection_get
//    if _newclass:
//        colReconnection = _swig_property(_pythia8.ColourDipole_colReconnection_get, _pythia8.ColourDipole_colReconnection_set)
//    __swig_setmethods__["isJun"] = _pythia8.ColourDipole_isJun_set
//    __swig_getmethods__["isJun"] = _pythia8.ColourDipole_isJun_get
//    if _newclass:
//        isJun = _swig_property(_pythia8.ColourDipole_isJun_get, _pythia8.ColourDipole_isJun_set)
//    __swig_setmethods__["isAntiJun"] = _pythia8.ColourDipole_isAntiJun_set
//    __swig_getmethods__["isAntiJun"] = _pythia8.ColourDipole_isAntiJun_get
//    if _newclass:
//        isAntiJun = _swig_property(_pythia8.ColourDipole_isAntiJun_get, _pythia8.ColourDipole_isAntiJun_set)
//    __swig_setmethods__["isActive"] = _pythia8.ColourDipole_isActive_set
//    __swig_getmethods__["isActive"] = _pythia8.ColourDipole_isActive_get
//    if _newclass:
//        isActive = _swig_property(_pythia8.ColourDipole_isActive_get, _pythia8.ColourDipole_isActive_set)
//    __swig_setmethods__["isReal"] = _pythia8.ColourDipole_isReal_set
//    __swig_getmethods__["isReal"] = _pythia8.ColourDipole_isReal_get
//    if _newclass:
//        isReal = _swig_property(_pythia8.ColourDipole_isReal_get, _pythia8.ColourDipole_isReal_set)
//    __swig_setmethods__["printed"] = _pythia8.ColourDipole_printed_set
//    __swig_getmethods__["printed"] = _pythia8.ColourDipole_printed_get
//    if _newclass:
//        printed = _swig_property(_pythia8.ColourDipole_printed_get, _pythia8.ColourDipole_printed_set)
//    __swig_setmethods__["leftDip"] = _pythia8.ColourDipole_leftDip_set
//    __swig_getmethods__["leftDip"] = _pythia8.ColourDipole_leftDip_get
//    if _newclass:
//        leftDip = _swig_property(_pythia8.ColourDipole_leftDip_get, _pythia8.ColourDipole_leftDip_set)
//    __swig_setmethods__["rightDip"] = _pythia8.ColourDipole_rightDip_set
//    __swig_getmethods__["rightDip"] = _pythia8.ColourDipole_rightDip_get
//    if _newclass:
//        rightDip = _swig_property(_pythia8.ColourDipole_rightDip_get, _pythia8.ColourDipole_rightDip_set)
//    __swig_setmethods__["colDips"] = _pythia8.ColourDipole_colDips_set
//    __swig_getmethods__["colDips"] = _pythia8.ColourDipole_colDips_get
//    if _newclass:
//        colDips = _swig_property(_pythia8.ColourDipole_colDips_get, _pythia8.ColourDipole_colDips_set)
//    __swig_setmethods__["acolDips"] = _pythia8.ColourDipole_acolDips_set
//    __swig_getmethods__["acolDips"] = _pythia8.ColourDipole_acolDips_get
//    if _newclass:
//        acolDips = _swig_property(_pythia8.ColourDipole_acolDips_get, _pythia8.ColourDipole_acolDips_set)
//    __swig_setmethods__["p1p2"] = _pythia8.ColourDipole_p1p2_set
//    __swig_getmethods__["p1p2"] = _pythia8.ColourDipole_p1p2_get
//    if _newclass:
//        p1p2 = _swig_property(_pythia8.ColourDipole_p1p2_get, _pythia8.ColourDipole_p1p2_set)
//
//    def __str__(self):
//        return _pythia8.ColourDipole___str__(self)
//    __swig_destroy__ = _pythia8.delete_ColourDipole
//    __del__ = lambda self: None
//ColourDipole_swigregister = _pythia8.ColourDipole_swigregister
//ColourDipole_swigregister(ColourDipole)
//
//class ColourJunction(Junction):
//    """
//Junction class. In addition to the normal junction class, also contains a
//list of dipoles connected to it.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Junction]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ColourJunction, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Junction]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ColourJunction, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_ColourJunction(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def getColDip(self, i):
//        """
//"""
//        return _pythia8.ColourJunction_getColDip(self, i)
//
//    def setColDip(self, i, dip):
//        """
//"""
//        return _pythia8.ColourJunction_setColDip(self, i, dip)
//    __swig_setmethods__["dips"] = _pythia8.ColourJunction_dips_set
//    __swig_getmethods__["dips"] = _pythia8.ColourJunction_dips_get
//    if _newclass:
//        dips = _swig_property(_pythia8.ColourJunction_dips_get, _pythia8.ColourJunction_dips_set)
//    __swig_setmethods__["dipsOrig"] = _pythia8.ColourJunction_dipsOrig_set
//    __swig_getmethods__["dipsOrig"] = _pythia8.ColourJunction_dipsOrig_get
//    if _newclass:
//        dipsOrig = _swig_property(_pythia8.ColourJunction_dipsOrig_get, _pythia8.ColourJunction_dipsOrig_set)
//
//    def __str__(self):
//        return _pythia8.ColourJunction___str__(self)
//    __swig_destroy__ = _pythia8.delete_ColourJunction
//    __del__ = lambda self: None
//ColourJunction_swigregister = _pythia8.ColourJunction_swigregister
//ColourJunction_swigregister(ColourJunction)
//
//class TrialReconnection(_object):
//    """
//TrialReconnection class.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, TrialReconnection, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, TrialReconnection, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, dip1In=None, dip2In=None, dip3In=None, dip4In=None, modeIn=0, lambdaDiffIn=0):
//        """
//"""
//        this = _pythia8.new_TrialReconnection(dip1In, dip2In, dip3In, dip4In, modeIn, lambdaDiffIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["dips"] = _pythia8.TrialReconnection_dips_set
//    __swig_getmethods__["dips"] = _pythia8.TrialReconnection_dips_get
//    if _newclass:
//        dips = _swig_property(_pythia8.TrialReconnection_dips_get, _pythia8.TrialReconnection_dips_set)
//    __swig_setmethods__["mode"] = _pythia8.TrialReconnection_mode_set
//    __swig_getmethods__["mode"] = _pythia8.TrialReconnection_mode_get
//    if _newclass:
//        mode = _swig_property(_pythia8.TrialReconnection_mode_get, _pythia8.TrialReconnection_mode_set)
//    __swig_setmethods__["lambdaDiff"] = _pythia8.TrialReconnection_lambdaDiff_set
//    __swig_getmethods__["lambdaDiff"] = _pythia8.TrialReconnection_lambdaDiff_get
//    if _newclass:
//        lambdaDiff = _swig_property(_pythia8.TrialReconnection_lambdaDiff_get, _pythia8.TrialReconnection_lambdaDiff_set)
//    __swig_destroy__ = _pythia8.delete_TrialReconnection
//    __del__ = lambda self: None
//TrialReconnection_swigregister = _pythia8.TrialReconnection_swigregister
//TrialReconnection_swigregister(TrialReconnection)
//
//class ColourParticle(Particle):
//    """
//ColourParticle class.
//"""
//    __swig_setmethods__ = {}
//    for _s in [Particle]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ColourParticle, name, value)
//    __swig_getmethods__ = {}
//    for _s in [Particle]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, ColourParticle, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, ju):
//        """
//"""
//        this = _pythia8.new_ColourParticle(ju)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["dips"] = _pythia8.ColourParticle_dips_set
//    __swig_getmethods__["dips"] = _pythia8.ColourParticle_dips_get
//    if _newclass:
//        dips = _swig_property(_pythia8.ColourParticle_dips_get, _pythia8.ColourParticle_dips_set)
//    __swig_setmethods__["colEndIncluded"] = _pythia8.ColourParticle_colEndIncluded_set
//    __swig_getmethods__["colEndIncluded"] = _pythia8.ColourParticle_colEndIncluded_get
//    if _newclass:
//        colEndIncluded = _swig_property(_pythia8.ColourParticle_colEndIncluded_get, _pythia8.ColourParticle_colEndIncluded_set)
//    __swig_setmethods__["acolEndIncluded"] = _pythia8.ColourParticle_acolEndIncluded_set
//    __swig_getmethods__["acolEndIncluded"] = _pythia8.ColourParticle_acolEndIncluded_get
//    if _newclass:
//        acolEndIncluded = _swig_property(_pythia8.ColourParticle_acolEndIncluded_get, _pythia8.ColourParticle_acolEndIncluded_set)
//    __swig_setmethods__["activeDips"] = _pythia8.ColourParticle_activeDips_set
//    __swig_getmethods__["activeDips"] = _pythia8.ColourParticle_activeDips_get
//    if _newclass:
//        activeDips = _swig_property(_pythia8.ColourParticle_activeDips_get, _pythia8.ColourParticle_activeDips_set)
//    __swig_setmethods__["isJun"] = _pythia8.ColourParticle_isJun_set
//    __swig_getmethods__["isJun"] = _pythia8.ColourParticle_isJun_get
//    if _newclass:
//        isJun = _swig_property(_pythia8.ColourParticle_isJun_get, _pythia8.ColourParticle_isJun_set)
//    __swig_setmethods__["junKind"] = _pythia8.ColourParticle_junKind_set
//    __swig_getmethods__["junKind"] = _pythia8.ColourParticle_junKind_get
//    if _newclass:
//        junKind = _swig_property(_pythia8.ColourParticle_junKind_get, _pythia8.ColourParticle_junKind_set)
//
//    def listParticle(self):
//        """
//Printing functions, intended for debugging.
//"""
//        return _pythia8.ColourParticle_listParticle(self)
//
//    def listActiveDips(self):
//        """
//"""
//        return _pythia8.ColourParticle_listActiveDips(self)
//
//    def listDips(self):
//        """
//"""
//        return _pythia8.ColourParticle_listDips(self)
//    __swig_destroy__ = _pythia8.delete_ColourParticle
//    __del__ = lambda self: None
//ColourParticle_swigregister = _pythia8.ColourParticle_swigregister
//ColourParticle_swigregister(ColourParticle)
//
//class ColourReconnection(_object):
//    """
//The ColourReconnection class handles the colour reconnection.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ColourReconnection, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, ColourReconnection, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor
//"""
//        this = _pythia8.new_ColourReconnection()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, infoPtrIn, settings, rndmPtrIn, particleDataPtrIn, beamAPtrIn, beamBPtrIn, partonSystemsPtrIn):
//        """
//Initialization.
//"""
//        return _pythia8.ColourReconnection_init(self, infoPtrIn, settings, rndmPtrIn, particleDataPtrIn, beamAPtrIn, beamBPtrIn, partonSystemsPtrIn)
//
//    def reassignBeamPtrs(self, beamAPtrIn, beamBPtrIn):
//        """
//New beams possible for handling of hard diffraction.
//"""
//        return _pythia8.ColourReconnection_reassignBeamPtrs(self, beamAPtrIn, beamBPtrIn)
//
//    def next(self, event, oldSize):
//        """
//Do colour reconnection for current event.
//"""
//        return _pythia8.ColourReconnection_next(self, event, oldSize)
//    __swig_destroy__ = _pythia8.delete_ColourReconnection
//    __del__ = lambda self: None
//ColourReconnection_swigregister = _pythia8.ColourReconnection_swigregister
//ColourReconnection_swigregister(ColourReconnection)
//
//class HVStringFlav(StringFlav):
//    """
//The HVStringFlav class is used to select HV-quark and HV-hadron flavours.
//"""
//    __swig_setmethods__ = {}
//    for _s in [StringFlav]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HVStringFlav, name, value)
//    __swig_getmethods__ = {}
//    for _s in [StringFlav]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, HVStringFlav, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_HVStringFlav()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HVStringFlav
//    __del__ = lambda self: None
//
//    def init(self, settings, particleDataPtrIn, rndmPtrIn, infoPtrIn):
//        """
//Initialize data members.
//"""
//        return _pythia8.HVStringFlav_init(self, settings, particleDataPtrIn, rndmPtrIn, infoPtrIn)
//
//    def pick(self, flavOld, arg3, arg4):
//        """
//Pick a new flavour (including diquarks) given an incoming one.
//"""
//        return _pythia8.HVStringFlav_pick(self, flavOld, arg3, arg4)
//
//    def combine(self, flav1, flav2):
//        """
//Combine two flavours (including diquarks) to produce a hadron.
//"""
//        return _pythia8.HVStringFlav_combine(self, flav1, flav2)
//HVStringFlav_swigregister = _pythia8.HVStringFlav_swigregister
//HVStringFlav_swigregister(HVStringFlav)
//
//class HVStringPT(StringPT):
//    """
//The HVStringPT class is used to select select HV transverse momenta.
//"""
//    __swig_setmethods__ = {}
//    for _s in [StringPT]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HVStringPT, name, value)
//    __swig_getmethods__ = {}
//    for _s in [StringPT]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, HVStringPT, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_HVStringPT()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HVStringPT
//    __del__ = lambda self: None
//
//    def init(self, settings, particleDataPtrIn, rndmPtrIn, infoPtrIn):
//        """
//Initialize data members.
//"""
//        return _pythia8.HVStringPT_init(self, settings, particleDataPtrIn, rndmPtrIn, infoPtrIn)
//HVStringPT_swigregister = _pythia8.HVStringPT_swigregister
//HVStringPT_swigregister(HVStringPT)
//
//class HVStringZ(StringZ):
//    """
//The HVStringZ class is used to sample the HV fragmentation function f(z).
//"""
//    __swig_setmethods__ = {}
//    for _s in [StringZ]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HVStringZ, name, value)
//    __swig_getmethods__ = {}
//    for _s in [StringZ]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, HVStringZ, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_HVStringZ()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HVStringZ
//    __del__ = lambda self: None
//
//    def init(self, settings, particleData, rndmPtrIn, infoPtrIn):
//        """
//Initialize data members.
//"""
//        return _pythia8.HVStringZ_init(self, settings, particleData, rndmPtrIn, infoPtrIn)
//
//    def zFrag(self, idOld, idNew=0, mT2=1.):
//        """
//Fragmentation function: top-level to determine parameters.
//"""
//        return _pythia8.HVStringZ_zFrag(self, idOld, idNew, mT2)
//
//    def stopMass(self):
//        """
//Parameters for stopping in the middle; for now hardcoded.
//"""
//        return _pythia8.HVStringZ_stopMass(self)
//
//    def stopNewFlav(self):
//        """
//"""
//        return _pythia8.HVStringZ_stopNewFlav(self)
//
//    def stopSmear(self):
//        """
//"""
//        return _pythia8.HVStringZ_stopSmear(self)
//HVStringZ_swigregister = _pythia8.HVStringZ_swigregister
//HVStringZ_swigregister(HVStringZ)
//
//class HiddenValleyFragmentation(_object):
//    """
//The HiddenValleyFragmentation class contains the routines
//to fragment a Hidden Valley partonic system.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HiddenValleyFragmentation, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, HiddenValleyFragmentation, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_HiddenValleyFragmentation()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HiddenValleyFragmentation
//    __del__ = lambda self: None
//
//    def init(self, infoPtrIn, settings, particleDataPtrIn, rndmPtrIn):
//        """
//Initialize and save pointers.
//"""
//        return _pythia8.HiddenValleyFragmentation_init(self, infoPtrIn, settings, particleDataPtrIn, rndmPtrIn)
//
//    def fragment(self, event):
//        """
//Do the fragmentation: driver routine.
//"""
//        return _pythia8.HiddenValleyFragmentation_fragment(self, event)
//HiddenValleyFragmentation_swigregister = _pythia8.HiddenValleyFragmentation_swigregister
//HiddenValleyFragmentation_swigregister(HiddenValleyFragmentation)
//
//class JunctionSplitting(_object):
//    """
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, JunctionSplitting, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, JunctionSplitting, name)
//    __repr__ = _swig_repr
//
//    def init(self, infoPtrIn, settings, rndmPtrIn, particleDataPtrIn):
//        """
//Initialization.
//"""
//        return _pythia8.JunctionSplitting_init(self, infoPtrIn, settings, rndmPtrIn, particleDataPtrIn)
//
//    def checkColours(self, event):
//        """
//Test whether an event has a physical colour configuration.
//It also splits junction pairs into pieces that PYTHIA can hadronize.
//"""
//        return _pythia8.JunctionSplitting_checkColours(self, event)
//
//    def __init__(self):
//        this = _pythia8.new_JunctionSplitting()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_JunctionSplitting
//    __del__ = lambda self: None
//JunctionSplitting_swigregister = _pythia8.JunctionSplitting_swigregister
//JunctionSplitting_swigregister(JunctionSplitting)
//
//class DecayHandler(_object):
//    """
//DecayHandler is base class for the external handling of decays.
//There is only one pure virtual method, that should do the decay.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, DecayHandler, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, DecayHandler, name)
//    __repr__ = _swig_repr
//    __swig_destroy__ = _pythia8.delete_DecayHandler
//    __del__ = lambda self: None
//
//    def decay(self, arg0, arg1, arg2, arg3, arg4):
//        """
//A virtual method, wherein the derived class method does a decay.
//Usage: decay( idProd, mProd, pProd, iDec, event).
//"""
//        return _pythia8.DecayHandler_decay(self, arg0, arg1, arg2, arg3, arg4)
//
//    def chainDecay(self, arg0, arg1, arg2, arg3, arg4, arg5):
//        """
//A virtual method, to do sequential decay chains.
//Usage: decay( idProd, motherProd, mProd, pProd, iDec, event).
//"""
//        return _pythia8.DecayHandler_chainDecay(self, arg0, arg1, arg2, arg3, arg4, arg5)
//
//    def __init__(self):
//        if self.__class__ == DecayHandler:
//            _self = None
//        else:
//            _self = self
//        this = _pythia8.new_DecayHandler(_self, )
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    def __disown__(self):
//        self.this.disown()
//        _pythia8.disown_DecayHandler(self)
//        return weakref_proxy(self)
//DecayHandler_swigregister = _pythia8.DecayHandler_swigregister
//DecayHandler_swigregister(DecayHandler)
//
//class ParticleDecays(_object):
//    """
//The ParticleDecays class contains the routines to decay a particle.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ParticleDecays, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, ParticleDecays, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ParticleDecays()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, infoPtrIn, settings, particleDataPtrIn, rndmPtrIn, couplingsPtrIn, timesDecPtrIn, flavSelPtrIn, decayHandlePtrIn, handledParticles):
//        """
//Initialize: store pointers and find settings
//"""
//        return _pythia8.ParticleDecays_init(self, infoPtrIn, settings, particleDataPtrIn, rndmPtrIn, couplingsPtrIn, timesDecPtrIn, flavSelPtrIn, decayHandlePtrIn, handledParticles)
//
//    def decay(self, iDec, event):
//        """
//Perform a decay of a single particle.
//"""
//        return _pythia8.ParticleDecays_decay(self, iDec, event)
//
//    def moreToDo(self):
//        """
//Did decay result in new partons to hadronize?
//"""
//        return _pythia8.ParticleDecays_moreToDo(self)
//    __swig_destroy__ = _pythia8.delete_ParticleDecays
//    __del__ = lambda self: None
//ParticleDecays_swigregister = _pythia8.ParticleDecays_swigregister
//ParticleDecays_swigregister(ParticleDecays)
//
//class ProcessContainer(_object):
//    """
//The ProcessContainer class combines pointers to matrix element and
//phase space generator with general generation info.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ProcessContainer, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, ProcessContainer, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, sigmaProcessPtrIn=None, externalPtrIn=False, phaseSpacePtrIn=None):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ProcessContainer(sigmaProcessPtrIn, externalPtrIn, phaseSpacePtrIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ProcessContainer
//    __del__ = lambda self: None
//
//    def init(self, isFirst, infoPtrIn, settings, particleDataPtrIn, rndmPtrIn, beamAPtr, beamBPtr, couplings, sigmaTotPtrIn, resDecaysPtrIn, slhaInterfacePtr, userHooksPtr, gammaKinPtrIn):
//        """
//Initialize phase space and counters.
//"""
//        return _pythia8.ProcessContainer_init(self, isFirst, infoPtrIn, settings, particleDataPtrIn, rndmPtrIn, beamAPtr, beamBPtr, couplings, sigmaTotPtrIn, resDecaysPtrIn, slhaInterfacePtr, userHooksPtr, gammaKinPtrIn)
//
//    def setLHAPtr(self, lhaUpPtrIn, particleDataPtrIn=None, settingsPtrIn=None, rndmPtrIn=None):
//        """
//Store or replace Les Houches pointer.
//"""
//        return _pythia8.ProcessContainer_setLHAPtr(self, lhaUpPtrIn, particleDataPtrIn, settingsPtrIn, rndmPtrIn)
//
//    def newECM(self, eCM):
//        """
//Update the CM energy of the event.
//"""
//        return _pythia8.ProcessContainer_newECM(self, eCM)
//
//    def trialProcess(self):
//        """
//Generate a trial event; accepted or not.
//"""
//        return _pythia8.ProcessContainer_trialProcess(self)
//
//    def constructState(self):
//        """
//Pick flavours and colour flow of process.
//"""
//        return _pythia8.ProcessContainer_constructState(self)
//
//    def constructProcess(self, process, isHardest=True):
//        """
//Give the hard subprocess (with option for a second hard subprocess).
//"""
//        return _pythia8.ProcessContainer_constructProcess(self, process, isHardest)
//
//    def constructDecays(self, process):
//        """
//Give the Les Houches decay chain for external resonance.
//"""
//        return _pythia8.ProcessContainer_constructDecays(self, process)
//
//    def decayResonances(self, process):
//        """
//Do resonance decays.
//"""
//        return _pythia8.ProcessContainer_decayResonances(self, process)
//
//    def accumulate(self):
//        """
//Accumulate statistics after user veto.
//"""
//        return _pythia8.ProcessContainer_accumulate(self)
//
//    def reset(self):
//        """
//Reset statistics on events generated so far.
//"""
//        return _pythia8.ProcessContainer_reset(self)
//
//    def setBeamModes(self):
//        """
//Set whether (photon) beam is resolved or unresolved.
//Method propagates the choice of photon process type to beam pointers.
//"""
//        return _pythia8.ProcessContainer_setBeamModes(self)
//
//    def chooseVMDstates(self, idA, idB):
//        """
//If resolved photons, then choose VMD states. Method propagates
//states to beam pointers and info pointer.
//"""
//        return _pythia8.ProcessContainer_chooseVMDstates(self, idA, idB)
//
//    def name(self):
//        """
//Process name and code, and the number of final-state particles.
//"""
//        return _pythia8.ProcessContainer_name(self)
//
//    def code(self):
//        """
//"""
//        return _pythia8.ProcessContainer_code(self)
//
//    def nFinal(self):
//        """
//"""
//        return _pythia8.ProcessContainer_nFinal(self)
//
//    def isSUSY(self):
//        """
//"""
//        return _pythia8.ProcessContainer_isSUSY(self)
//
//    def isNonDiffractive(self):
//        """
//"""
//        return _pythia8.ProcessContainer_isNonDiffractive(self)
//
//    def isSoftQCD(self):
//        """
//"""
//        return _pythia8.ProcessContainer_isSoftQCD(self)
//
//    def newSigmaMax(self):
//        """
//Member functions for info on generation process.
//"""
//        return _pythia8.ProcessContainer_newSigmaMax(self)
//
//    def sigmaMax(self):
//        """
//"""
//        return _pythia8.ProcessContainer_sigmaMax(self)
//
//    def nTried(self):
//        """
//"""
//        return _pythia8.ProcessContainer_nTried(self)
//
//    def nSelected(self):
//        """
//"""
//        return _pythia8.ProcessContainer_nSelected(self)
//
//    def nAccepted(self):
//        """
//"""
//        return _pythia8.ProcessContainer_nAccepted(self)
//
//    def weightSum(self):
//        """
//"""
//        return _pythia8.ProcessContainer_weightSum(self)
//
//    def sigmaSelMC(self, doAccumulate=True):
//        """
//"""
//        return _pythia8.ProcessContainer_sigmaSelMC(self, doAccumulate)
//
//    def sigmaMC(self, doAccumulate=True):
//        """
//"""
//        return _pythia8.ProcessContainer_sigmaMC(self, doAccumulate)
//
//    def deltaMC(self, doAccumulate=True):
//        """
//"""
//        return _pythia8.ProcessContainer_deltaMC(self, doAccumulate)
//
//    def id1(self):
//        """
//Some kinematics quantities.
//"""
//        return _pythia8.ProcessContainer_id1(self)
//
//    def id2(self):
//        """
//"""
//        return _pythia8.ProcessContainer_id2(self)
//
//    def x1(self):
//        """
//"""
//        return _pythia8.ProcessContainer_x1(self)
//
//    def x2(self):
//        """
//"""
//        return _pythia8.ProcessContainer_x2(self)
//
//    def Q2Fac(self):
//        """
//"""
//        return _pythia8.ProcessContainer_Q2Fac(self)
//
//    def mHat(self):
//        """
//"""
//        return _pythia8.ProcessContainer_mHat(self)
//
//    def pTHat(self):
//        """
//"""
//        return _pythia8.ProcessContainer_pTHat(self)
//
//    def isLHAContainer(self):
//        """
//Tell whether container is for Les Houches events.
//"""
//        return _pythia8.ProcessContainer_isLHAContainer(self)
//
//    def lhaStrategy(self):
//        """
//"""
//        return _pythia8.ProcessContainer_lhaStrategy(self)
//
//    def codeLHASize(self):
//        """
//Info on Les Houches events.
//"""
//        return _pythia8.ProcessContainer_codeLHASize(self)
//
//    def subCodeLHA(self, i):
//        """
//"""
//        return _pythia8.ProcessContainer_subCodeLHA(self, i)
//
//    def nTriedLHA(self, i):
//        """
//"""
//        return _pythia8.ProcessContainer_nTriedLHA(self, i)
//
//    def nSelectedLHA(self, i):
//        """
//"""
//        return _pythia8.ProcessContainer_nSelectedLHA(self, i)
//
//    def nAcceptedLHA(self, i):
//        """
//"""
//        return _pythia8.ProcessContainer_nAcceptedLHA(self, i)
//
//    def isSame(self, *args):
//        """
//"""
//        return _pythia8.ProcessContainer_isSame(self, *args)
//ProcessContainer_swigregister = _pythia8.ProcessContainer_swigregister
//ProcessContainer_swigregister(ProcessContainer)
//
//class SetupContainers(_object):
//    """
//The SetupContainers class turns the list of user-requested processes
//into a vector of ProcessContainer objects, each with a process.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SetupContainers, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, SetupContainers, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_SetupContainers()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, containerPtrs, infoPtr, settings, particleDataPtr, couplings):
//        """
//Initialization assuming all necessary data already read.
//"""
//        return _pythia8.SetupContainers_init(self, containerPtrs, infoPtr, settings, particleDataPtr, couplings)
//
//    def init2(self, container2Ptrs, settings):
//        """
//Initialization of a second hard process.
//"""
//        return _pythia8.SetupContainers_init2(self, container2Ptrs, settings)
//    __swig_destroy__ = _pythia8.delete_SetupContainers
//    __del__ = lambda self: None
//SetupContainers_swigregister = _pythia8.SetupContainers_swigregister
//SetupContainers_swigregister(SetupContainers)
//
//class ProcessLevel(_object):
//    """
//The ProcessLevel class contains the top-level routines to generate
//the characteristic "hard" process of an event.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ProcessLevel, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, ProcessLevel, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_ProcessLevel()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ProcessLevel
//    __del__ = lambda self: None
//
//    def init(self, infoPtrIn, settings, particleDataPtrIn, rndmPtrIn, beamAPtrIn, beamBPtrIn, beamGamAPtrIn, beamGamBPtrIn, beamVMDAPtrIn, beamVMDBPtrIn, couplingsPtrIn, sigmaTotPtrIn, doLHAin, slhaInterfacePtrIn, userHooksPtrIn, sigmaPtrs, phaseSpacePtrs):
//        """
//Initialization.
//"""
//        return _pythia8.ProcessLevel_init(self, infoPtrIn, settings, particleDataPtrIn, rndmPtrIn, beamAPtrIn, beamBPtrIn, beamGamAPtrIn, beamGamBPtrIn, beamVMDAPtrIn, beamVMDBPtrIn, couplingsPtrIn, sigmaTotPtrIn, doLHAin, slhaInterfacePtrIn, userHooksPtrIn, sigmaPtrs, phaseSpacePtrs)
//
//    def setLHAPtr(self, lhaUpPtrIn):
//        """
//Store or replace Les Houches pointer.
//"""
//        return _pythia8.ProcessLevel_setLHAPtr(self, lhaUpPtrIn)
//
//    def next(self, process):
//        """
//Generate the next "hard" process.
//"""
//        return _pythia8.ProcessLevel_next(self, process)
//
//    def nextLHAdec(self, process):
//        """
//Special case: LHA input of resonance decay only.
//"""
//        return _pythia8.ProcessLevel_nextLHAdec(self, process)
//
//    def accumulate(self, doAccumulate=True):
//        """
//Accumulate and update statistics (after possible user veto).
//"""
//        return _pythia8.ProcessLevel_accumulate(self, doAccumulate)
//
//    def statistics(self, reset=False):
//        """
//Print statistics on cross sections and number of events.
//"""
//        return _pythia8.ProcessLevel_statistics(self, reset)
//
//    def resetStatistics(self):
//        """
//Reset statistics.
//"""
//        return _pythia8.ProcessLevel_resetStatistics(self)
//
//    def findJunctions(self, junEvent):
//        """
//Add any junctions to the process event record list.
//"""
//        return _pythia8.ProcessLevel_findJunctions(self, junEvent)
//
//    def initDecays(self, infoPtrIn, settings, particleDataPtrIn, rndmPtrIn, lhaUpPtrIn):
//        """
//Initialize and call resonance decays separately.
//"""
//        return _pythia8.ProcessLevel_initDecays(self, infoPtrIn, settings, particleDataPtrIn, rndmPtrIn, lhaUpPtrIn)
//
//    def nextDecays(self, process):
//        """
//"""
//        return _pythia8.ProcessLevel_nextDecays(self, process)
//ProcessLevel_swigregister = _pythia8.ProcessLevel_swigregister
//ProcessLevel_swigregister(ProcessLevel)
//
//class BeamRemnants(_object):
//    """
//This class matches the kinematics of the hard-scattering subsystems
//(with primordial kT added) to that of the two beam remnants.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, BeamRemnants, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, BeamRemnants, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_BeamRemnants()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, infoPtrIn, settings, rndmPtrIn, beamAPtrIn, beamBPtrIn, partonSystemsPtrIn, partonVertexPtrIn, particleDataPtrIn, colourReconnectionPtrIn):
//        """
//Initialization.
//"""
//        return _pythia8.BeamRemnants_init(self, infoPtrIn, settings, rndmPtrIn, beamAPtrIn, beamBPtrIn, partonSystemsPtrIn, partonVertexPtrIn, particleDataPtrIn, colourReconnectionPtrIn)
//
//    def reassignBeamPtrs(self, beamAPtrIn, beamBPtrIn, iDSin):
//        """
//New beams possible for handling of hard diffraction.
//"""
//        return _pythia8.BeamRemnants_reassignBeamPtrs(self, beamAPtrIn, beamBPtrIn, iDSin)
//
//    def add(self, event, iFirst=0, doDiffCR=False):
//        """
//Select the flavours/kinematics/colours of the two beam remnants.
//"""
//        return _pythia8.BeamRemnants_add(self, event, iFirst, doDiffCR)
//    __swig_destroy__ = _pythia8.delete_BeamRemnants
//    __del__ = lambda self: None
//BeamRemnants_swigregister = _pythia8.BeamRemnants_swigregister
//BeamRemnants_swigregister(BeamRemnants)
//
//class HadronLevel(_object):
//    """
//The HadronLevel class contains the top-level routines to generate
//the transition from the partonic to the hadronic stage of an event.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HadronLevel, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, HadronLevel, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_HadronLevel()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, infoPtrIn, settings, particleDataPtrIn, rndmPtrIn, couplingsPtrIn, timesDecPtr, rHadronsPtrIn, decayHandlePtr, handledParticles, userHooksPtrIn):
//        """
//Initialize HadronLevel classes as required.
//"""
//        return _pythia8.HadronLevel_init(self, infoPtrIn, settings, particleDataPtrIn, rndmPtrIn, couplingsPtrIn, timesDecPtr, rHadronsPtrIn, decayHandlePtr, handledParticles, userHooksPtrIn)
//
//    def getStringFlavPtr(self):
//        """
//Get pointer to StringFlav instance (needed by BeamParticle).
//"""
//        return _pythia8.HadronLevel_getStringFlavPtr(self)
//
//    def next(self, event):
//        """
//Generate the next event.
//"""
//        return _pythia8.HadronLevel_next(self, event)
//
//    def moreDecays(self, event):
//        """
//Special routine to allow more decays if on/off switches changed.
//"""
//        return _pythia8.HadronLevel_moreDecays(self, event)
//    __swig_destroy__ = _pythia8.delete_HadronLevel
//    __del__ = lambda self: None
//HadronLevel_swigregister = _pythia8.HadronLevel_swigregister
//HadronLevel_swigregister(HadronLevel)
//
//class HardDiffraction(_object):
//    """
//HardDiffraction class.
//This class handles hard diffraction, together with PartonLevel.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HardDiffraction, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, HardDiffraction, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor and destructor.
//"""
//        this = _pythia8.new_HardDiffraction()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HardDiffraction
//    __del__ = lambda self: None
//
//    def init(self, infoPtrIn, settingsIn, rndmPtrIn, beamAPtrIn, beamBPtrIn, beamPomAPtrIn, beamPomBPtrIn, sigTotPtrIn):
//        """
//Initialise constants
//"""
//        return _pythia8.HardDiffraction_init(self, infoPtrIn, settingsIn, rndmPtrIn, beamAPtrIn, beamBPtrIn, beamPomAPtrIn, beamPomBPtrIn, sigTotPtrIn)
//
//    def isDiffractive(self, iBeamIn=1, partonIn=0, xIn=0., Q2In=0., xfIncIn=0.):
//        """
//Main routine to check if event is from diffractive PDF.
//"""
//        return _pythia8.HardDiffraction_isDiffractive(self, iBeamIn, partonIn, xIn, Q2In, xfIncIn)
//
//    def getXPomeronA(self):
//        """
//Get diffractive values.
//"""
//        return _pythia8.HardDiffraction_getXPomeronA(self)
//
//    def getXPomeronB(self):
//        """
//"""
//        return _pythia8.HardDiffraction_getXPomeronB(self)
//
//    def getTPomeronA(self):
//        """
//"""
//        return _pythia8.HardDiffraction_getTPomeronA(self)
//
//    def getTPomeronB(self):
//        """
//"""
//        return _pythia8.HardDiffraction_getTPomeronB(self)
//
//    def getThetaPomeronA(self):
//        """
//"""
//        return _pythia8.HardDiffraction_getThetaPomeronA(self)
//
//    def getThetaPomeronB(self):
//        """
//"""
//        return _pythia8.HardDiffraction_getThetaPomeronB(self)
//HardDiffraction_swigregister = _pythia8.HardDiffraction_swigregister
//HardDiffraction_swigregister(HardDiffraction)
//
//class PartonLevel(_object):
//    """
//The PartonLevel class contains the top-level routines to generate
//the partonic activity of an event.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, PartonLevel, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, PartonLevel, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor.
//"""
//        this = _pythia8.new_PartonLevel()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def init(self, infoPtrIn, settings, particleDataPtrIn, rndmPtrIn, beamAPtrIn, beamBPtrIn, beamPomAPtrIn, beamPomBPtrIn, beamGamAPtrIn, beamGamBPtrIn, beamVMDAPtrIn, beamVMDBPtrIn, couplingsPtrIn, partonSystemsPtrIn, sigmaTotPtr, timesDecPtrIn, timesPtrIn, spacePtrIn, rHadronsPtrIn, userHooksPtrIn, mergingHooksPtr, partonVertexPtrIn, useAsTrial):
//        """
//Initialization of all classes at the parton level.
//"""
//        return _pythia8.PartonLevel_init(self, infoPtrIn, settings, particleDataPtrIn, rndmPtrIn, beamAPtrIn, beamBPtrIn, beamPomAPtrIn, beamPomBPtrIn, beamGamAPtrIn, beamGamBPtrIn, beamVMDAPtrIn, beamVMDBPtrIn, couplingsPtrIn, partonSystemsPtrIn, sigmaTotPtr, timesDecPtrIn, timesPtrIn, spacePtrIn, rHadronsPtrIn, userHooksPtrIn, mergingHooksPtr, partonVertexPtrIn, useAsTrial)
//
//    def next(self, process, event):
//        """
//Generate the next parton-level process.
//"""
//        return _pythia8.PartonLevel_next(self, process, event)
//
//    def setupShowerSys(self, process, event):
//        """
//Perform showers in resonance decay chains. (For special cases.)
//"""
//        return _pythia8.PartonLevel_setupShowerSys(self, process, event)
//
//    def resonanceShowers(self, process, event, skipForR):
//        """
//"""
//        return _pythia8.PartonLevel_resonanceShowers(self, process, event, skipForR)
//
//    def wzDecayShowers(self, event):
//        """
//Perform decays and showers of W and Z emitted in shower.
//"""
//        return _pythia8.PartonLevel_wzDecayShowers(self, event)
//
//    def hasVetoed(self):
//        """
//Tell whether failure was due to vetoing.
//"""
//        return _pythia8.PartonLevel_hasVetoed(self)
//
//    def hasVetoedDiff(self):
//        """
//"""
//        return _pythia8.PartonLevel_hasVetoedDiff(self)
//
//    def accumulate(self):
//        """
//Accumulate, print and reset statistics.
//"""
//        return _pythia8.PartonLevel_accumulate(self)
//
//    def statistics(self, reset=False):
//        """
//"""
//        return _pythia8.PartonLevel_statistics(self, reset)
//
//    def resetStatistics(self):
//        return _pythia8.PartonLevel_resetStatistics(self)
//
//    def resetTrial(self):
//        return _pythia8.PartonLevel_resetTrial(self)
//
//    def pTLastInShower(self):
//        return _pythia8.PartonLevel_pTLastInShower(self)
//
//    def typeLastInShower(self):
//        return _pythia8.PartonLevel_typeLastInShower(self)
//    __swig_setmethods__["timesDecPtr"] = _pythia8.PartonLevel_timesDecPtr_set
//    __swig_getmethods__["timesDecPtr"] = _pythia8.PartonLevel_timesDecPtr_get
//    if _newclass:
//        timesDecPtr = _swig_property(_pythia8.PartonLevel_timesDecPtr_get, _pythia8.PartonLevel_timesDecPtr_set)
//    __swig_setmethods__["timesPtr"] = _pythia8.PartonLevel_timesPtr_set
//    __swig_getmethods__["timesPtr"] = _pythia8.PartonLevel_timesPtr_get
//    if _newclass:
//        timesPtr = _swig_property(_pythia8.PartonLevel_timesPtr_get, _pythia8.PartonLevel_timesPtr_set)
//    __swig_setmethods__["spacePtr"] = _pythia8.PartonLevel_spacePtr_set
//    __swig_getmethods__["spacePtr"] = _pythia8.PartonLevel_spacePtr_get
//    if _newclass:
//        spacePtr = _swig_property(_pythia8.PartonLevel_spacePtr_get, _pythia8.PartonLevel_spacePtr_set)
//    __swig_setmethods__["userHooksPtr"] = _pythia8.PartonLevel_userHooksPtr_set
//    __swig_getmethods__["userHooksPtr"] = _pythia8.PartonLevel_userHooksPtr_get
//    if _newclass:
//        userHooksPtr = _swig_property(_pythia8.PartonLevel_userHooksPtr_get, _pythia8.PartonLevel_userHooksPtr_set)
//    __swig_destroy__ = _pythia8.delete_PartonLevel
//    __del__ = lambda self: None
//PartonLevel_swigregister = _pythia8.PartonLevel_swigregister
//PartonLevel_swigregister(PartonLevel)
//
//class Clustering(_object):
//    """
//Declaration of Clustering class.
//This class holds information about one radiator, recoiler, emitted system.
//This class is a container class for History class use.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Clustering, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, Clustering, name)
//    __repr__ = _swig_repr
//    __swig_setmethods__["emitted"] = _pythia8.Clustering_emitted_set
//    __swig_getmethods__["emitted"] = _pythia8.Clustering_emitted_get
//    if _newclass:
//        emitted = _swig_property(_pythia8.Clustering_emitted_get, _pythia8.Clustering_emitted_set)
//    __swig_setmethods__["emittor"] = _pythia8.Clustering_emittor_set
//    __swig_getmethods__["emittor"] = _pythia8.Clustering_emittor_get
//    if _newclass:
//        emittor = _swig_property(_pythia8.Clustering_emittor_get, _pythia8.Clustering_emittor_set)
//    __swig_setmethods__["recoiler"] = _pythia8.Clustering_recoiler_set
//    __swig_getmethods__["recoiler"] = _pythia8.Clustering_recoiler_get
//    if _newclass:
//        recoiler = _swig_property(_pythia8.Clustering_recoiler_get, _pythia8.Clustering_recoiler_set)
//    __swig_setmethods__["partner"] = _pythia8.Clustering_partner_set
//    __swig_getmethods__["partner"] = _pythia8.Clustering_partner_get
//    if _newclass:
//        partner = _swig_property(_pythia8.Clustering_partner_get, _pythia8.Clustering_partner_set)
//    __swig_setmethods__["pTscale"] = _pythia8.Clustering_pTscale_set
//    __swig_getmethods__["pTscale"] = _pythia8.Clustering_pTscale_get
//    if _newclass:
//        pTscale = _swig_property(_pythia8.Clustering_pTscale_get, _pythia8.Clustering_pTscale_set)
//    __swig_setmethods__["flavRadBef"] = _pythia8.Clustering_flavRadBef_set
//    __swig_getmethods__["flavRadBef"] = _pythia8.Clustering_flavRadBef_get
//    if _newclass:
//        flavRadBef = _swig_property(_pythia8.Clustering_flavRadBef_get, _pythia8.Clustering_flavRadBef_set)
//    __swig_setmethods__["spinRad"] = _pythia8.Clustering_spinRad_set
//    __swig_getmethods__["spinRad"] = _pythia8.Clustering_spinRad_get
//    if _newclass:
//        spinRad = _swig_property(_pythia8.Clustering_spinRad_get, _pythia8.Clustering_spinRad_set)
//    __swig_setmethods__["spinEmt"] = _pythia8.Clustering_spinEmt_set
//    __swig_getmethods__["spinEmt"] = _pythia8.Clustering_spinEmt_get
//    if _newclass:
//        spinEmt = _swig_property(_pythia8.Clustering_spinEmt_get, _pythia8.Clustering_spinEmt_set)
//    __swig_setmethods__["spinRec"] = _pythia8.Clustering_spinRec_set
//    __swig_getmethods__["spinRec"] = _pythia8.Clustering_spinRec_get
//    if _newclass:
//        spinRec = _swig_property(_pythia8.Clustering_spinRec_get, _pythia8.Clustering_spinRec_set)
//    __swig_setmethods__["spinRadBef"] = _pythia8.Clustering_spinRadBef_set
//    __swig_getmethods__["spinRadBef"] = _pythia8.Clustering_spinRadBef_get
//    if _newclass:
//        spinRadBef = _swig_property(_pythia8.Clustering_spinRadBef_get, _pythia8.Clustering_spinRadBef_set)
//    __swig_setmethods__["radBef"] = _pythia8.Clustering_radBef_set
//    __swig_getmethods__["radBef"] = _pythia8.Clustering_radBef_get
//    if _newclass:
//        radBef = _swig_property(_pythia8.Clustering_radBef_get, _pythia8.Clustering_radBef_set)
//    __swig_setmethods__["recBef"] = _pythia8.Clustering_recBef_set
//    __swig_getmethods__["recBef"] = _pythia8.Clustering_recBef_get
//    if _newclass:
//        recBef = _swig_property(_pythia8.Clustering_recBef_get, _pythia8.Clustering_recBef_set)
//    __swig_destroy__ = _pythia8.delete_Clustering
//    __del__ = lambda self: None
//
//    def __init__(self, *args):
//        """
//Constructor with input
//"""
//        this = _pythia8.new_Clustering(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def pT(self):
//        """
//Function to return pythia pT scale of clustering
//"""
//        return _pythia8.Clustering_pT(self)
//
//    def __str__(self):
//        return _pythia8.Clustering___str__(self)
//Clustering_swigregister = _pythia8.Clustering_swigregister
//Clustering_swigregister(Clustering)
//
//class History(_object):
//    """
//Declaration of History class
//A History object represents an event in a given step in the CKKW-L
//clustering procedure. It defines a tree-like recursive structure,
//where the root node represents the state with n jets as given by
//the matrix element generator, and is characterized by the member
//variable mother being null. The leaves on the tree corresponds to a
//fully clustered paths where the original n-jets has been clustered
//down to the Born-level state. Also states which cannot be clustered
//down to the Born-level are possible - these will be called
//incomplete. The leaves are characterized by the vector of children
//being empty.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, History, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, History, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, depth, scalein, statein, c, mergingHooksPtrIn, beamAIn, beamBIn, particleDataPtrIn, infoPtrIn, showersIn, coupSMPtrIn, isOrdered, isStronglyOrdered, isAllowed, isNextInInput, probin, mothin):
//        """
//The only constructor. Default arguments are used when creating
//the initial history node. The \a depth is the maximum number of
//clusterings requested. \a scalein is the scale at which the \a
//statein was clustered (should be set to the merging scale for the
//initial history node. \a beamAIn and beamBIn are needed to
//calcutate PDF ratios, \a particleDataIn to have access to the
//correct masses of particles. If \a isOrdered is true, the previous
//clusterings has been ordered. \a is the PDF ratio for this
//clustering (=1 for FSR clusterings). \a probin is the accumulated
//probabilities for the previous clusterings, and \ mothin is the
//previous history node (null for the initial node).
//"""
//        this = _pythia8.new_History(depth, scalein, statein, c, mergingHooksPtrIn, beamAIn, beamBIn, particleDataPtrIn, infoPtrIn, showersIn, coupSMPtrIn, isOrdered, isStronglyOrdered, isAllowed, isNextInInput, probin, mothin)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_History
//    __del__ = lambda self: None
//
//    def projectOntoDesiredHistories(self):
//        """
//Function to project paths onto desired paths.
//"""
//        return _pythia8.History_projectOntoDesiredHistories(self)
//
//    def weightTREE(self, trial, asFSR, asISR, aemFSR, aemISR, RN):
//        """
//For CKKW-L, NL3 and UMEPS:
//In the initial history node, select one of the paths according to
//the probabilities. This function should be called for the initial
//history node.
//IN  trialShower*    : Previously initialised trialShower object,
//                      to perform trial showering and as
//                      repository of pointers to initialise alphaS
//    PartonSystems* : PartonSystems object needed to initialise
//                     shower objects
//OUT double         : (Sukadov) , (alpha_S ratios) , (PDF ratios)
//"""
//        return _pythia8.History_weightTREE(self, trial, asFSR, asISR, aemFSR, aemISR, RN)
//
//    def weightLOOP(self, trial, RN):
//        """
//For default NL3:
//Return weight of virtual correction and subtractive for NL3 merging
//"""
//        return _pythia8.History_weightLOOP(self, trial, RN)
//
//    def weightFIRST(self, trial, asFSR, asISR, aemFSR, aemISR, RN, rndmPtr):
//        """
//Return O(\alpha_s)-term of CKKWL-weight for NL3 merging
//"""
//        return _pythia8.History_weightFIRST(self, trial, asFSR, asISR, aemFSR, aemISR, RN, rndmPtr)
//
//    def weight_UMEPS_TREE(self, trial, asFSR, asISR, aemFSR, aemISR, RN):
//        """
//For UMEPS:
//"""
//        return _pythia8.History_weight_UMEPS_TREE(self, trial, asFSR, asISR, aemFSR, aemISR, RN)
//
//    def weight_UMEPS_SUBT(self, trial, asFSR, asISR, aemFSR, aemISR, RN):
//        """
//"""
//        return _pythia8.History_weight_UMEPS_SUBT(self, trial, asFSR, asISR, aemFSR, aemISR, RN)
//
//    def weight_UNLOPS_TREE(self, trial, asFSR, asISR, aemFSR, aemISR, RN, depth=-1):
//        """
//For unitary NL3:
//"""
//        return _pythia8.History_weight_UNLOPS_TREE(self, trial, asFSR, asISR, aemFSR, aemISR, RN, depth)
//
//    def weight_UNLOPS_SUBT(self, trial, asFSR, asISR, aemFSR, aemISR, RN, depth=-1):
//        """
//"""
//        return _pythia8.History_weight_UNLOPS_SUBT(self, trial, asFSR, asISR, aemFSR, aemISR, RN, depth)
//
//    def weight_UNLOPS_LOOP(self, trial, asFSR, asISR, aemFSR, aemISR, RN, depth=-1):
//        """
//"""
//        return _pythia8.History_weight_UNLOPS_LOOP(self, trial, asFSR, asISR, aemFSR, aemISR, RN, depth)
//
//    def weight_UNLOPS_SUBTNLO(self, trial, asFSR, asISR, aemFSR, aemISR, RN, depth=-1):
//        """
//"""
//        return _pythia8.History_weight_UNLOPS_SUBTNLO(self, trial, asFSR, asISR, aemFSR, aemISR, RN, depth)
//
//    def weight_UNLOPS_CORRECTION(self, order, trial, asFSR, asISR, aemFSR, aemISR, RN, rndmPtr):
//        """
//"""
//        return _pythia8.History_weight_UNLOPS_CORRECTION(self, order, trial, asFSR, asISR, aemFSR, aemISR, RN, rndmPtr)
//
//    def foundAllowedHistories(self):
//        """
//Function to check if any allowed histories were found
//"""
//        return _pythia8.History_foundAllowedHistories(self)
//
//    def foundOrderedHistories(self):
//        """
//Function to check if any ordered histories were found
//"""
//        return _pythia8.History_foundOrderedHistories(self)
//
//    def foundCompleteHistories(self):
//        """
//Function to check if any ordered histories were found
//"""
//        return _pythia8.History_foundCompleteHistories(self)
//
//    def getStartingConditions(self, RN, outState):
//        """
//Function to set the state with complete scales for evolution
//"""
//        return _pythia8.History_getStartingConditions(self, RN, outState)
//
//    def getClusteredEvent(self, RN, nSteps, outState):
//        """
//Function to get the state with complete scales for evolution
//"""
//        return _pythia8.History_getClusteredEvent(self, RN, nSteps, outState)
//
//    def getFirstClusteredEventAboveTMS(self, RN, nDesired, process, nPerformed, updateProcess=True):
//        """
//Function to get the first reclustered state above the merging scale.
//"""
//        return _pythia8.History_getFirstClusteredEventAboveTMS(self, RN, nDesired, process, nPerformed, updateProcess)
//
//    def nClusterings(self):
//        """
//Function to return the depth of the history (i.e. the number of
//reclustered splittings)
//"""
//        return _pythia8.History_nClusterings(self)
//
//    def lowestMultProc(self, RN):
//        """
//Function to get the lowest multiplicity reclustered event
//"""
//        return _pythia8.History_lowestMultProc(self, RN)
//
//    def getPDFratio(self, side, forSudakov, useHardPDF, flavNum, xNum, muNum, flavDen, xDen, muDen):
//        """
//Calculate and return pdf ratio
//"""
//        return _pythia8.History_getPDFratio(self, side, forSudakov, useHardPDF, flavNum, xNum, muNum, flavDen, xDen, muDen)
//
//    def getWeakProb(self, *args):
//        """
//Recursive function that returns the weak probability for the given path.
//Mode refers to which ME correction to use, 1 = sChannel, 2 = gluon
//channel, 3 = double quark t-channel, 4 is double quark u-channel.
//"""
//        return _pythia8.History_getWeakProb(self, *args)
//
//    def getSingleWeakProb(self, mode, mom, fermionLines):
//        """
//return the weak probability of a single reclustering.
//Mode refers to which ME correction to use, 1 = sChannel, 2 = gluon
//channel, 3 = double quark t-channel, 4 is double quark u-channel.
//"""
//        return _pythia8.History_getSingleWeakProb(self, mode, mom, fermionLines)
//
//    def findStateTransfer(self, transfer):
//        """
//Find map between indecies in the current state and the state after
//the splitting.
//NOT IMPLEMENTED FOR MULTIPLE W/Z/GAMMA (NEED TO HAVE A WAY TO
//IDENTIFY THEM).
//"""
//        return _pythia8.History_findStateTransfer(self, transfer)
//
//    def printHistory(self, RN):
//        """
//Function to print the history that would be chosen from the random number
//RN. Mainly for debugging.
//"""
//        return _pythia8.History_printHistory(self, RN)
//
//    def printStates(self):
//        """
//Function to print the states in a history, starting from the hard process.
//Mainly for debugging.
//"""
//        return _pythia8.History_printStates(self)
//History_swigregister = _pythia8.History_swigregister
//History_swigregister(History)
//
//class Merging(_object):
//    """
//Merging is a wrapper class for the interface of matrix element merging and
//Pythia8.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Merging, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, Merging, name)
//
//    def __init__(self, *args, **kwargs):
//        """
//The members
//Constructor.
//"""
//        raise AttributeError("No constructor defined")
//    __repr__ = _swig_repr
//    __swig_destroy__ = _pythia8.delete_Merging
//    __del__ = lambda self: None
//
//    def initPtr(self, settingsPtrIn, infoPtrIn, particleDataPtrIn, rndmPtrIn, beamAPtrIn, beamBPtrIn, mergingHooksPtrIn, trialPartonLevelPtrIn, coupSMPtrIn):
//        """
//Initialisation function for internal use inside Pythia source code
//"""
//        return _pythia8.Merging_initPtr(self, settingsPtrIn, infoPtrIn, particleDataPtrIn, rndmPtrIn, beamAPtrIn, beamBPtrIn, mergingHooksPtrIn, trialPartonLevelPtrIn, coupSMPtrIn)
//
//    def init(self):
//        """
//Initialisation function for internal use inside Pythia source code
//"""
//        return _pythia8.Merging_init(self)
//
//    def statistics(self):
//        """
//Function to print statistics.
//"""
//        return _pythia8.Merging_statistics(self)
//
//    def mergeProcess(self, process):
//        """
//Function to steer different merging prescriptions.
//"""
//        return _pythia8.Merging_mergeProcess(self, process)
//Merging_swigregister = _pythia8.Merging_swigregister
//Merging_swigregister(Merging)
//
//
//_pythia8.PYTHIA_VERSION_swigconstant(_pythia8)
//PYTHIA_VERSION = _pythia8.PYTHIA_VERSION
//
//_pythia8.PYTHIA_VERSION_INTEGER_swigconstant(_pythia8)
//PYTHIA_VERSION_INTEGER = _pythia8.PYTHIA_VERSION_INTEGER
//class Pythia(_object):
//    """
//The Pythia class contains the top-level routines to generate an event.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Pythia, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, Pythia, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//The event record for the parton-level central process.
//The event record for the complete event history.
//Information on the generation: current subprocess and error statistics.
//Settings: databases of flags/modes/parms/words to control run.
//ParticleData: the particle data table/database.
//Random number generator.
//Standard Model couplings, including alphaS and alphaEM.
//SLHA Interface
//The partonic content of each subcollision system (auxiliary to event).
//Merging object as wrapper for matrix element merging routines.
//Pointer to MergingHooks object for user interaction with the merging.
//MergingHooks also more generally steers the matrix element merging.
//Pointer to a HeavyIons object for generating heavy ion collisions
//Pointer to a HIUserHooks object to modify heavy ion modelling.
//The two incoming beams.
//Copy and = constructors are made private so they cannot be used.
//"""
//        this = _pythia8.new_Pythia(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_Pythia
//    __del__ = lambda self: None
//
//    def initPtrs(self):
//        """
//Initialise new Pythia object (called by constructors).
//"""
//        return _pythia8.Pythia_initPtrs(self)
//
//    def checkVersion(self):
//        """
//Check consistency of version numbers (called by constructors).
//"""
//        return _pythia8.Pythia_checkVersion(self)
//
//    def readString(self, arg2, warn=True):
//        """
//Read in one update for a setting or particle data from a single line.
//"""
//        return _pythia8.Pythia_readString(self, arg2, warn)
//
//    def readFile(self, *args):
//        """
//"""
//        return _pythia8.Pythia_readFile(self, *args)
//
//    def setPDFPtr(self, pdfAPtrIn, pdfBPtrIn, pdfHardAPtrIn=None, pdfHardBPtrIn=None, pdfPomAPtrIn=None, pdfPomBPtrIn=None, pdfGamAPtrIn=None, pdfGamBPtrIn=None, pdfHardGamAPtrIn=None, pdfHardGamBPtrIn=None, pdfUnresAPtrIn=None, pdfUnresBPtrIn=None, pdfUnresGamAPtrIn=None, pdfUnresGamBPtrIn=None, pdfVMDAPtrIn=None, pdfVMDBPtrIn=None):
//        """
//Possibility to pass in pointers to PDF's.
//"""
//        return _pythia8.Pythia_setPDFPtr(self, pdfAPtrIn, pdfBPtrIn, pdfHardAPtrIn, pdfHardBPtrIn, pdfPomAPtrIn, pdfPomBPtrIn, pdfGamAPtrIn, pdfGamBPtrIn, pdfHardGamAPtrIn, pdfHardGamBPtrIn, pdfUnresAPtrIn, pdfUnresBPtrIn, pdfUnresGamAPtrIn, pdfUnresGamBPtrIn, pdfVMDAPtrIn, pdfVMDBPtrIn)
//
//    def setPhotonFluxPtr(self, photonFluxAIn, photonFluxBIn):
//        """
//Set photon fluxes externally. Used with option "PDF:lepton2gammaSet = 2".
//"""
//        return _pythia8.Pythia_setPhotonFluxPtr(self, photonFluxAIn, photonFluxBIn)
//
//    def setLHAupPtr(self, lhaUpPtrIn):
//        """
//Possibility to pass in pointer to external LHA-interfaced generator.
//"""
//        return _pythia8.Pythia_setLHAupPtr(self, lhaUpPtrIn)
//
//    def setDecayPtr(self, decayHandlePtrIn, handledParticlesIn):
//        """
//Possibility to pass in pointer for external handling of some decays.
//"""
//        return _pythia8.Pythia_setDecayPtr(self, decayHandlePtrIn, handledParticlesIn)
//
//    def setRndmEnginePtr(self, rndmEnginePtrIn):
//        """
//Possibility to pass in pointer for external random number generation.
//"""
//        return _pythia8.Pythia_setRndmEnginePtr(self, rndmEnginePtrIn)
//
//    def setUserHooksPtr(self, userHooksPtrIn):
//        """
//Possibility to pass in pointer for user hooks.
//"""
//        return _pythia8.Pythia_setUserHooksPtr(self, userHooksPtrIn)
//
//    def addUserHooksPtr(self, userHooksPtrIn):
//        """
//Possibility to add further pointers to allow multiple user hooks.
//"""
//        return _pythia8.Pythia_addUserHooksPtr(self, userHooksPtrIn)
//
//    def setMergingPtr(self, mergingPtrIn):
//        """
//Possibility to pass in pointer for full merging class.
//"""
//        return _pythia8.Pythia_setMergingPtr(self, mergingPtrIn)
//
//    def setMergingHooksPtr(self, mergingHooksPtrIn):
//        """
//Possibility to pass in pointer for merging hooks.
//"""
//        return _pythia8.Pythia_setMergingHooksPtr(self, mergingHooksPtrIn)
//
//    def setBeamShapePtr(self, beamShapePtrIn):
//        """
//Possibility to pass in pointer for beam shape.
//"""
//        return _pythia8.Pythia_setBeamShapePtr(self, beamShapePtrIn)
//
//    def setSigmaPtr(self, sigmaPtrIn, phaseSpacePtrIn=None):
//        """
//Possibility to pass in pointer(s) for external cross section,
//with option to include external phase-space generator(s).
//"""
//        return _pythia8.Pythia_setSigmaPtr(self, sigmaPtrIn, phaseSpacePtrIn)
//
//    def setResonancePtr(self, resonancePtrIn):
//        """
//Possibility to pass in pointer(s) for external resonance.
//"""
//        return _pythia8.Pythia_setResonancePtr(self, resonancePtrIn)
//
//    def setShowerPtr(self, timesDecPtrIn, timesPtrIn=None, spacePtrIn=None):
//        """
//Possibility to pass in pointer for external showers.
//"""
//        return _pythia8.Pythia_setShowerPtr(self, timesDecPtrIn, timesPtrIn, spacePtrIn)
//
//    def setHeavyIonsPtr(self, heavyIonsPtrIn):
//        """
//Possibility to pass in pointer for modelling of heavy ion collisions.
//"""
//        return _pythia8.Pythia_setHeavyIonsPtr(self, heavyIonsPtrIn)
//
//    def setHIHooks(self, hiHooksPtrIn):
//        """
//Possibility to pass a HIUserHooks pointer for modifying the
//behavior of the heavy ion modelling.
//"""
//        return _pythia8.Pythia_setHIHooks(self, hiHooksPtrIn)
//
//    def getHeavyIonsPtr(self):
//        """
//Possibility to get the pointer to a object modelling heavy ion
//collisions.
//"""
//        return _pythia8.Pythia_getHeavyIonsPtr(self)
//
//    def setPartonVertexPtr(self, partonVertexPtrIn):
//        """
//Possibility to pass in pointer for setting of parton space-time vertices.
//"""
//        return _pythia8.Pythia_setPartonVertexPtr(self, partonVertexPtrIn)
//
//    def init(self):
//        """
//Initialize.
//"""
//        return _pythia8.Pythia_init(self)
//
//    def next(self):
//        """
//Generate the next event.
//"""
//        return _pythia8.Pythia_next(self)
//
//    def forceTimeShower(self, iBeg, iEnd, pTmax, nBranchMax=0):
//        """
//Generate only a single timelike shower as in a decay.
//"""
//        return _pythia8.Pythia_forceTimeShower(self, iBeg, iEnd, pTmax, nBranchMax)
//
//    def forceHadronLevel(self, findJunctions=True):
//        """
//Generate only the hadronization/decay stage.
//"""
//        return _pythia8.Pythia_forceHadronLevel(self, findJunctions)
//
//    def moreDecays(self):
//        """
//Special routine to allow more decays if on/off switches changed.
//"""
//        return _pythia8.Pythia_moreDecays(self)
//
//    def forceRHadronDecays(self):
//        """
//Special routine to force R-hadron decay when not done before.
//"""
//        return _pythia8.Pythia_forceRHadronDecays(self)
//
//    def LHAeventList(self):
//        """
//List the current Les Houches event.
//"""
//        return _pythia8.Pythia_LHAeventList(self)
//
//    def LHAeventSkip(self, nSkip):
//        """
//Skip a number of Les Houches events at input.
//"""
//        return _pythia8.Pythia_LHAeventSkip(self, nSkip)
//
//    def stat(self):
//        """
//Main routine to provide final statistics on generation.
//"""
//        return _pythia8.Pythia_stat(self)
//
//    def flag(self, key):
//        """
//Read in settings values: shorthand, not new functionality.
//"""
//        return _pythia8.Pythia_flag(self, key)
//
//    def mode(self, key):
//        """
//"""
//        return _pythia8.Pythia_mode(self, key)
//
//    def parm(self, key):
//        """
//"""
//        return _pythia8.Pythia_parm(self, key)
//
//    def word(self, key):
//        """
//"""
//        return _pythia8.Pythia_word(self, key)
//
//    def getPDFPtr(self, *args):
//        """
//Auxiliary to set parton densities among list of possibilities.
//"""
//        return _pythia8.Pythia_getPDFPtr(self, *args)
//    __swig_setmethods__["process"] = _pythia8.Pythia_process_set
//    __swig_getmethods__["process"] = _pythia8.Pythia_process_get
//    if _newclass:
//        process = _swig_property(_pythia8.Pythia_process_get, _pythia8.Pythia_process_set)
//    __swig_setmethods__["event"] = _pythia8.Pythia_event_set
//    __swig_getmethods__["event"] = _pythia8.Pythia_event_get
//    if _newclass:
//        event = _swig_property(_pythia8.Pythia_event_get, _pythia8.Pythia_event_set)
//    __swig_setmethods__["info"] = _pythia8.Pythia_info_set
//    __swig_getmethods__["info"] = _pythia8.Pythia_info_get
//    if _newclass:
//        info = _swig_property(_pythia8.Pythia_info_get, _pythia8.Pythia_info_set)
//    __swig_setmethods__["settings"] = _pythia8.Pythia_settings_set
//    __swig_getmethods__["settings"] = _pythia8.Pythia_settings_get
//    if _newclass:
//        settings = _swig_property(_pythia8.Pythia_settings_get, _pythia8.Pythia_settings_set)
//    __swig_setmethods__["particleData"] = _pythia8.Pythia_particleData_set
//    __swig_getmethods__["particleData"] = _pythia8.Pythia_particleData_get
//    if _newclass:
//        particleData = _swig_property(_pythia8.Pythia_particleData_get, _pythia8.Pythia_particleData_set)
//    __swig_setmethods__["rndm"] = _pythia8.Pythia_rndm_set
//    __swig_getmethods__["rndm"] = _pythia8.Pythia_rndm_get
//    if _newclass:
//        rndm = _swig_property(_pythia8.Pythia_rndm_get, _pythia8.Pythia_rndm_set)
//    __swig_setmethods__["couplings"] = _pythia8.Pythia_couplings_set
//    __swig_getmethods__["couplings"] = _pythia8.Pythia_couplings_get
//    if _newclass:
//        couplings = _swig_property(_pythia8.Pythia_couplings_get, _pythia8.Pythia_couplings_set)
//    __swig_setmethods__["couplingsPtr"] = _pythia8.Pythia_couplingsPtr_set
//    __swig_getmethods__["couplingsPtr"] = _pythia8.Pythia_couplingsPtr_get
//    if _newclass:
//        couplingsPtr = _swig_property(_pythia8.Pythia_couplingsPtr_get, _pythia8.Pythia_couplingsPtr_set)
//    __swig_setmethods__["slhaInterface"] = _pythia8.Pythia_slhaInterface_set
//    __swig_getmethods__["slhaInterface"] = _pythia8.Pythia_slhaInterface_get
//    if _newclass:
//        slhaInterface = _swig_property(_pythia8.Pythia_slhaInterface_get, _pythia8.Pythia_slhaInterface_set)
//    __swig_setmethods__["partonSystems"] = _pythia8.Pythia_partonSystems_set
//    __swig_getmethods__["partonSystems"] = _pythia8.Pythia_partonSystems_get
//    if _newclass:
//        partonSystems = _swig_property(_pythia8.Pythia_partonSystems_get, _pythia8.Pythia_partonSystems_set)
//    __swig_setmethods__["mergingPtr"] = _pythia8.Pythia_mergingPtr_set
//    __swig_getmethods__["mergingPtr"] = _pythia8.Pythia_mergingPtr_get
//    if _newclass:
//        mergingPtr = _swig_property(_pythia8.Pythia_mergingPtr_get, _pythia8.Pythia_mergingPtr_set)
//    __swig_setmethods__["mergingHooksPtr"] = _pythia8.Pythia_mergingHooksPtr_set
//    __swig_getmethods__["mergingHooksPtr"] = _pythia8.Pythia_mergingHooksPtr_get
//    if _newclass:
//        mergingHooksPtr = _swig_property(_pythia8.Pythia_mergingHooksPtr_get, _pythia8.Pythia_mergingHooksPtr_set)
//    __swig_setmethods__["heavyIonsPtr"] = _pythia8.Pythia_heavyIonsPtr_set
//    __swig_getmethods__["heavyIonsPtr"] = _pythia8.Pythia_heavyIonsPtr_get
//    if _newclass:
//        heavyIonsPtr = _swig_property(_pythia8.Pythia_heavyIonsPtr_get, _pythia8.Pythia_heavyIonsPtr_set)
//    __swig_setmethods__["hiHooksPtr"] = _pythia8.Pythia_hiHooksPtr_set
//    __swig_getmethods__["hiHooksPtr"] = _pythia8.Pythia_hiHooksPtr_get
//    if _newclass:
//        hiHooksPtr = _swig_property(_pythia8.Pythia_hiHooksPtr_get, _pythia8.Pythia_hiHooksPtr_set)
//    __swig_setmethods__["beamA"] = _pythia8.Pythia_beamA_set
//    __swig_getmethods__["beamA"] = _pythia8.Pythia_beamA_get
//    if _newclass:
//        beamA = _swig_property(_pythia8.Pythia_beamA_get, _pythia8.Pythia_beamA_set)
//    __swig_setmethods__["beamB"] = _pythia8.Pythia_beamB_set
//    __swig_getmethods__["beamB"] = _pythia8.Pythia_beamB_get
//    if _newclass:
//        beamB = _swig_property(_pythia8.Pythia_beamB_get, _pythia8.Pythia_beamB_set)
//Pythia_swigregister = _pythia8.Pythia_swigregister
//Pythia_swigregister(Pythia)
//
//class Nucleon(_object):
//    """
//The HIUnits namespace defines the unitsystem used by the heavy ion
//machinery in Pythia8. In particular all lengths are in femtometer
//and cross sections are therefore in squared femtometer.
//Lengths
//Cross sections
//The Nucleon class represent a nucleon in a nucleus. It has an id
//number (proton or neutron) an impact parameter position (absolute
//and relative to the nucleus center), a status and a state to be
//defined and used by a SubCollisionModel.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Nucleon, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, Nucleon, name)
//    __repr__ = _swig_repr
//    UNWOUNDED = _pythia8.Nucleon_UNWOUNDED
//    ELASTIC = _pythia8.Nucleon_ELASTIC
//    DIFF = _pythia8.Nucleon_DIFF
//    ABS = _pythia8.Nucleon_ABS
//
//    def __init__(self, *args):
//        this = _pythia8.new_Nucleon(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def id(self):
//        return _pythia8.Nucleon_id(self)
//
//    def index(self):
//        return _pythia8.Nucleon_index(self)
//
//    def nPos(self):
//        return _pythia8.Nucleon_nPos(self)
//
//    def bPos(self):
//        return _pythia8.Nucleon_bPos(self)
//
//    def bShift(self, bvec):
//        return _pythia8.Nucleon_bShift(self, bvec)
//
//    def done(self):
//        return _pythia8.Nucleon_done(self)
//
//    def event(self):
//        return _pythia8.Nucleon_event(self)
//
//    def altState(self, i=0):
//        return _pythia8.Nucleon_altState(self, i)
//
//    def status(self, *args):
//        return _pythia8.Nucleon_status(self, *args)
//
//    def state(self, *args):
//        return _pythia8.Nucleon_state(self, *args)
//
//    def addAltState(self, s):
//        return _pythia8.Nucleon_addAltState(self, s)
//
//    def select(self, *args):
//        return _pythia8.Nucleon_select(self, *args)
//
//    def debug(self):
//        return _pythia8.Nucleon_debug(self)
//    __swig_destroy__ = _pythia8.delete_Nucleon
//    __del__ = lambda self: None
//Nucleon_swigregister = _pythia8.Nucleon_swigregister
//Nucleon_swigregister(Nucleon)
//femtometer = cvar.femtometer
//millimeter = cvar.millimeter
//femtometer2 = cvar.femtometer2
//millibarn = cvar.millibarn
//nanobarn = cvar.nanobarn
//
//class SubCollision(_object):
//    """
//SubCollision represents a possible collision between a projectile
//and a target Nucleon.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SubCollision, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, SubCollision, name)
//    __repr__ = _swig_repr
//    NONE = _pythia8.SubCollision_NONE
//    ELASTIC = _pythia8.SubCollision_ELASTIC
//    SDEP = _pythia8.SubCollision_SDEP
//    SDET = _pythia8.SubCollision_SDET
//    DDE = _pythia8.SubCollision_DDE
//    CDE = _pythia8.SubCollision_CDE
//    ABS = _pythia8.SubCollision_ABS
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_SubCollision(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def __lt__(self, s):
//        return _pythia8.SubCollision___lt__(self, s)
//
//    def nucleons(self):
//        """
//Return 0 if neither proj or target are neutrons, 1 if target is
//neutron, 2 if projectile is neutron, and 3 if both are neutrons.
//"""
//        return _pythia8.SubCollision_nucleons(self)
//    __swig_setmethods__["proj"] = _pythia8.SubCollision_proj_set
//    __swig_getmethods__["proj"] = _pythia8.SubCollision_proj_get
//    if _newclass:
//        proj = _swig_property(_pythia8.SubCollision_proj_get, _pythia8.SubCollision_proj_set)
//    __swig_setmethods__["targ"] = _pythia8.SubCollision_targ_set
//    __swig_getmethods__["targ"] = _pythia8.SubCollision_targ_get
//    if _newclass:
//        targ = _swig_property(_pythia8.SubCollision_targ_get, _pythia8.SubCollision_targ_set)
//    __swig_setmethods__["b"] = _pythia8.SubCollision_b_set
//    __swig_getmethods__["b"] = _pythia8.SubCollision_b_get
//    if _newclass:
//        b = _swig_property(_pythia8.SubCollision_b_get, _pythia8.SubCollision_b_set)
//    __swig_setmethods__["bp"] = _pythia8.SubCollision_bp_set
//    __swig_getmethods__["bp"] = _pythia8.SubCollision_bp_get
//    if _newclass:
//        bp = _swig_property(_pythia8.SubCollision_bp_get, _pythia8.SubCollision_bp_set)
//    __swig_setmethods__["type"] = _pythia8.SubCollision_type_set
//    __swig_getmethods__["type"] = _pythia8.SubCollision_type_get
//    if _newclass:
//        type = _swig_property(_pythia8.SubCollision_type_get, _pythia8.SubCollision_type_set)
//    __swig_destroy__ = _pythia8.delete_SubCollision
//    __del__ = lambda self: None
//SubCollision_swigregister = _pythia8.SubCollision_swigregister
//SubCollision_swigregister(SubCollision)
//
//class NucleusModel(_object):
//    """
//This class generates the impact parameter distribution of nucleons
//in a nucleus.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, NucleusModel, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, NucleusModel, name)
//
//    def __init__(self, *args, **kwargs):
//        """
//Default constructor giving the nucleis id and an optional
//raduis (in femtometer).
//"""
//        raise AttributeError("No constructor defined - class is abstract")
//    __repr__ = _swig_repr
//    __swig_destroy__ = _pythia8.delete_NucleusModel
//    __del__ = lambda self: None
//
//    def initPtr(self, idIn, settingsIn, particleDataIn, rndIn):
//        """
//Init method.
//"""
//        return _pythia8.NucleusModel_initPtr(self, idIn, settingsIn, particleDataIn, rndIn)
//
//    def init(self):
//        """
//"""
//        return _pythia8.NucleusModel_init(self)
//
//    def produceIon(self, istarg):
//        """
//"""
//        return _pythia8.NucleusModel_produceIon(self, istarg)
//
//    def generate(self):
//        """
//Generate a vector of nucleons according to the implemented model
//for a nucleus given by the PDG number.
//"""
//        return _pythia8.NucleusModel_generate(self)
//
//    def id(self):
//        """
//Accessor functions.
//"""
//        return _pythia8.NucleusModel_id(self)
//
//    def I(self):
//        """
//"""
//        return _pythia8.NucleusModel_I(self)
//
//    def A(self):
//        """
//"""
//        return _pythia8.NucleusModel_A(self)
//
//    def Z(self):
//        """
//"""
//        return _pythia8.NucleusModel_Z(self)
//
//    def L(self):
//        """
//"""
//        return _pythia8.NucleusModel_L(self)
//
//    def R(self):
//        """
//"""
//        return _pythia8.NucleusModel_R(self)
//NucleusModel_swigregister = _pythia8.NucleusModel_swigregister
//NucleusModel_swigregister(NucleusModel)
//
//class WoodsSaxonModel(NucleusModel):
//    __swig_setmethods__ = {}
//    for _s in [NucleusModel]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, WoodsSaxonModel, name, value)
//    __swig_getmethods__ = {}
//    for _s in [NucleusModel]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, WoodsSaxonModel, name)
//
//    def __init__(self, *args, **kwargs):
//        raise AttributeError("No constructor defined - class is abstract")
//    __repr__ = _swig_repr
//
//    def a(self):
//        return _pythia8.WoodsSaxonModel_a(self)
//WoodsSaxonModel_swigregister = _pythia8.WoodsSaxonModel_swigregister
//WoodsSaxonModel_swigregister(WoodsSaxonModel)
//
//class GLISSANDOModel(WoodsSaxonModel):
//    __swig_setmethods__ = {}
//    for _s in [WoodsSaxonModel]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, GLISSANDOModel, name, value)
//    __swig_getmethods__ = {}
//    for _s in [WoodsSaxonModel]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, GLISSANDOModel, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        this = _pythia8.new_GLISSANDOModel()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_GLISSANDOModel
//    __del__ = lambda self: None
//
//    def init(self):
//        return _pythia8.GLISSANDOModel_init(self)
//
//    def generate(self):
//        return _pythia8.GLISSANDOModel_generate(self)
//
//    def Rh(self):
//        return _pythia8.GLISSANDOModel_Rh(self)
//
//    def RhGauss(self):
//        return _pythia8.GLISSANDOModel_RhGauss(self)
//GLISSANDOModel_swigregister = _pythia8.GLISSANDOModel_swigregister
//GLISSANDOModel_swigregister(GLISSANDOModel)
//
//class ImpactParameterGenerator(_object):
//    """
//ImpactParameterGenerator is able to generate a specific impact
//parameter together with a weight such that aweighted average over
//any quantity X(b) corresponds to the infinite integral over d^2b
//X(b). This base class gives a Gaussian profile, d^2b exp(-b^2/2w^2).
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, ImpactParameterGenerator, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, ImpactParameterGenerator, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//The default constructor takes a gneral width (in femtometers) as
//argument.
//"""
//        this = _pythia8.new_ImpactParameterGenerator()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_ImpactParameterGenerator
//    __del__ = lambda self: None
//
//    def init(self):
//        """
//Virtual init method.
//"""
//        return _pythia8.ImpactParameterGenerator_init(self)
//
//    def initPtr(self, collIn, projIn, targIn, settingsIn, rndIn):
//        """
//"""
//        return _pythia8.ImpactParameterGenerator_initPtr(self, collIn, projIn, targIn, settingsIn, rndIn)
//
//    def generate(self, weight):
//        """
//Return a new impact parameter and set the corresponding weight
//provided.
//"""
//        return _pythia8.ImpactParameterGenerator_generate(self, weight)
//
//    def width(self, *args):
//        """
//Get the width.
//"""
//        return _pythia8.ImpactParameterGenerator_width(self, *args)
//ImpactParameterGenerator_swigregister = _pythia8.ImpactParameterGenerator_swigregister
//ImpactParameterGenerator_swigregister(ImpactParameterGenerator)
//
//class SubCollisionModel(_object):
//    """
//The SubCollisionModel is is able to model the collision between two
//nucleons to tell which type of collision has occurred. The model
//may manipulate the corresponing state of the nucleons.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, SubCollisionModel, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, SubCollisionModel, name)
//
//    def __init__(self, *args, **kwargs):
//        """
//The default constructor is empty.
//"""
//        raise AttributeError("No constructor defined - class is abstract")
//    __repr__ = _swig_repr
//    __swig_destroy__ = _pythia8.delete_SubCollisionModel
//    __del__ = lambda self: None
//
//    def init(self):
//        """
//Virtual init method.
//"""
//        return _pythia8.SubCollisionModel_init(self)
//
//    def initPtr(self, projIn, targIn, sigTotIn, settingsIn, infoIn, rndIn):
//        """
//"""
//        return _pythia8.SubCollisionModel_initPtr(self, projIn, targIn, sigTotIn, settingsIn, infoIn, rndIn)
//
//    def getCollisions(self, proj, targ, bvec, T):
//        """
//Take two vectors of Nucleons and an impact parameter vector and
//produce the corrsponding sub-collisions. Note that states of the
//nucleons may be changed. The function in this abstract base
//class will reset the nucleon states for convenience. The
//sub-collisions are ordered in the impact parameter distance
//between the nucleons. The T-variable will be set to the summed
//elastic amplityde.
//"""
//        return _pythia8.SubCollisionModel_getCollisions(self, proj, targ, bvec, T)
//
//    def sigTot(self):
//        """
//Access the nucleon-nucleon cross sections assumed
//for this model.
//The total cross section.
//"""
//        return _pythia8.SubCollisionModel_sigTot(self)
//
//    def sigEl(self):
//        """
//The total cross section.
//"""
//        return _pythia8.SubCollisionModel_sigEl(self)
//
//    def sigCDE(self):
//        """
//The central diffractive excitation cross section.
//"""
//        return _pythia8.SubCollisionModel_sigCDE(self)
//
//    def sigSDE(self):
//        """
//The single diffractive excitation cross section (both sides summed).
//"""
//        return _pythia8.SubCollisionModel_sigSDE(self)
//
//    def sigSDEP(self):
//        """
//The single diffractive excitation cross section (excited projectile).
//"""
//        return _pythia8.SubCollisionModel_sigSDEP(self)
//
//    def sigSDET(self):
//        """
//The single diffractive excitation cross section (excited target).
//"""
//        return _pythia8.SubCollisionModel_sigSDET(self)
//
//    def sigDDE(self):
//        """
//The double diffractive excitation cross section.
//"""
//        return _pythia8.SubCollisionModel_sigDDE(self)
//
//    def sigND(self):
//        """
//The non-diffractive (absorptive) cross section.
//"""
//        return _pythia8.SubCollisionModel_sigND(self)
//
//    def bSlope(self):
//        """
//The elastic b-slope parameter.
//"""
//        return _pythia8.SubCollisionModel_bSlope(self)
//
//    def getSig(self):
//        """
//Calculate the cross sections for the given set of parameters.
//"""
//        return _pythia8.SubCollisionModel_getSig(self)
//
//    def avNDB(self):
//        """
//Return the average non-diffractive impact parameter.
//"""
//        return _pythia8.SubCollisionModel_avNDB(self)
//
//    def Chi2(self, sigs, npar):
//        """
//Calculate the Chi2 for the given cross section estimates.
//"""
//        return _pythia8.SubCollisionModel_Chi2(self, sigs, npar)
//
//    def evolve(self):
//        """
//Use a simlified genetic algorithm to fit the parameters.
//"""
//        return _pythia8.SubCollisionModel_evolve(self)
//
//    def setParm(self, arg2):
//        """
//Set the parameters of this model.
//"""
//        return _pythia8.SubCollisionModel_setParm(self, arg2)
//
//    def getParm(self):
//        """
//Return the current parameters and the minimum and maximum
//allowed values for the parameters of this model.
//"""
//        return _pythia8.SubCollisionModel_getParm(self)
//
//    def minParm(self):
//        """
//"""
//        return _pythia8.SubCollisionModel_minParm(self)
//
//    def maxParm(self):
//        """
//"""
//        return _pythia8.SubCollisionModel_maxParm(self)
//SubCollisionModel_swigregister = _pythia8.SubCollisionModel_swigregister
//SubCollisionModel_swigregister(SubCollisionModel)
//
//class NaiveSubCollisionModel(SubCollisionModel):
//    __swig_setmethods__ = {}
//    for _s in [SubCollisionModel]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, NaiveSubCollisionModel, name, value)
//    __swig_getmethods__ = {}
//    for _s in [SubCollisionModel]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, NaiveSubCollisionModel, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        this = _pythia8.new_NaiveSubCollisionModel()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_NaiveSubCollisionModel
//    __del__ = lambda self: None
//
//    def getCollisions(self, proj, targ, bvec, T):
//        return _pythia8.NaiveSubCollisionModel_getCollisions(self, proj, targ, bvec, T)
//NaiveSubCollisionModel_swigregister = _pythia8.NaiveSubCollisionModel_swigregister
//NaiveSubCollisionModel_swigregister(NaiveSubCollisionModel)
//
//class DoubleStrikman(SubCollisionModel):
//    __swig_setmethods__ = {}
//    for _s in [SubCollisionModel]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleStrikman, name, value)
//    __swig_getmethods__ = {}
//    for _s in [SubCollisionModel]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, DoubleStrikman, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, modein=0):
//        this = _pythia8.new_DoubleStrikman(modein)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_DoubleStrikman
//    __del__ = lambda self: None
//
//    def getCollisions(self, proj, targ, bvec, T):
//        return _pythia8.DoubleStrikman_getCollisions(self, proj, targ, bvec, T)
//
//    def gamma(self):
//        return _pythia8.DoubleStrikman_gamma(self)
//
//    def opacity(self, sig):
//        return _pythia8.DoubleStrikman_opacity(self, sig)
//
//    def Tpt(self, p, t, b):
//        return _pythia8.DoubleStrikman_Tpt(self, p, t, b)
//
//    def getSig(self):
//        return _pythia8.DoubleStrikman_getSig(self)
//
//    def setParm(self, arg2):
//        return _pythia8.DoubleStrikman_setParm(self, arg2)
//
//    def getParm(self):
//        return _pythia8.DoubleStrikman_getParm(self)
//
//    def minParm(self):
//        return _pythia8.DoubleStrikman_minParm(self)
//
//    def maxParm(self):
//        return _pythia8.DoubleStrikman_maxParm(self)
//    __swig_getmethods__["shuffle"] = lambda x: _pythia8.DoubleStrikman_shuffle
//    if _newclass:
//        shuffle = staticmethod(_pythia8.DoubleStrikman_shuffle)
//    __swig_getmethods__["shuffel"] = lambda x: _pythia8.DoubleStrikman_shuffel
//    if _newclass:
//        shuffel = staticmethod(_pythia8.DoubleStrikman_shuffel)
//    __swig_getmethods__["PNW"] = lambda x: _pythia8.DoubleStrikman_PNW
//    if _newclass:
//        PNW = staticmethod(_pythia8.DoubleStrikman_PNW)
//DoubleStrikman_swigregister = _pythia8.DoubleStrikman_swigregister
//DoubleStrikman_swigregister(DoubleStrikman)
//
//def DoubleStrikman_shuffle(PND1, PND2, PW1, PW2):
//    return _pythia8.DoubleStrikman_shuffle(PND1, PND2, PW1, PW2)
//DoubleStrikman_shuffle = _pythia8.DoubleStrikman_shuffle
//
//def DoubleStrikman_shuffel(PEL11, P11, P12, P21, P22):
//    return _pythia8.DoubleStrikman_shuffel(PEL11, P11, P12, P21, P22)
//DoubleStrikman_shuffel = _pythia8.DoubleStrikman_shuffel
//
//def DoubleStrikman_PNW(PWp, PWt, PND):
//    return _pythia8.DoubleStrikman_PNW(PWp, PWt, PND)
//DoubleStrikman_PNW = _pythia8.DoubleStrikman_PNW
//
//class MultiRadial(SubCollisionModel):
//    __swig_setmethods__ = {}
//    for _s in [SubCollisionModel]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, MultiRadial, name, value)
//    __swig_getmethods__ = {}
//    for _s in [SubCollisionModel]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, MultiRadial, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, NrIn=0):
//        this = _pythia8.new_MultiRadial(NrIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_MultiRadial
//    __del__ = lambda self: None
//
//    def getCollisions(self, proj, targ, bvec, T):
//        return _pythia8.MultiRadial_getCollisions(self, proj, targ, bvec, T)
//
//    def Tpt(self, p, t, b):
//        return _pythia8.MultiRadial_Tpt(self, p, t, b)
//
//    def getSig(self):
//        return _pythia8.MultiRadial_getSig(self)
//
//    def setParm(self, arg2):
//        return _pythia8.MultiRadial_setParm(self, arg2)
//
//    def getParm(self):
//        return _pythia8.MultiRadial_getParm(self)
//
//    def minParm(self):
//        return _pythia8.MultiRadial_minParm(self)
//
//    def maxParm(self):
//        return _pythia8.MultiRadial_maxParm(self)
//MultiRadial_swigregister = _pythia8.MultiRadial_swigregister
//MultiRadial_swigregister(MultiRadial)
//
//class EventInfo(_object):
//    """
//Class for storing Events and Info objects.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, EventInfo, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, EventInfo, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Empty constructor.
//"""
//        this = _pythia8.new_EventInfo()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_setmethods__["event"] = _pythia8.EventInfo_event_set
//    __swig_getmethods__["event"] = _pythia8.EventInfo_event_get
//    if _newclass:
//        event = _swig_property(_pythia8.EventInfo_event_get, _pythia8.EventInfo_event_set)
//    __swig_setmethods__["info"] = _pythia8.EventInfo_info_set
//    __swig_getmethods__["info"] = _pythia8.EventInfo_info_get
//    if _newclass:
//        info = _swig_property(_pythia8.EventInfo_info_get, _pythia8.EventInfo_info_set)
//    __swig_setmethods__["ordering"] = _pythia8.EventInfo_ordering_set
//    __swig_getmethods__["ordering"] = _pythia8.EventInfo_ordering_get
//    if _newclass:
//        ordering = _swig_property(_pythia8.EventInfo_ordering_get, _pythia8.EventInfo_ordering_set)
//
//    def __lt__(self, ei):
//        return _pythia8.EventInfo___lt__(self, ei)
//    __swig_setmethods__["coll"] = _pythia8.EventInfo_coll_set
//    __swig_getmethods__["coll"] = _pythia8.EventInfo_coll_get
//    if _newclass:
//        coll = _swig_property(_pythia8.EventInfo_coll_get, _pythia8.EventInfo_coll_set)
//    __swig_setmethods__["ok"] = _pythia8.EventInfo_ok_set
//    __swig_getmethods__["ok"] = _pythia8.EventInfo_ok_get
//    if _newclass:
//        ok = _swig_property(_pythia8.EventInfo_ok_get, _pythia8.EventInfo_ok_set)
//    __swig_setmethods__["projs"] = _pythia8.EventInfo_projs_set
//    __swig_getmethods__["projs"] = _pythia8.EventInfo_projs_get
//    if _newclass:
//        projs = _swig_property(_pythia8.EventInfo_projs_get, _pythia8.EventInfo_projs_set)
//    __swig_setmethods__["targs"] = _pythia8.EventInfo_targs_set
//    __swig_getmethods__["targs"] = _pythia8.EventInfo_targs_get
//    if _newclass:
//        targs = _swig_property(_pythia8.EventInfo_targs_get, _pythia8.EventInfo_targs_set)
//    __swig_destroy__ = _pythia8.delete_EventInfo
//    __del__ = lambda self: None
//EventInfo_swigregister = _pythia8.EventInfo_swigregister
//EventInfo_swigregister(EventInfo)
//
//class HIInfo(_object):
//    """
//Class for collecting info about a Heavy Ion run and its produced
//events.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HIInfo, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, HIInfo, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        this = _pythia8.new_HIInfo()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def b(self):
//        return _pythia8.HIInfo_b(self)
//
//    def sigmaTot(self):
//        return _pythia8.HIInfo_sigmaTot(self)
//
//    def sigmaTotErr(self):
//        return _pythia8.HIInfo_sigmaTotErr(self)
//
//    def sigmaND(self):
//        return _pythia8.HIInfo_sigmaND(self)
//
//    def sigmaNDErr(self):
//        return _pythia8.HIInfo_sigmaNDErr(self)
//
//    def nAttempts(self):
//        return _pythia8.HIInfo_nAttempts(self)
//
//    def nAccepted(self):
//        return _pythia8.HIInfo_nAccepted(self)
//
//    def nCollTot(self):
//        return _pythia8.HIInfo_nCollTot(self)
//
//    def nCollND(self):
//        return _pythia8.HIInfo_nCollND(self)
//
//    def nCollNDTot(self):
//        return _pythia8.HIInfo_nCollNDTot(self)
//
//    def nCollSDP(self):
//        return _pythia8.HIInfo_nCollSDP(self)
//
//    def nCollSDT(self):
//        return _pythia8.HIInfo_nCollSDT(self)
//
//    def nCollDD(self):
//        return _pythia8.HIInfo_nCollDD(self)
//
//    def nCollCD(self):
//        return _pythia8.HIInfo_nCollCD(self)
//
//    def nCollEL(self):
//        return _pythia8.HIInfo_nCollEL(self)
//
//    def nPartProj(self):
//        return _pythia8.HIInfo_nPartProj(self)
//
//    def nAbsProj(self):
//        return _pythia8.HIInfo_nAbsProj(self)
//
//    def nDiffProj(self):
//        return _pythia8.HIInfo_nDiffProj(self)
//
//    def nElProj(self):
//        return _pythia8.HIInfo_nElProj(self)
//
//    def nPartTarg(self):
//        return _pythia8.HIInfo_nPartTarg(self)
//
//    def nAbsTarg(self):
//        return _pythia8.HIInfo_nAbsTarg(self)
//
//    def nDiffTarg(self):
//        return _pythia8.HIInfo_nDiffTarg(self)
//
//    def nElTarg(self):
//        return _pythia8.HIInfo_nElTarg(self)
//
//    def weight(self):
//        return _pythia8.HIInfo_weight(self)
//
//    def weightSum(self):
//        return _pythia8.HIInfo_weightSum(self)
//
//    def nFail(self):
//        return _pythia8.HIInfo_nFail(self)
//
//    def failedExcitation(self):
//        return _pythia8.HIInfo_failedExcitation(self)
//
//    def subCollisionsPtr(self, *args):
//        return _pythia8.HIInfo_subCollisionsPtr(self, *args)
//    __swig_destroy__ = _pythia8.delete_HIInfo
//    __del__ = lambda self: None
//HIInfo_swigregister = _pythia8.HIInfo_swigregister
//HIInfo_swigregister(HIInfo)
//
//class HIUserHooks(_object):
//    """
//This is the heavy ion user hooks class which in the future may be
//used inside a Pythia object to generate heavy ion collisons. For
//now it is used outside Pythia and requires access to a number of
//Pythia objects.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HIUserHooks, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, HIUserHooks, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//The default constructor is empty.
//"""
//        this = _pythia8.new_HIUserHooks()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HIUserHooks
//    __del__ = lambda self: None
//
//    def init(self, idProjIn, idTargIn):
//        """
//Initialize this user hook.
//"""
//        return _pythia8.HIUserHooks_init(self, idProjIn, idTargIn)
//
//    def hasImpactParameterGenerator(self):
//        """
//A user-supplied impact parameter generator.
//"""
//        return _pythia8.HIUserHooks_hasImpactParameterGenerator(self)
//
//    def impactParameterGenerator(self):
//        """
//"""
//        return _pythia8.HIUserHooks_impactParameterGenerator(self)
//
//    def hasProjectileModel(self):
//        """
//A suser-supplied NucleusModel for the projectile and target.
//"""
//        return _pythia8.HIUserHooks_hasProjectileModel(self)
//
//    def projectileModel(self):
//        """
//"""
//        return _pythia8.HIUserHooks_projectileModel(self)
//
//    def hasTargetModel(self):
//        """
//"""
//        return _pythia8.HIUserHooks_hasTargetModel(self)
//
//    def targetModel(self):
//        """
//"""
//        return _pythia8.HIUserHooks_targetModel(self)
//
//    def hasSubCollisionModel(self):
//        """
//A user-supplied SubCollisionModel for generating nucleon-nucleon
//subcollisions.
//"""
//        return _pythia8.HIUserHooks_hasSubCollisionModel(self)
//
//    def subCollisionModel(self):
//        """
//"""
//        return _pythia8.HIUserHooks_subCollisionModel(self)
//
//    def hasEventOrdering(self):
//        """
//A user-supplied ordering of events in (inverse) hardness.
//"""
//        return _pythia8.HIUserHooks_hasEventOrdering(self)
//
//    def eventOrdering(self, arg2, arg3):
//        """
//"""
//        return _pythia8.HIUserHooks_eventOrdering(self, arg2, arg3)
//
//    def canFixIsoSpin(self):
//        """
//A user-supplied method for fixing up proton-neutron mismatch in
//generated beams.
//"""
//        return _pythia8.HIUserHooks_canFixIsoSpin(self)
//
//    def fixIsoSpin(self, arg2):
//        """
//"""
//        return _pythia8.HIUserHooks_fixIsoSpin(self, arg2)
//
//    def canShiftEvent(self):
//        """
//A user-supplied method for shifting the event in impact parameter space.
//"""
//        return _pythia8.HIUserHooks_canShiftEvent(self)
//
//    def shiftEvent(self, ei):
//        """
//"""
//        return _pythia8.HIUserHooks_shiftEvent(self, ei)
//
//    def canAddNucleonExcitation(self):
//        """
//A user-supplied method of adding a diffractive excitation event
//to another event, optionally connecting their colours.
//"""
//        return _pythia8.HIUserHooks_canAddNucleonExcitation(self)
//
//    def addNucleonExcitation(self, arg2, arg3, arg4):
//        """
//"""
//        return _pythia8.HIUserHooks_addNucleonExcitation(self, arg2, arg3, arg4)
//
//    def canForceHadronLevel(self):
//        """
//A user supplied wrapper around the Pythia::forceHadronLevel()
//"""
//        return _pythia8.HIUserHooks_canForceHadronLevel(self)
//
//    def forceHadronLevel(self, arg2):
//        """
//"""
//        return _pythia8.HIUserHooks_forceHadronLevel(self, arg2)
//
//    def canFindRecoilers(self):
//        """
//A user-supplied way of finding the remnants of an
//non-diffrcative pp collision (on the target side if tside is
//true) to be used to give momentum when adding.
//"""
//        return _pythia8.HIUserHooks_canFindRecoilers(self)
//
//    def findRecoilers(self, arg2, arg3, arg4, arg5, arg6, arg7):
//        """
//"""
//        return _pythia8.HIUserHooks_findRecoilers(self, arg2, arg3, arg4, arg5, arg6, arg7)
//HIUserHooks_swigregister = _pythia8.HIUserHooks_swigregister
//HIUserHooks_swigregister(HIUserHooks)
//
//class amcnlo_unitarised_interface(UserHooks):
//    """
//Constants.
//Local properties.
//"""
//    __swig_setmethods__ = {}
//    for _s in [UserHooks]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, amcnlo_unitarised_interface, name, value)
//    __swig_getmethods__ = {}
//    for _s in [UserHooks]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, amcnlo_unitarised_interface, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//"""
//        this = _pythia8.new_amcnlo_unitarised_interface(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_amcnlo_unitarised_interface
//    __del__ = lambda self: None
//
//    def getNormFactor(self):
//        """
//"""
//        return _pythia8.amcnlo_unitarised_interface_getNormFactor(self)
//
//    def canVetoProcessLevel(self):
//        """
//Allow to set the number of partons.
//"""
//        return _pythia8.amcnlo_unitarised_interface_canVetoProcessLevel(self)
//
//    def doVetoProcessLevel(self, process):
//        """
//Set the number of partons.
//"""
//        return _pythia8.amcnlo_unitarised_interface_doVetoProcessLevel(self, process)
//amcnlo_unitarised_interface_swigregister = _pythia8.amcnlo_unitarised_interface_swigregister
//amcnlo_unitarised_interface_swigregister(amcnlo_unitarised_interface)
//
//class MBReconUserHooks(UserHooks):
//    """
//Done
//"""
//    __swig_setmethods__ = {}
//    for _s in [UserHooks]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, MBReconUserHooks, name, value)
//    __swig_getmethods__ = {}
//    for _s in [UserHooks]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, MBReconUserHooks, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, modeIn=0, flipIn=0, dLamCutIn=0., fracGluonIn=1.):
//        """
//Constructor and destructor.
//mode = 0: no reconnection (dummy option, does nothing);
//     = 1: swap gluons to minimize lambda.
//     = 2: move gluons to minimize lambda.
//flip = 0: no flip between quark-antiquark ends.
//     = 1: flip between quark-antiquark ends, excluding junction systems.
//     = 2: flip between quark-antiquark ends, including junction systems.
//dLamCut: smallest -delta-lambda value for which to swap/mode (positive).
//fracGluon: the fraction of gluons that will be studied for reconnection.
//m2Ref   : squared reference mass scale for lambda measure calculation.
//"""
//        this = _pythia8.new_MBReconUserHooks(modeIn, flipIn, dLamCutIn, fracGluonIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_MBReconUserHooks
//    __del__ = lambda self: None
//
//    def canReconnectResonanceSystems(self):
//        """
//Allow colour reconnection after resonance decays (early or late)...
//"""
//        return _pythia8.MBReconUserHooks_canReconnectResonanceSystems(self)
//
//    def doReconnectResonanceSystems(self, arg2, event):
//        """
//...which gives access to the event, for modification.
//"""
//        return _pythia8.MBReconUserHooks_doReconnectResonanceSystems(self, arg2, event)
//MBReconUserHooks_swigregister = _pythia8.MBReconUserHooks_swigregister
//MBReconUserHooks_swigregister(MBReconUserHooks)
//
//class TopReconUserHooks(UserHooks):
//    """
//Done.
//"""
//    __swig_setmethods__ = {}
//    for _s in [UserHooks]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, TopReconUserHooks, name, value)
//    __swig_getmethods__ = {}
//    for _s in [UserHooks]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, TopReconUserHooks, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, modeIn=0, strengthIn=1.):
//        """
//Constructor and destructor.
//mode = 0: no reconnection of tops (dummy option, does nothing);
//     = 1: reconnect with random background gluon;
//     = 2: reconnect with nearest (smallest-mass) background gluon;
//     = 3: reconnect with furthest (largest-mass) background gluon;
//     = 4: reconnect with smallest (with sign) lambda measure shift;
//     = 5: reconnect only if reduced lamda, and then to most reduction.
//strength: fraction of top gluons that is to be colour reconnected.
//nList: list first nList parton classifications.
//pTolerance: acceptable total momentum error (in reconstruction check).
//m2Ref: squared reference mass scale for lambda measure calculation.
//Possible variants for the future: swap with nearest in angle, not mass,
//and/or only allow a background gluon to swap colours once.
//"""
//        this = _pythia8.new_TopReconUserHooks(modeIn, strengthIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_TopReconUserHooks
//    __del__ = lambda self: None
//
//    def canReconnectResonanceSystems(self):
//        """
//Allow colour reconnection after resonance decays (early or late)...
//"""
//        return _pythia8.TopReconUserHooks_canReconnectResonanceSystems(self)
//
//    def doReconnectResonanceSystems(self, arg2, event):
//        """
//...which gives access to the event, for modification.
//"""
//        return _pythia8.TopReconUserHooks_doReconnectResonanceSystems(self, arg2, event)
//TopReconUserHooks_swigregister = _pythia8.TopReconUserHooks_swigregister
//TopReconUserHooks_swigregister(TopReconUserHooks)
//
//class AlpgenPar(_object):
//    """
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, AlpgenPar, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, AlpgenPar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, infoPtrIn=None):
//        """
//Constructor
//"""
//        this = _pythia8.new_AlpgenPar(infoPtrIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def parse(self, paramStr):
//        """
//Parse as incoming ALPGEN parameter file (passed as string)
//"""
//        return _pythia8.AlpgenPar_parse(self, paramStr)
//
//    def extractRunParam(self, line):
//        """
//Parse an incoming parameter line
//"""
//        return _pythia8.AlpgenPar_extractRunParam(self, line)
//
//    def haveParam(self, paramIn):
//        """
//Check if a parameter exists
//"""
//        return _pythia8.AlpgenPar_haveParam(self, paramIn)
//
//    def getParam(self, paramIn):
//        """
//Get a parameter as a double or integer.
//Caller should have already checked existance of the parameter.
//"""
//        return _pythia8.AlpgenPar_getParam(self, paramIn)
//
//    def getParamAsInt(self, paramIn):
//        """
//"""
//        return _pythia8.AlpgenPar_getParamAsInt(self, paramIn)
//
//    def printParams(self):
//        """
//Print parameters read from the '.par' file
//"""
//        return _pythia8.AlpgenPar_printParams(self)
//    __swig_destroy__ = _pythia8.delete_AlpgenPar
//    __del__ = lambda self: None
//AlpgenPar_swigregister = _pythia8.AlpgenPar_swigregister
//AlpgenPar_swigregister(AlpgenPar)
//
//class LHAupAlpgen(LHAup):
//    """
//Storage for parameters
//Info pointer if provided
//Constants
//"""
//    __swig_setmethods__ = {}
//    for _s in [LHAup]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, LHAupAlpgen, name, value)
//    __swig_getmethods__ = {}
//    for _s in [LHAup]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, LHAupAlpgen, name)
//
//    def __init__(self, *args, **kwargs):
//        """
//Constructor and destructor.
//"""
//        raise AttributeError("No constructor defined - class is abstract")
//    __repr__ = _swig_repr
//    __swig_destroy__ = _pythia8.delete_LHAupAlpgen
//    __del__ = lambda self: None
//
//    def fileFound(self):
//        """
//Override fileFound routine from LHAup.
//"""
//        return _pythia8.LHAupAlpgen_fileFound(self)
//
//    def setInit(self):
//        """
//Override setInit/setEvent routines from LHAup.
//"""
//        return _pythia8.LHAupAlpgen_setInit(self)
//
//    def setEvent(self, arg2):
//        """
//"""
//        return _pythia8.LHAupAlpgen_setEvent(self, arg2)
//
//    def printParticles(self):
//        """
//Print list of particles; mainly intended for debugging
//"""
//        return _pythia8.LHAupAlpgen_printParticles(self)
//LHAupAlpgen_swigregister = _pythia8.LHAupAlpgen_swigregister
//LHAupAlpgen_swigregister(LHAupAlpgen)
//
//class AlpgenHooks(UserHooks):
//    """
//Class variables
//Incoming filenames
//Parameter database
//Process code
//Beam energies
//Heavy flavours for certain processes
//Bottom mass
//Input file stream for 'unw' file
//Input stream for 'unw' file
//Local storage for particles
//Constants
//"""
//    __swig_setmethods__ = {}
//    for _s in [UserHooks]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, AlpgenHooks, name, value)
//    __swig_getmethods__ = {}
//    for _s in [UserHooks]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, AlpgenHooks, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, pythia):
//        """
//Constructor and destructor
//"""
//        this = _pythia8.new_AlpgenHooks(pythia)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_AlpgenHooks
//    __del__ = lambda self: None
//
//    def initAfterBeams(self):
//        """
//Override initAfterBeams routine from UserHooks
//"""
//        return _pythia8.AlpgenHooks_initAfterBeams(self)
//AlpgenHooks_swigregister = _pythia8.AlpgenHooks_swigregister
//AlpgenHooks_swigregister(AlpgenHooks)
//
//class MadgraphPar(_object):
//    """
//LHAupAlpgen pointer
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, MadgraphPar, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, MadgraphPar, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, infoPtrIn=None):
//        """
//Constructor
//"""
//        this = _pythia8.new_MadgraphPar(infoPtrIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def parse(self, paramStr):
//        """
//Parse an incoming Madgraph parameter file string
//"""
//        return _pythia8.MadgraphPar_parse(self, paramStr)
//
//    def extractRunParam(self, line):
//        """
//Block 1 or 2: extract parameters
//"""
//        return _pythia8.MadgraphPar_extractRunParam(self, line)
//
//    def haveParam(self, paramIn):
//        """
//Check if a parameter exists
//"""
//        return _pythia8.MadgraphPar_haveParam(self, paramIn)
//
//    def getParam(self, paramIn):
//        """
//Get a parameter as a double or integer.
//Caller should have already checked existance of the parameter.
//"""
//        return _pythia8.MadgraphPar_getParam(self, paramIn)
//
//    def getParamAsInt(self, paramIn):
//        """
//"""
//        return _pythia8.MadgraphPar_getParamAsInt(self, paramIn)
//
//    def printParams(self):
//        """
//Print parameters read from the '.par' file
//"""
//        return _pythia8.MadgraphPar_printParams(self)
//    __swig_destroy__ = _pythia8.delete_MadgraphPar
//    __del__ = lambda self: None
//MadgraphPar_swigregister = _pythia8.MadgraphPar_swigregister
//MadgraphPar_swigregister(MadgraphPar)
//
//class HJSlowJet(SlowJet):
//    __swig_setmethods__ = {}
//    for _s in [SlowJet]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HJSlowJet, name, value)
//    __swig_getmethods__ = {}
//    for _s in [SlowJet]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, HJSlowJet, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, powerIn, Rin, pTjetMinIn=0., etaMaxIn=25., selectIn=1, massSetIn=2, sjHookPtrIn=None, useFJcoreIn=False, useStandardRin=True):
//        this = _pythia8.new_HJSlowJet(powerIn, Rin, pTjetMinIn, etaMaxIn, selectIn, massSetIn, sjHookPtrIn, useFJcoreIn, useStandardRin)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_HJSlowJet
//    __del__ = lambda self: None
//HJSlowJet_swigregister = _pythia8.HJSlowJet_swigregister
//HJSlowJet_swigregister(HJSlowJet)
//
//class JetMatching(UserHooks):
//    """
//If no clusters left then instead default values.
//"""
//    __swig_setmethods__ = {}
//    for _s in [UserHooks]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, JetMatching, name, value)
//    __swig_getmethods__ = {}
//    for _s in [UserHooks]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, JetMatching, name)
//
//    def __init__(self, *args, **kwargs):
//        """
//Constructor and destructor
//"""
//        raise AttributeError("No constructor defined - class is abstract")
//    __repr__ = _swig_repr
//    __swig_destroy__ = _pythia8.delete_JetMatching
//    __del__ = lambda self: None
//
//    def initAfterBeams(self):
//        """
//Initialisation
//"""
//        return _pythia8.JetMatching_initAfterBeams(self)
//
//    def canVetoProcessLevel(self):
//        """
//Process level vetos
//"""
//        return _pythia8.JetMatching_canVetoProcessLevel(self)
//
//    def doVetoProcessLevel(self, process):
//        """
//"""
//        return _pythia8.JetMatching_doVetoProcessLevel(self, process)
//
//    def canVetoPartonLevelEarly(self):
//        """
//Parton level vetos (before beam remnants and resonance decays)
//"""
//        return _pythia8.JetMatching_canVetoPartonLevelEarly(self)
//
//    def doVetoPartonLevelEarly(self, event):
//        """
//"""
//        return _pythia8.JetMatching_doVetoPartonLevelEarly(self, event)
//
//    def numberVetoStep(self):
//        """
//Shower step vetoes (after the first emission, for Shower-kT scheme)
//"""
//        return _pythia8.JetMatching_numberVetoStep(self)
//
//    def canVetoStep(self):
//        """
//"""
//        return _pythia8.JetMatching_canVetoStep(self)
//
//    def doVetoStep(self, arg2, arg3, arg4, arg5):
//        """
//"""
//        return _pythia8.JetMatching_doVetoStep(self, arg2, arg3, arg4, arg5)
//JetMatching_swigregister = _pythia8.JetMatching_swigregister
//JetMatching_swigregister(JetMatching)
//
//class JetMatchingAlpgen(JetMatching):
//    """
//Master switch for merging
//Switch for merging in the shower-kT scheme. Needed here because
//the scheme uses different UserHooks functionality.
//Maximum and current number of jets
//Jet algorithm parameters
//Internal jet algorithms
//SlowJet specific
//Event records to store original incoming process, final-state of the
//incoming process and what will be passed to the jet algorithm.
//Not completely necessary to store all steps, but makes tracking the
//steps of the algorithm a lot easier.
//Sort final-state of incoming process into light/heavy jets and 'other'
//Momenta output of jet algorithm (to provide same output regardless of
//the selected jet algorithm)
//CellJet specific
//Merging procedure parameters
//Store the minimum eT/pT of matched light jets
//"""
//    __swig_setmethods__ = {}
//    for _s in [JetMatching]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, JetMatchingAlpgen, name, value)
//    __swig_getmethods__ = {}
//    for _s in [JetMatching]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, JetMatchingAlpgen, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor and destructor
//"""
//        this = _pythia8.new_JetMatchingAlpgen()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_JetMatchingAlpgen
//    __del__ = lambda self: None
//
//    def initAfterBeams(self):
//        """
//Initialisation
//"""
//        return _pythia8.JetMatchingAlpgen_initAfterBeams(self)
//JetMatchingAlpgen_swigregister = _pythia8.JetMatchingAlpgen_swigregister
//JetMatchingAlpgen_swigregister(JetMatchingAlpgen)
//
//class JetMatchingMadgraph(JetMatching):
//    """
//Constants
//"""
//    __swig_setmethods__ = {}
//    for _s in [JetMatching]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, JetMatchingMadgraph, name, value)
//    __swig_getmethods__ = {}
//    for _s in [JetMatching]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, JetMatchingMadgraph, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor and destructor
//"""
//        this = _pythia8.new_JetMatchingMadgraph()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_JetMatchingMadgraph
//    __del__ = lambda self: None
//
//    def initAfterBeams(self):
//        """
//Initialisation
//"""
//        return _pythia8.JetMatchingMadgraph_initAfterBeams(self)
//
//    def canVetoProcessLevel(self):
//        """
//Process level vetos
//"""
//        return _pythia8.JetMatchingMadgraph_canVetoProcessLevel(self)
//
//    def doVetoProcessLevel(self, process):
//        """
//"""
//        return _pythia8.JetMatchingMadgraph_doVetoProcessLevel(self, process)
//
//    def numberVetoStep(self):
//        """
//Shower step vetoes (after the first emission, for Shower-kT scheme)
//"""
//        return _pythia8.JetMatchingMadgraph_numberVetoStep(self)
//
//    def canVetoStep(self):
//        """
//"""
//        return _pythia8.JetMatchingMadgraph_canVetoStep(self)
//
//    def doVetoStep(self, arg2, arg3, arg4, arg5):
//        """
//"""
//        return _pythia8.JetMatchingMadgraph_doVetoStep(self, arg2, arg3, arg4, arg5)
//    __swig_setmethods__["slowJetDJR"] = _pythia8.JetMatchingMadgraph_slowJetDJR_set
//    __swig_getmethods__["slowJetDJR"] = _pythia8.JetMatchingMadgraph_slowJetDJR_get
//    if _newclass:
//        slowJetDJR = _swig_property(_pythia8.JetMatchingMadgraph_slowJetDJR_get, _pythia8.JetMatchingMadgraph_slowJetDJR_set)
//
//    def getDJR(self):
//        """
//Jet algorithm to access the jet separations in the cleaned event
//after showering.
//Functions to return the jet clustering scales and number of ME partons.
//These are useful to investigate the matching systematics.
//"""
//        return _pythia8.JetMatchingMadgraph_getDJR(self)
//
//    def nMEpartons(self):
//        """
//"""
//        return _pythia8.JetMatchingMadgraph_nMEpartons(self)
//
//    def getWorkEventJet(self):
//        """
//For systematic variations of the jet matching parameters, it is helpful
//to decouple the jet matching veto from the internal book-keeping. The
//veto can then be applied in hindsight by an expert user. The functions
//below return all the necessary information to do this.
//"""
//        return _pythia8.JetMatchingMadgraph_getWorkEventJet(self)
//
//    def getProcessSubset(self):
//        """
//"""
//        return _pythia8.JetMatchingMadgraph_getProcessSubset(self)
//
//    def getExclusive(self):
//        """
//"""
//        return _pythia8.JetMatchingMadgraph_getExclusive(self)
//
//    def getPTfirst(self):
//        """
//"""
//        return _pythia8.JetMatchingMadgraph_getPTfirst(self)
//JetMatchingMadgraph_swigregister = _pythia8.JetMatchingMadgraph_swigregister
//JetMatchingMadgraph_swigregister(JetMatchingMadgraph)
//
//class LHAupHelaconia(LHAup):
//    """
//Save beam energies to calculate x values.
//"""
//    __swig_setmethods__ = {}
//    for _s in [LHAup]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, LHAupHelaconia, name, value)
//    __swig_getmethods__ = {}
//    for _s in [LHAup]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, LHAupHelaconia, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor.
//"""
//        this = _pythia8.new_LHAupHelaconia(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_LHAupHelaconia
//    __del__ = lambda self: None
//
//    def readString(self, line):
//        """
//Read a HelacOnia command string.
//"""
//        return _pythia8.LHAupHelaconia_readString(self, line)
//
//    def setEvents(self, eventsIn):
//        """
//Set the number of events to generate per run.
//"""
//        return _pythia8.LHAupHelaconia_setEvents(self, eventsIn)
//
//    def setSeed(self, seedIn, runsIn=30081):
//        """
//Set the random seed and maximum runs.
//"""
//        return _pythia8.LHAupHelaconia_setSeed(self, seedIn, runsIn)
//
//    def setInit(self):
//        """
//Set the initialization information.
//"""
//        return _pythia8.LHAupHelaconia_setInit(self)
//
//    def setEvent(self, arg2=0):
//        """
//Set the event information.
//"""
//        return _pythia8.LHAupHelaconia_setEvent(self, arg2)
//LHAupHelaconia_swigregister = _pythia8.LHAupHelaconia_swigregister
//LHAupHelaconia_swigregister(LHAupHelaconia)
//
//class LHAupMadgraph(LHAup):
//    """
//"""
//    __swig_setmethods__ = {}
//    for _s in [LHAup]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, LHAupMadgraph, name, value)
//    __swig_getmethods__ = {}
//    for _s in [LHAup]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, LHAupMadgraph, name)
//    __repr__ = _swig_repr
//    Auto = _pythia8.LHAupMadgraph_Auto
//    Configure = _pythia8.LHAupMadgraph_Configure
//    Generate = _pythia8.LHAupMadgraph_Generate
//    Launch = _pythia8.LHAupMadgraph_Launch
//
//    def __init__(self, *args):
//        """
//Types of MadGraph stages.
//Constructor.
//"""
//        this = _pythia8.new_LHAupMadgraph(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_LHAupMadgraph
//    __del__ = lambda self: None
//
//    def readString(self, *args):
//        """
//Read a MadGraph command string.
//"""
//        return _pythia8.LHAupMadgraph_readString(self, *args)
//
//    def addCard(self, src, dst):
//        """
//Add a MadGraph configuration card to be used.
//"""
//        return _pythia8.LHAupMadgraph_addCard(self, src, dst)
//
//    def setEvents(self, eventsIn):
//        """
//Set the number of events to generate per run.
//"""
//        return _pythia8.LHAupMadgraph_setEvents(self, eventsIn)
//
//    def setSeed(self, seedIn, runsIn=30081):
//        """
//Set the random seed and maximum runs.
//"""
//        return _pythia8.LHAupMadgraph_setSeed(self, seedIn, runsIn)
//
//    def setJets(self, jetsIn):
//        """
//Set the maximum number of jets produced by MadGraph.
//"""
//        return _pythia8.LHAupMadgraph_setJets(self, jetsIn)
//
//    def setInit(self):
//        """
//Set the initialization information.
//"""
//        return _pythia8.LHAupMadgraph_setInit(self)
//
//    def setEvent(self, arg2=0):
//        """
//Set the event information.
//"""
//        return _pythia8.LHAupMadgraph_setEvent(self, arg2)
//LHAupMadgraph_swigregister = _pythia8.LHAupMadgraph_swigregister
//LHAupMadgraph_swigregister(LHAupMadgraph)
//
//class PowhegHooks(UserHooks):
//    """
//Internal MixMax randum number generator.
//Use userhooks to veto PYTHIA emissions above the POWHEG scale.
//"""
//    __swig_setmethods__ = {}
//    for _s in [UserHooks]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, PowhegHooks, name, value)
//    __swig_getmethods__ = {}
//    for _s in [UserHooks]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, PowhegHooks, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor and destructor.
//"""
//        this = _pythia8.new_PowhegHooks()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_PowhegHooks
//    __del__ = lambda self: None
//
//    def initAfterBeams(self):
//        """
//Initialize settings, detailing merging strategy to use.
//"""
//        return _pythia8.PowhegHooks_initAfterBeams(self)
//
//    def pTpythia(self, e, RadAfterBranch, EmtAfterBranch, RecAfterBranch, FSR):
//        """
//"""
//        return _pythia8.PowhegHooks_pTpythia(self, e, RadAfterBranch, EmtAfterBranch, RecAfterBranch, FSR)
//
//    def pTpowheg(self, e, i, j, FSR):
//        """
//"""
//        return _pythia8.PowhegHooks_pTpowheg(self, e, i, j, FSR)
//
//    def pTcalc(self, e, i, j, k, r, xSRin):
//        """
//"""
//        return _pythia8.PowhegHooks_pTcalc(self, e, i, j, k, r, xSRin)
//
//    def canVetoMPIStep(self):
//        """
//for (rNow)
//for (kNow)
//if (!FSR)
//if (pTdefMode)
//for (j)
//for (xSR)
//Extraction of pThard based on the incoming event.
//Assume that all the final-state particles are in a continuous block
//at the end of the event and the final entry is the POWHEG emission.
//If there is no POWHEG emission, then pThard is set to SCALUP.
//"""
//        return _pythia8.PowhegHooks_canVetoMPIStep(self)
//
//    def numberVetoMPIStep(self):
//        """
//"""
//        return _pythia8.PowhegHooks_numberVetoMPIStep(self)
//
//    def doVetoMPIStep(self, nMPI, e):
//        """
//"""
//        return _pythia8.PowhegHooks_doVetoMPIStep(self, nMPI, e)
//
//    def canVetoISREmission(self):
//        """
//Initialise other variables
//Do not veto the event
//ISR veto
//"""
//        return _pythia8.PowhegHooks_canVetoISREmission(self)
//
//    def doVetoISREmission(self, arg2, e, iSys):
//        """
//"""
//        return _pythia8.PowhegHooks_doVetoISREmission(self, arg2, e, iSys)
//
//    def canVetoFSREmission(self):
//        """
//Don't veto ANY emissions afterwards
//Else mark that an emission has been accepted and continue
//FSR veto
//"""
//        return _pythia8.PowhegHooks_canVetoFSREmission(self)
//
//    def doVetoFSREmission(self, arg2, e, iSys, arg5):
//        """
//"""
//        return _pythia8.PowhegHooks_doVetoFSREmission(self, arg2, e, iSys, arg5)
//
//    def canVetoMPIEmission(self):
//        """
//Don't veto ANY emissions afterwards
//Else mark that an emission has been accepted and continue
//MPI veto
//"""
//        return _pythia8.PowhegHooks_canVetoMPIEmission(self)
//
//    def doVetoMPIEmission(self, arg2, e):
//        """
//"""
//        return _pythia8.PowhegHooks_doVetoMPIEmission(self, arg2, e)
//
//    def getNISRveto(self):
//        """
//Functions to return information
//"""
//        return _pythia8.PowhegHooks_getNISRveto(self)
//
//    def getNFSRveto(self):
//        """
//"""
//        return _pythia8.PowhegHooks_getNFSRveto(self)
//PowhegHooks_swigregister = _pythia8.PowhegHooks_swigregister
//PowhegHooks_swigregister(PowhegHooks)
//
//class PowhegProcs(_object):
//    """
//A class to generate events with hard processes from POWHEGBOX
//matrix elements. See http://powhegbox.mib.infn.it/ for further
//details on POWHEGBOX.
//WARNING: If one wishes to use LHAPDF with both POWHEGBOX and
//Pythia, only LHAPDF 6 configured with the option
//"--with-lhapdf6-plugin=LHAPDF6.h" for Pythia should be used. If
//not, and differing PDF sets are used between POWHEGBOX and Pythia,
//POWHEGBOX will not re-initialize the PDF set and consequently will
//use the PDF set last used by Pythia.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, PowhegProcs, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, PowhegProcs, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, *args):
//        """
//Constructor.
//"""
//        this = _pythia8.new_PowhegProcs(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_PowhegProcs
//    __del__ = lambda self: None
//
//    def readString(self, line):
//        """
//Read a POWHEG settings string.
//"""
//        return _pythia8.PowhegProcs_readString(self, line)
//
//    def readFile(self, name):
//        """
//Read a POWHEG settings file.
//"""
//        return _pythia8.PowhegProcs_readFile(self, name)
//
//    def init(self):
//        """
//Write out the input for POWHEG.
//"""
//        return _pythia8.PowhegProcs_init(self)
//    __swig_setmethods__["lhaup"] = _pythia8.PowhegProcs_lhaup_set
//    __swig_getmethods__["lhaup"] = _pythia8.PowhegProcs_lhaup_get
//    if _newclass:
//        lhaup = _swig_property(_pythia8.PowhegProcs_lhaup_get, _pythia8.PowhegProcs_lhaup_set)
//PowhegProcs_swigregister = _pythia8.PowhegProcs_swigregister
//PowhegProcs_swigregister(PowhegProcs)
//
//class HeavyIons(_object):
//    """
//HeavyIons contains several standard Pythia objects to allow for
//the combination of different kinds of nucleon-nucleon events into
//a heavy ion collision event. The actual model for doing this must
//be implemented in a subclass overriding the the virtual'init()'
//and 'next()' functions.
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, HeavyIons, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, HeavyIons, name)
//
//    def __init__(self, *args, **kwargs):
//        """
//The constructor needs a reference to the main Pythia object to
//which it will belong. A HeavyIons object cannot belong to more
//than one main Pythia object.
//"""
//        raise AttributeError("No constructor defined - class is abstract")
//    __repr__ = _swig_repr
//    __swig_destroy__ = _pythia8.delete_HeavyIons
//    __del__ = lambda self: None
//
//    def init(self):
//        """
//Virtual function to be implemented in a subclass. This will be
//called in the beginning of the Pythia::init function if the mode
//HeavyIon:mode is set non zero. The return value should be true
//if this object is able to handle the requested collision
//type. If false Pythia::init will set HeavyIon:mode to zero but
//will try to cope anyway.
//"""
//        return _pythia8.HeavyIons_init(self)
//
//    def next(self):
//        """
//Virtual function to be implemented in a subclass. This will be
//called in the beginning of the Pythia::next function if
//HeavyIon:mode is set non zero. After the call, Pythia::next will
//return immediately with the return value of this function.
//"""
//        return _pythia8.HeavyIons_next(self)
//    __swig_getmethods__["addSpecialSettings"] = lambda x: _pythia8.HeavyIons_addSpecialSettings
//    if _newclass:
//        addSpecialSettings = staticmethod(_pythia8.HeavyIons_addSpecialSettings)
//    __swig_getmethods__["isHeavyIon"] = lambda x: _pythia8.HeavyIons_isHeavyIon
//    if _newclass:
//        isHeavyIon = staticmethod(_pythia8.HeavyIons_isHeavyIon)
//
//    def setHIUserHooksPtr(self, userHooksPtrIn):
//        """
//Possibility to pass in pointer for special heavy ion user hooks.
//"""
//        return _pythia8.HeavyIons_setHIUserHooksPtr(self, userHooksPtrIn)
//    __swig_setmethods__["hiinfo"] = _pythia8.HeavyIons_hiinfo_set
//    __swig_getmethods__["hiinfo"] = _pythia8.HeavyIons_hiinfo_get
//    if _newclass:
//        hiinfo = _swig_property(_pythia8.HeavyIons_hiinfo_get, _pythia8.HeavyIons_hiinfo_set)
//
//    def stat(self):
//        """
//This is the pointer to the main Pythia object to which this
//object is assigned.
//Object containing information on inclusive pp cross sections to
//be used in Glauber calculations in subclasses.
//Optional HIUserHooks object able to modify the behavior of the
//HeavyIon model.
//The internal Pythia objects. Index zero will always correspond
//to the mainPythiaPtr.
//The names associated with the secondary pythia objects.
//This is the HIInfo object containing information about the last
//generated heavy ion event and som statistics of all such events
//generated since the last call to init();
//Print out statistics.
//"""
//        return _pythia8.HeavyIons_stat(self)
//HeavyIons_swigregister = _pythia8.HeavyIons_swigregister
//HeavyIons_swigregister(HeavyIons)
//
//def HeavyIons_addSpecialSettings(settings):
//    return _pythia8.HeavyIons_addSpecialSettings(settings)
//HeavyIons_addSpecialSettings = _pythia8.HeavyIons_addSpecialSettings
//
//def HeavyIons_isHeavyIon(settings):
//    return _pythia8.HeavyIons_isHeavyIon(settings)
//HeavyIons_isHeavyIon = _pythia8.HeavyIons_isHeavyIon
//
//class Angantyr(HeavyIons):
//    __swig_setmethods__ = {}
//    for _s in [HeavyIons]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, Angantyr, name, value)
//    __swig_getmethods__ = {}
//    for _s in [HeavyIons]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, Angantyr, name)
//    __repr__ = _swig_repr
//    HADRON = _pythia8.Angantyr_HADRON
//    MBIAS = _pythia8.Angantyr_MBIAS
//    SASD = _pythia8.Angantyr_SASD
//    SIGPP = _pythia8.Angantyr_SIGPP
//    SIGPN = _pythia8.Angantyr_SIGPN
//    SIGNP = _pythia8.Angantyr_SIGNP
//    SIGNN = _pythia8.Angantyr_SIGNN
//    ALL = _pythia8.Angantyr_ALL
//
//    def __init__(self, mainPythiaIn):
//        this = _pythia8.new_Angantyr(mainPythiaIn)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_Angantyr
//    __del__ = lambda self: None
//
//    def init(self):
//        return _pythia8.Angantyr_init(self)
//
//    def next(self):
//        return _pythia8.Angantyr_next(self)
//
//    def setUserHooksPtr(self, sel, userHooksPtrIn):
//        return _pythia8.Angantyr_setUserHooksPtr(self, sel, userHooksPtrIn)
//    __swig_getmethods__["getTransforms"] = lambda x: _pythia8.Angantyr_getTransforms
//    if _newclass:
//        getTransforms = staticmethod(_pythia8.Angantyr_getTransforms)
//    __swig_getmethods__["mT2"] = lambda x: _pythia8.Angantyr_mT2
//    if _newclass:
//        mT2 = staticmethod(_pythia8.Angantyr_mT2)
//    __swig_getmethods__["mT"] = lambda x: _pythia8.Angantyr_mT
//    if _newclass:
//        mT = staticmethod(_pythia8.Angantyr_mT)
//Angantyr_swigregister = _pythia8.Angantyr_swigregister
//Angantyr_swigregister(Angantyr)
//
//def Angantyr_getTransforms(p1, p2, p1p, R12, arg6, arg7):
//    return _pythia8.Angantyr_getTransforms(p1, p2, p1p, R12, arg6, arg7)
//Angantyr_getTransforms = _pythia8.Angantyr_getTransforms
//
//def Angantyr_mT2(p):
//    return _pythia8.Angantyr_mT2(p)
//Angantyr_mT2 = _pythia8.Angantyr_mT2
//
//def Angantyr_mT(p):
//    return _pythia8.Angantyr_mT(p)
//Angantyr_mT = _pythia8.Angantyr_mT
//
//class JetMatchingAlpgenInputAlpgen(AlpgenHooks, JetMatchingAlpgen):
//    __swig_setmethods__ = {}
//    for _s in [AlpgenHooks, JetMatchingAlpgen]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, JetMatchingAlpgenInputAlpgen, name, value)
//    __swig_getmethods__ = {}
//    for _s in [AlpgenHooks, JetMatchingAlpgen]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, JetMatchingAlpgenInputAlpgen, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, pythia):
//        this = _pythia8.new_JetMatchingAlpgenInputAlpgen(pythia)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_JetMatchingAlpgenInputAlpgen
//    __del__ = lambda self: None
//
//    def initAfterBeams(self):
//        return _pythia8.JetMatchingAlpgenInputAlpgen_initAfterBeams(self)
//
//    def canVetoProcessLevel(self):
//        return _pythia8.JetMatchingAlpgenInputAlpgen_canVetoProcessLevel(self)
//
//    def doVetoProcessLevel(self, proc):
//        return _pythia8.JetMatchingAlpgenInputAlpgen_doVetoProcessLevel(self, proc)
//
//    def canVetoPartonLevelEarly(self):
//        return _pythia8.JetMatchingAlpgenInputAlpgen_canVetoPartonLevelEarly(self)
//
//    def doVetoPartonLevelEarly(self, proc):
//        return _pythia8.JetMatchingAlpgenInputAlpgen_doVetoPartonLevelEarly(self, proc)
//JetMatchingAlpgenInputAlpgen_swigregister = _pythia8.JetMatchingAlpgenInputAlpgen_swigregister
//JetMatchingAlpgenInputAlpgen_swigregister(JetMatchingAlpgenInputAlpgen)
//
//class JetMatchingMadgraphInputAlpgen(AlpgenHooks, JetMatchingMadgraph):
//    __swig_setmethods__ = {}
//    for _s in [AlpgenHooks, JetMatchingMadgraph]:
//        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
//    __setattr__ = lambda self, name, value: _swig_setattr(self, JetMatchingMadgraphInputAlpgen, name, value)
//    __swig_getmethods__ = {}
//    for _s in [AlpgenHooks, JetMatchingMadgraph]:
//        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
//    __getattr__ = lambda self, name: _swig_getattr(self, JetMatchingMadgraphInputAlpgen, name)
//    __repr__ = _swig_repr
//
//    def __init__(self, pythia):
//        this = _pythia8.new_JetMatchingMadgraphInputAlpgen(pythia)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_JetMatchingMadgraphInputAlpgen
//    __del__ = lambda self: None
//
//    def initAfterBeams(self):
//        return _pythia8.JetMatchingMadgraphInputAlpgen_initAfterBeams(self)
//
//    def canVetoProcessLevel(self):
//        return _pythia8.JetMatchingMadgraphInputAlpgen_canVetoProcessLevel(self)
//
//    def doVetoProcessLevel(self, proc):
//        return _pythia8.JetMatchingMadgraphInputAlpgen_doVetoProcessLevel(self, proc)
//
//    def canVetoPartonLevelEarly(self):
//        return _pythia8.JetMatchingMadgraphInputAlpgen_canVetoPartonLevelEarly(self)
//
//    def doVetoPartonLevelEarly(self, proc):
//        return _pythia8.JetMatchingMadgraphInputAlpgen_doVetoPartonLevelEarly(self, proc)
//JetMatchingMadgraphInputAlpgen_swigregister = _pythia8.JetMatchingMadgraphInputAlpgen_swigregister
//JetMatchingMadgraphInputAlpgen_swigregister(JetMatchingMadgraphInputAlpgen)
//
//class CombineMatchingInput(_object):
//    """
//"""
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, CombineMatchingInput, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, CombineMatchingInput, name)
//    __repr__ = _swig_repr
//
//    def __init__(self):
//        """
//Constructor and destructor.
//"""
//        this = _pythia8.new_CombineMatchingInput()
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//    __swig_destroy__ = _pythia8.delete_CombineMatchingInput
//    __del__ = lambda self: None
//
//    def getHook(self, pythia):
//        """
//Return a hook relevant for combination of input and matching.
//"""
//        return _pythia8.CombineMatchingInput_getHook(self, pythia)
//CombineMatchingInput_swigregister = _pythia8.CombineMatchingInput_swigregister
//CombineMatchingInput_swigregister(CombineMatchingInput)
//
//class MapStringFlag(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, MapStringFlag, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, MapStringFlag, name)
//    __repr__ = _swig_repr
//
//    def iterator(self):
//        return _pythia8.MapStringFlag_iterator(self)
//    def __iter__(self):
//        return self.iterator()
//
//    def __nonzero__(self):
//        return _pythia8.MapStringFlag___nonzero__(self)
//
//    def __bool__(self):
//        return _pythia8.MapStringFlag___bool__(self)
//
//    def __len__(self):
//        return _pythia8.MapStringFlag___len__(self)
//    def __iter__(self):
//        return self.key_iterator()
//    def iterkeys(self):
//        return self.key_iterator()
//    def itervalues(self):
//        return self.value_iterator()
//    def iteritems(self):
//        return self.iterator()
//
//    def __getitem__(self, key):
//        return _pythia8.MapStringFlag___getitem__(self, key)
//
//    def __delitem__(self, key):
//        return _pythia8.MapStringFlag___delitem__(self, key)
//
//    def has_key(self, key):
//        return _pythia8.MapStringFlag_has_key(self, key)
//
//    def keys(self):
//        return _pythia8.MapStringFlag_keys(self)
//
//    def values(self):
//        return _pythia8.MapStringFlag_values(self)
//
//    def items(self):
//        return _pythia8.MapStringFlag_items(self)
//
//    def __contains__(self, key):
//        return _pythia8.MapStringFlag___contains__(self, key)
//
//    def key_iterator(self):
//        return _pythia8.MapStringFlag_key_iterator(self)
//
//    def value_iterator(self):
//        return _pythia8.MapStringFlag_value_iterator(self)
//
//    def __setitem__(self, *args):
//        return _pythia8.MapStringFlag___setitem__(self, *args)
//
//    def asdict(self):
//        return _pythia8.MapStringFlag_asdict(self)
//
//    def __init__(self, *args):
//        this = _pythia8.new_MapStringFlag(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def empty(self):
//        return _pythia8.MapStringFlag_empty(self)
//
//    def size(self):
//        return _pythia8.MapStringFlag_size(self)
//
//    def swap(self, v):
//        return _pythia8.MapStringFlag_swap(self, v)
//
//    def begin(self):
//        return _pythia8.MapStringFlag_begin(self)
//
//    def end(self):
//        return _pythia8.MapStringFlag_end(self)
//
//    def rbegin(self):
//        return _pythia8.MapStringFlag_rbegin(self)
//
//    def rend(self):
//        return _pythia8.MapStringFlag_rend(self)
//
//    def clear(self):
//        return _pythia8.MapStringFlag_clear(self)
//
//    def get_allocator(self):
//        return _pythia8.MapStringFlag_get_allocator(self)
//
//    def count(self, x):
//        return _pythia8.MapStringFlag_count(self, x)
//
//    def erase(self, *args):
//        return _pythia8.MapStringFlag_erase(self, *args)
//
//    def find(self, x):
//        return _pythia8.MapStringFlag_find(self, x)
//
//    def lower_bound(self, x):
//        return _pythia8.MapStringFlag_lower_bound(self, x)
//
//    def upper_bound(self, x):
//        return _pythia8.MapStringFlag_upper_bound(self, x)
//    __swig_destroy__ = _pythia8.delete_MapStringFlag
//    __del__ = lambda self: None
//MapStringFlag_swigregister = _pythia8.MapStringFlag_swigregister
//MapStringFlag_swigregister(MapStringFlag)
//
//class MapStringMode(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, MapStringMode, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, MapStringMode, name)
//    __repr__ = _swig_repr
//
//    def iterator(self):
//        return _pythia8.MapStringMode_iterator(self)
//    def __iter__(self):
//        return self.iterator()
//
//    def __nonzero__(self):
//        return _pythia8.MapStringMode___nonzero__(self)
//
//    def __bool__(self):
//        return _pythia8.MapStringMode___bool__(self)
//
//    def __len__(self):
//        return _pythia8.MapStringMode___len__(self)
//    def __iter__(self):
//        return self.key_iterator()
//    def iterkeys(self):
//        return self.key_iterator()
//    def itervalues(self):
//        return self.value_iterator()
//    def iteritems(self):
//        return self.iterator()
//
//    def __getitem__(self, key):
//        return _pythia8.MapStringMode___getitem__(self, key)
//
//    def __delitem__(self, key):
//        return _pythia8.MapStringMode___delitem__(self, key)
//
//    def has_key(self, key):
//        return _pythia8.MapStringMode_has_key(self, key)
//
//    def keys(self):
//        return _pythia8.MapStringMode_keys(self)
//
//    def values(self):
//        return _pythia8.MapStringMode_values(self)
//
//    def items(self):
//        return _pythia8.MapStringMode_items(self)
//
//    def __contains__(self, key):
//        return _pythia8.MapStringMode___contains__(self, key)
//
//    def key_iterator(self):
//        return _pythia8.MapStringMode_key_iterator(self)
//
//    def value_iterator(self):
//        return _pythia8.MapStringMode_value_iterator(self)
//
//    def __setitem__(self, *args):
//        return _pythia8.MapStringMode___setitem__(self, *args)
//
//    def asdict(self):
//        return _pythia8.MapStringMode_asdict(self)
//
//    def __init__(self, *args):
//        this = _pythia8.new_MapStringMode(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def empty(self):
//        return _pythia8.MapStringMode_empty(self)
//
//    def size(self):
//        return _pythia8.MapStringMode_size(self)
//
//    def swap(self, v):
//        return _pythia8.MapStringMode_swap(self, v)
//
//    def begin(self):
//        return _pythia8.MapStringMode_begin(self)
//
//    def end(self):
//        return _pythia8.MapStringMode_end(self)
//
//    def rbegin(self):
//        return _pythia8.MapStringMode_rbegin(self)
//
//    def rend(self):
//        return _pythia8.MapStringMode_rend(self)
//
//    def clear(self):
//        return _pythia8.MapStringMode_clear(self)
//
//    def get_allocator(self):
//        return _pythia8.MapStringMode_get_allocator(self)
//
//    def count(self, x):
//        return _pythia8.MapStringMode_count(self, x)
//
//    def erase(self, *args):
//        return _pythia8.MapStringMode_erase(self, *args)
//
//    def find(self, x):
//        return _pythia8.MapStringMode_find(self, x)
//
//    def lower_bound(self, x):
//        return _pythia8.MapStringMode_lower_bound(self, x)
//
//    def upper_bound(self, x):
//        return _pythia8.MapStringMode_upper_bound(self, x)
//    __swig_destroy__ = _pythia8.delete_MapStringMode
//    __del__ = lambda self: None
//MapStringMode_swigregister = _pythia8.MapStringMode_swigregister
//MapStringMode_swigregister(MapStringMode)
//
//class MapStringParm(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, MapStringParm, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, MapStringParm, name)
//    __repr__ = _swig_repr
//
//    def iterator(self):
//        return _pythia8.MapStringParm_iterator(self)
//    def __iter__(self):
//        return self.iterator()
//
//    def __nonzero__(self):
//        return _pythia8.MapStringParm___nonzero__(self)
//
//    def __bool__(self):
//        return _pythia8.MapStringParm___bool__(self)
//
//    def __len__(self):
//        return _pythia8.MapStringParm___len__(self)
//    def __iter__(self):
//        return self.key_iterator()
//    def iterkeys(self):
//        return self.key_iterator()
//    def itervalues(self):
//        return self.value_iterator()
//    def iteritems(self):
//        return self.iterator()
//
//    def __getitem__(self, key):
//        return _pythia8.MapStringParm___getitem__(self, key)
//
//    def __delitem__(self, key):
//        return _pythia8.MapStringParm___delitem__(self, key)
//
//    def has_key(self, key):
//        return _pythia8.MapStringParm_has_key(self, key)
//
//    def keys(self):
//        return _pythia8.MapStringParm_keys(self)
//
//    def values(self):
//        return _pythia8.MapStringParm_values(self)
//
//    def items(self):
//        return _pythia8.MapStringParm_items(self)
//
//    def __contains__(self, key):
//        return _pythia8.MapStringParm___contains__(self, key)
//
//    def key_iterator(self):
//        return _pythia8.MapStringParm_key_iterator(self)
//
//    def value_iterator(self):
//        return _pythia8.MapStringParm_value_iterator(self)
//
//    def __setitem__(self, *args):
//        return _pythia8.MapStringParm___setitem__(self, *args)
//
//    def asdict(self):
//        return _pythia8.MapStringParm_asdict(self)
//
//    def __init__(self, *args):
//        this = _pythia8.new_MapStringParm(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def empty(self):
//        return _pythia8.MapStringParm_empty(self)
//
//    def size(self):
//        return _pythia8.MapStringParm_size(self)
//
//    def swap(self, v):
//        return _pythia8.MapStringParm_swap(self, v)
//
//    def begin(self):
//        return _pythia8.MapStringParm_begin(self)
//
//    def end(self):
//        return _pythia8.MapStringParm_end(self)
//
//    def rbegin(self):
//        return _pythia8.MapStringParm_rbegin(self)
//
//    def rend(self):
//        return _pythia8.MapStringParm_rend(self)
//
//    def clear(self):
//        return _pythia8.MapStringParm_clear(self)
//
//    def get_allocator(self):
//        return _pythia8.MapStringParm_get_allocator(self)
//
//    def count(self, x):
//        return _pythia8.MapStringParm_count(self, x)
//
//    def erase(self, *args):
//        return _pythia8.MapStringParm_erase(self, *args)
//
//    def find(self, x):
//        return _pythia8.MapStringParm_find(self, x)
//
//    def lower_bound(self, x):
//        return _pythia8.MapStringParm_lower_bound(self, x)
//
//    def upper_bound(self, x):
//        return _pythia8.MapStringParm_upper_bound(self, x)
//    __swig_destroy__ = _pythia8.delete_MapStringParm
//    __del__ = lambda self: None
//MapStringParm_swigregister = _pythia8.MapStringParm_swigregister
//MapStringParm_swigregister(MapStringParm)
//
//class MapStringWord(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, MapStringWord, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, MapStringWord, name)
//    __repr__ = _swig_repr
//
//    def iterator(self):
//        return _pythia8.MapStringWord_iterator(self)
//    def __iter__(self):
//        return self.iterator()
//
//    def __nonzero__(self):
//        return _pythia8.MapStringWord___nonzero__(self)
//
//    def __bool__(self):
//        return _pythia8.MapStringWord___bool__(self)
//
//    def __len__(self):
//        return _pythia8.MapStringWord___len__(self)
//    def __iter__(self):
//        return self.key_iterator()
//    def iterkeys(self):
//        return self.key_iterator()
//    def itervalues(self):
//        return self.value_iterator()
//    def iteritems(self):
//        return self.iterator()
//
//    def __getitem__(self, key):
//        return _pythia8.MapStringWord___getitem__(self, key)
//
//    def __delitem__(self, key):
//        return _pythia8.MapStringWord___delitem__(self, key)
//
//    def has_key(self, key):
//        return _pythia8.MapStringWord_has_key(self, key)
//
//    def keys(self):
//        return _pythia8.MapStringWord_keys(self)
//
//    def values(self):
//        return _pythia8.MapStringWord_values(self)
//
//    def items(self):
//        return _pythia8.MapStringWord_items(self)
//
//    def __contains__(self, key):
//        return _pythia8.MapStringWord___contains__(self, key)
//
//    def key_iterator(self):
//        return _pythia8.MapStringWord_key_iterator(self)
//
//    def value_iterator(self):
//        return _pythia8.MapStringWord_value_iterator(self)
//
//    def __setitem__(self, *args):
//        return _pythia8.MapStringWord___setitem__(self, *args)
//
//    def asdict(self):
//        return _pythia8.MapStringWord_asdict(self)
//
//    def __init__(self, *args):
//        this = _pythia8.new_MapStringWord(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def empty(self):
//        return _pythia8.MapStringWord_empty(self)
//
//    def size(self):
//        return _pythia8.MapStringWord_size(self)
//
//    def swap(self, v):
//        return _pythia8.MapStringWord_swap(self, v)
//
//    def begin(self):
//        return _pythia8.MapStringWord_begin(self)
//
//    def end(self):
//        return _pythia8.MapStringWord_end(self)
//
//    def rbegin(self):
//        return _pythia8.MapStringWord_rbegin(self)
//
//    def rend(self):
//        return _pythia8.MapStringWord_rend(self)
//
//    def clear(self):
//        return _pythia8.MapStringWord_clear(self)
//
//    def get_allocator(self):
//        return _pythia8.MapStringWord_get_allocator(self)
//
//    def count(self, x):
//        return _pythia8.MapStringWord_count(self, x)
//
//    def erase(self, *args):
//        return _pythia8.MapStringWord_erase(self, *args)
//
//    def find(self, x):
//        return _pythia8.MapStringWord_find(self, x)
//
//    def lower_bound(self, x):
//        return _pythia8.MapStringWord_lower_bound(self, x)
//
//    def upper_bound(self, x):
//        return _pythia8.MapStringWord_upper_bound(self, x)
//    __swig_destroy__ = _pythia8.delete_MapStringWord
//    __del__ = lambda self: None
//MapStringWord_swigregister = _pythia8.MapStringWord_swigregister
//MapStringWord_swigregister(MapStringWord)
//
//class MapStringFVec(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, MapStringFVec, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, MapStringFVec, name)
//    __repr__ = _swig_repr
//
//    def iterator(self):
//        return _pythia8.MapStringFVec_iterator(self)
//    def __iter__(self):
//        return self.iterator()
//
//    def __nonzero__(self):
//        return _pythia8.MapStringFVec___nonzero__(self)
//
//    def __bool__(self):
//        return _pythia8.MapStringFVec___bool__(self)
//
//    def __len__(self):
//        return _pythia8.MapStringFVec___len__(self)
//    def __iter__(self):
//        return self.key_iterator()
//    def iterkeys(self):
//        return self.key_iterator()
//    def itervalues(self):
//        return self.value_iterator()
//    def iteritems(self):
//        return self.iterator()
//
//    def __getitem__(self, key):
//        return _pythia8.MapStringFVec___getitem__(self, key)
//
//    def __delitem__(self, key):
//        return _pythia8.MapStringFVec___delitem__(self, key)
//
//    def has_key(self, key):
//        return _pythia8.MapStringFVec_has_key(self, key)
//
//    def keys(self):
//        return _pythia8.MapStringFVec_keys(self)
//
//    def values(self):
//        return _pythia8.MapStringFVec_values(self)
//
//    def items(self):
//        return _pythia8.MapStringFVec_items(self)
//
//    def __contains__(self, key):
//        return _pythia8.MapStringFVec___contains__(self, key)
//
//    def key_iterator(self):
//        return _pythia8.MapStringFVec_key_iterator(self)
//
//    def value_iterator(self):
//        return _pythia8.MapStringFVec_value_iterator(self)
//
//    def __setitem__(self, *args):
//        return _pythia8.MapStringFVec___setitem__(self, *args)
//
//    def asdict(self):
//        return _pythia8.MapStringFVec_asdict(self)
//
//    def __init__(self, *args):
//        this = _pythia8.new_MapStringFVec(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def empty(self):
//        return _pythia8.MapStringFVec_empty(self)
//
//    def size(self):
//        return _pythia8.MapStringFVec_size(self)
//
//    def swap(self, v):
//        return _pythia8.MapStringFVec_swap(self, v)
//
//    def begin(self):
//        return _pythia8.MapStringFVec_begin(self)
//
//    def end(self):
//        return _pythia8.MapStringFVec_end(self)
//
//    def rbegin(self):
//        return _pythia8.MapStringFVec_rbegin(self)
//
//    def rend(self):
//        return _pythia8.MapStringFVec_rend(self)
//
//    def clear(self):
//        return _pythia8.MapStringFVec_clear(self)
//
//    def get_allocator(self):
//        return _pythia8.MapStringFVec_get_allocator(self)
//
//    def count(self, x):
//        return _pythia8.MapStringFVec_count(self, x)
//
//    def erase(self, *args):
//        return _pythia8.MapStringFVec_erase(self, *args)
//
//    def find(self, x):
//        return _pythia8.MapStringFVec_find(self, x)
//
//    def lower_bound(self, x):
//        return _pythia8.MapStringFVec_lower_bound(self, x)
//
//    def upper_bound(self, x):
//        return _pythia8.MapStringFVec_upper_bound(self, x)
//    __swig_destroy__ = _pythia8.delete_MapStringFVec
//    __del__ = lambda self: None
//MapStringFVec_swigregister = _pythia8.MapStringFVec_swigregister
//MapStringFVec_swigregister(MapStringFVec)
//
//class MapStringMVec(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, MapStringMVec, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, MapStringMVec, name)
//    __repr__ = _swig_repr
//
//    def iterator(self):
//        return _pythia8.MapStringMVec_iterator(self)
//    def __iter__(self):
//        return self.iterator()
//
//    def __nonzero__(self):
//        return _pythia8.MapStringMVec___nonzero__(self)
//
//    def __bool__(self):
//        return _pythia8.MapStringMVec___bool__(self)
//
//    def __len__(self):
//        return _pythia8.MapStringMVec___len__(self)
//    def __iter__(self):
//        return self.key_iterator()
//    def iterkeys(self):
//        return self.key_iterator()
//    def itervalues(self):
//        return self.value_iterator()
//    def iteritems(self):
//        return self.iterator()
//
//    def __getitem__(self, key):
//        return _pythia8.MapStringMVec___getitem__(self, key)
//
//    def __delitem__(self, key):
//        return _pythia8.MapStringMVec___delitem__(self, key)
//
//    def has_key(self, key):
//        return _pythia8.MapStringMVec_has_key(self, key)
//
//    def keys(self):
//        return _pythia8.MapStringMVec_keys(self)
//
//    def values(self):
//        return _pythia8.MapStringMVec_values(self)
//
//    def items(self):
//        return _pythia8.MapStringMVec_items(self)
//
//    def __contains__(self, key):
//        return _pythia8.MapStringMVec___contains__(self, key)
//
//    def key_iterator(self):
//        return _pythia8.MapStringMVec_key_iterator(self)
//
//    def value_iterator(self):
//        return _pythia8.MapStringMVec_value_iterator(self)
//
//    def __setitem__(self, *args):
//        return _pythia8.MapStringMVec___setitem__(self, *args)
//
//    def asdict(self):
//        return _pythia8.MapStringMVec_asdict(self)
//
//    def __init__(self, *args):
//        this = _pythia8.new_MapStringMVec(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def empty(self):
//        return _pythia8.MapStringMVec_empty(self)
//
//    def size(self):
//        return _pythia8.MapStringMVec_size(self)
//
//    def swap(self, v):
//        return _pythia8.MapStringMVec_swap(self, v)
//
//    def begin(self):
//        return _pythia8.MapStringMVec_begin(self)
//
//    def end(self):
//        return _pythia8.MapStringMVec_end(self)
//
//    def rbegin(self):
//        return _pythia8.MapStringMVec_rbegin(self)
//
//    def rend(self):
//        return _pythia8.MapStringMVec_rend(self)
//
//    def clear(self):
//        return _pythia8.MapStringMVec_clear(self)
//
//    def get_allocator(self):
//        return _pythia8.MapStringMVec_get_allocator(self)
//
//    def count(self, x):
//        return _pythia8.MapStringMVec_count(self, x)
//
//    def erase(self, *args):
//        return _pythia8.MapStringMVec_erase(self, *args)
//
//    def find(self, x):
//        return _pythia8.MapStringMVec_find(self, x)
//
//    def lower_bound(self, x):
//        return _pythia8.MapStringMVec_lower_bound(self, x)
//
//    def upper_bound(self, x):
//        return _pythia8.MapStringMVec_upper_bound(self, x)
//    __swig_destroy__ = _pythia8.delete_MapStringMVec
//    __del__ = lambda self: None
//MapStringMVec_swigregister = _pythia8.MapStringMVec_swigregister
//MapStringMVec_swigregister(MapStringMVec)
//
//class MapStringPVec(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, MapStringPVec, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, MapStringPVec, name)
//    __repr__ = _swig_repr
//
//    def iterator(self):
//        return _pythia8.MapStringPVec_iterator(self)
//    def __iter__(self):
//        return self.iterator()
//
//    def __nonzero__(self):
//        return _pythia8.MapStringPVec___nonzero__(self)
//
//    def __bool__(self):
//        return _pythia8.MapStringPVec___bool__(self)
//
//    def __len__(self):
//        return _pythia8.MapStringPVec___len__(self)
//    def __iter__(self):
//        return self.key_iterator()
//    def iterkeys(self):
//        return self.key_iterator()
//    def itervalues(self):
//        return self.value_iterator()
//    def iteritems(self):
//        return self.iterator()
//
//    def __getitem__(self, key):
//        return _pythia8.MapStringPVec___getitem__(self, key)
//
//    def __delitem__(self, key):
//        return _pythia8.MapStringPVec___delitem__(self, key)
//
//    def has_key(self, key):
//        return _pythia8.MapStringPVec_has_key(self, key)
//
//    def keys(self):
//        return _pythia8.MapStringPVec_keys(self)
//
//    def values(self):
//        return _pythia8.MapStringPVec_values(self)
//
//    def items(self):
//        return _pythia8.MapStringPVec_items(self)
//
//    def __contains__(self, key):
//        return _pythia8.MapStringPVec___contains__(self, key)
//
//    def key_iterator(self):
//        return _pythia8.MapStringPVec_key_iterator(self)
//
//    def value_iterator(self):
//        return _pythia8.MapStringPVec_value_iterator(self)
//
//    def __setitem__(self, *args):
//        return _pythia8.MapStringPVec___setitem__(self, *args)
//
//    def asdict(self):
//        return _pythia8.MapStringPVec_asdict(self)
//
//    def __init__(self, *args):
//        this = _pythia8.new_MapStringPVec(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def empty(self):
//        return _pythia8.MapStringPVec_empty(self)
//
//    def size(self):
//        return _pythia8.MapStringPVec_size(self)
//
//    def swap(self, v):
//        return _pythia8.MapStringPVec_swap(self, v)
//
//    def begin(self):
//        return _pythia8.MapStringPVec_begin(self)
//
//    def end(self):
//        return _pythia8.MapStringPVec_end(self)
//
//    def rbegin(self):
//        return _pythia8.MapStringPVec_rbegin(self)
//
//    def rend(self):
//        return _pythia8.MapStringPVec_rend(self)
//
//    def clear(self):
//        return _pythia8.MapStringPVec_clear(self)
//
//    def get_allocator(self):
//        return _pythia8.MapStringPVec_get_allocator(self)
//
//    def count(self, x):
//        return _pythia8.MapStringPVec_count(self, x)
//
//    def erase(self, *args):
//        return _pythia8.MapStringPVec_erase(self, *args)
//
//    def find(self, x):
//        return _pythia8.MapStringPVec_find(self, x)
//
//    def lower_bound(self, x):
//        return _pythia8.MapStringPVec_lower_bound(self, x)
//
//    def upper_bound(self, x):
//        return _pythia8.MapStringPVec_upper_bound(self, x)
//    __swig_destroy__ = _pythia8.delete_MapStringPVec
//    __del__ = lambda self: None
//MapStringPVec_swigregister = _pythia8.MapStringPVec_swigregister
//MapStringPVec_swigregister(MapStringPVec)
//
//class VectorClustering(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, VectorClustering, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, VectorClustering, name)
//    __repr__ = _swig_repr
//
//    def iterator(self):
//        return _pythia8.VectorClustering_iterator(self)
//    def __iter__(self):
//        return self.iterator()
//
//    def __nonzero__(self):
//        return _pythia8.VectorClustering___nonzero__(self)
//
//    def __bool__(self):
//        return _pythia8.VectorClustering___bool__(self)
//
//    def __len__(self):
//        return _pythia8.VectorClustering___len__(self)
//
//    def __getslice__(self, i, j):
//        return _pythia8.VectorClustering___getslice__(self, i, j)
//
//    def __setslice__(self, *args):
//        return _pythia8.VectorClustering___setslice__(self, *args)
//
//    def __delslice__(self, i, j):
//        return _pythia8.VectorClustering___delslice__(self, i, j)
//
//    def __delitem__(self, *args):
//        return _pythia8.VectorClustering___delitem__(self, *args)
//
//    def __getitem__(self, *args):
//        return _pythia8.VectorClustering___getitem__(self, *args)
//
//    def __setitem__(self, *args):
//        return _pythia8.VectorClustering___setitem__(self, *args)
//
//    def pop(self):
//        return _pythia8.VectorClustering_pop(self)
//
//    def append(self, x):
//        return _pythia8.VectorClustering_append(self, x)
//
//    def empty(self):
//        return _pythia8.VectorClustering_empty(self)
//
//    def size(self):
//        return _pythia8.VectorClustering_size(self)
//
//    def swap(self, v):
//        return _pythia8.VectorClustering_swap(self, v)
//
//    def begin(self):
//        return _pythia8.VectorClustering_begin(self)
//
//    def end(self):
//        return _pythia8.VectorClustering_end(self)
//
//    def rbegin(self):
//        return _pythia8.VectorClustering_rbegin(self)
//
//    def rend(self):
//        return _pythia8.VectorClustering_rend(self)
//
//    def clear(self):
//        return _pythia8.VectorClustering_clear(self)
//
//    def get_allocator(self):
//        return _pythia8.VectorClustering_get_allocator(self)
//
//    def pop_back(self):
//        return _pythia8.VectorClustering_pop_back(self)
//
//    def erase(self, *args):
//        return _pythia8.VectorClustering_erase(self, *args)
//
//    def __init__(self, *args):
//        this = _pythia8.new_VectorClustering(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def push_back(self, x):
//        return _pythia8.VectorClustering_push_back(self, x)
//
//    def front(self):
//        return _pythia8.VectorClustering_front(self)
//
//    def back(self):
//        return _pythia8.VectorClustering_back(self)
//
//    def assign(self, n, x):
//        return _pythia8.VectorClustering_assign(self, n, x)
//
//    def resize(self, *args):
//        return _pythia8.VectorClustering_resize(self, *args)
//
//    def insert(self, *args):
//        return _pythia8.VectorClustering_insert(self, *args)
//
//    def reserve(self, n):
//        return _pythia8.VectorClustering_reserve(self, n)
//
//    def capacity(self):
//        return _pythia8.VectorClustering_capacity(self)
//    __swig_destroy__ = _pythia8.delete_VectorClustering
//    __del__ = lambda self: None
//VectorClustering_swigregister = _pythia8.VectorClustering_swigregister
//VectorClustering_swigregister(VectorClustering)
//
//class VectorHelicityParticle(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, VectorHelicityParticle, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, VectorHelicityParticle, name)
//    __repr__ = _swig_repr
//
//    def iterator(self):
//        return _pythia8.VectorHelicityParticle_iterator(self)
//    def __iter__(self):
//        return self.iterator()
//
//    def __nonzero__(self):
//        return _pythia8.VectorHelicityParticle___nonzero__(self)
//
//    def __bool__(self):
//        return _pythia8.VectorHelicityParticle___bool__(self)
//
//    def __len__(self):
//        return _pythia8.VectorHelicityParticle___len__(self)
//
//    def __getslice__(self, i, j):
//        return _pythia8.VectorHelicityParticle___getslice__(self, i, j)
//
//    def __setslice__(self, *args):
//        return _pythia8.VectorHelicityParticle___setslice__(self, *args)
//
//    def __delslice__(self, i, j):
//        return _pythia8.VectorHelicityParticle___delslice__(self, i, j)
//
//    def __delitem__(self, *args):
//        return _pythia8.VectorHelicityParticle___delitem__(self, *args)
//
//    def __getitem__(self, *args):
//        return _pythia8.VectorHelicityParticle___getitem__(self, *args)
//
//    def __setitem__(self, *args):
//        return _pythia8.VectorHelicityParticle___setitem__(self, *args)
//
//    def pop(self):
//        return _pythia8.VectorHelicityParticle_pop(self)
//
//    def append(self, x):
//        return _pythia8.VectorHelicityParticle_append(self, x)
//
//    def empty(self):
//        return _pythia8.VectorHelicityParticle_empty(self)
//
//    def size(self):
//        return _pythia8.VectorHelicityParticle_size(self)
//
//    def swap(self, v):
//        return _pythia8.VectorHelicityParticle_swap(self, v)
//
//    def begin(self):
//        return _pythia8.VectorHelicityParticle_begin(self)
//
//    def end(self):
//        return _pythia8.VectorHelicityParticle_end(self)
//
//    def rbegin(self):
//        return _pythia8.VectorHelicityParticle_rbegin(self)
//
//    def rend(self):
//        return _pythia8.VectorHelicityParticle_rend(self)
//
//    def clear(self):
//        return _pythia8.VectorHelicityParticle_clear(self)
//
//    def get_allocator(self):
//        return _pythia8.VectorHelicityParticle_get_allocator(self)
//
//    def pop_back(self):
//        return _pythia8.VectorHelicityParticle_pop_back(self)
//
//    def erase(self, *args):
//        return _pythia8.VectorHelicityParticle_erase(self, *args)
//
//    def __init__(self, *args):
//        this = _pythia8.new_VectorHelicityParticle(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def push_back(self, x):
//        return _pythia8.VectorHelicityParticle_push_back(self, x)
//
//    def front(self):
//        return _pythia8.VectorHelicityParticle_front(self)
//
//    def back(self):
//        return _pythia8.VectorHelicityParticle_back(self)
//
//    def assign(self, n, x):
//        return _pythia8.VectorHelicityParticle_assign(self, n, x)
//
//    def resize(self, *args):
//        return _pythia8.VectorHelicityParticle_resize(self, *args)
//
//    def insert(self, *args):
//        return _pythia8.VectorHelicityParticle_insert(self, *args)
//
//    def reserve(self, n):
//        return _pythia8.VectorHelicityParticle_reserve(self, n)
//
//    def capacity(self):
//        return _pythia8.VectorHelicityParticle_capacity(self)
//    __swig_destroy__ = _pythia8.delete_VectorHelicityParticle
//    __del__ = lambda self: None
//VectorHelicityParticle_swigregister = _pythia8.VectorHelicityParticle_swigregister
//VectorHelicityParticle_swigregister(VectorHelicityParticle)
//
//class VectorProcessContainerPtr(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, VectorProcessContainerPtr, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, VectorProcessContainerPtr, name)
//    __repr__ = _swig_repr
//
//    def iterator(self):
//        return _pythia8.VectorProcessContainerPtr_iterator(self)
//    def __iter__(self):
//        return self.iterator()
//
//    def __nonzero__(self):
//        return _pythia8.VectorProcessContainerPtr___nonzero__(self)
//
//    def __bool__(self):
//        return _pythia8.VectorProcessContainerPtr___bool__(self)
//
//    def __len__(self):
//        return _pythia8.VectorProcessContainerPtr___len__(self)
//
//    def __getslice__(self, i, j):
//        return _pythia8.VectorProcessContainerPtr___getslice__(self, i, j)
//
//    def __setslice__(self, *args):
//        return _pythia8.VectorProcessContainerPtr___setslice__(self, *args)
//
//    def __delslice__(self, i, j):
//        return _pythia8.VectorProcessContainerPtr___delslice__(self, i, j)
//
//    def __delitem__(self, *args):
//        return _pythia8.VectorProcessContainerPtr___delitem__(self, *args)
//
//    def __getitem__(self, *args):
//        return _pythia8.VectorProcessContainerPtr___getitem__(self, *args)
//
//    def __setitem__(self, *args):
//        return _pythia8.VectorProcessContainerPtr___setitem__(self, *args)
//
//    def pop(self):
//        return _pythia8.VectorProcessContainerPtr_pop(self)
//
//    def append(self, x):
//        return _pythia8.VectorProcessContainerPtr_append(self, x)
//
//    def empty(self):
//        return _pythia8.VectorProcessContainerPtr_empty(self)
//
//    def size(self):
//        return _pythia8.VectorProcessContainerPtr_size(self)
//
//    def swap(self, v):
//        return _pythia8.VectorProcessContainerPtr_swap(self, v)
//
//    def begin(self):
//        return _pythia8.VectorProcessContainerPtr_begin(self)
//
//    def end(self):
//        return _pythia8.VectorProcessContainerPtr_end(self)
//
//    def rbegin(self):
//        return _pythia8.VectorProcessContainerPtr_rbegin(self)
//
//    def rend(self):
//        return _pythia8.VectorProcessContainerPtr_rend(self)
//
//    def clear(self):
//        return _pythia8.VectorProcessContainerPtr_clear(self)
//
//    def get_allocator(self):
//        return _pythia8.VectorProcessContainerPtr_get_allocator(self)
//
//    def pop_back(self):
//        return _pythia8.VectorProcessContainerPtr_pop_back(self)
//
//    def erase(self, *args):
//        return _pythia8.VectorProcessContainerPtr_erase(self, *args)
//
//    def __init__(self, *args):
//        this = _pythia8.new_VectorProcessContainerPtr(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def push_back(self, x):
//        return _pythia8.VectorProcessContainerPtr_push_back(self, x)
//
//    def front(self):
//        return _pythia8.VectorProcessContainerPtr_front(self)
//
//    def back(self):
//        return _pythia8.VectorProcessContainerPtr_back(self)
//
//    def assign(self, n, x):
//        return _pythia8.VectorProcessContainerPtr_assign(self, n, x)
//
//    def resize(self, *args):
//        return _pythia8.VectorProcessContainerPtr_resize(self, *args)
//
//    def insert(self, *args):
//        return _pythia8.VectorProcessContainerPtr_insert(self, *args)
//
//    def reserve(self, n):
//        return _pythia8.VectorProcessContainerPtr_reserve(self, n)
//
//    def capacity(self):
//        return _pythia8.VectorProcessContainerPtr_capacity(self)
//    __swig_destroy__ = _pythia8.delete_VectorProcessContainerPtr
//    __del__ = lambda self: None
//VectorProcessContainerPtr_swigregister = _pythia8.VectorProcessContainerPtr_swigregister
//VectorProcessContainerPtr_swigregister(VectorProcessContainerPtr)
//
//class VectorResonanceWidthsPtr(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, VectorResonanceWidthsPtr, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, VectorResonanceWidthsPtr, name)
//    __repr__ = _swig_repr
//
//    def iterator(self):
//        return _pythia8.VectorResonanceWidthsPtr_iterator(self)
//    def __iter__(self):
//        return self.iterator()
//
//    def __nonzero__(self):
//        return _pythia8.VectorResonanceWidthsPtr___nonzero__(self)
//
//    def __bool__(self):
//        return _pythia8.VectorResonanceWidthsPtr___bool__(self)
//
//    def __len__(self):
//        return _pythia8.VectorResonanceWidthsPtr___len__(self)
//
//    def __getslice__(self, i, j):
//        return _pythia8.VectorResonanceWidthsPtr___getslice__(self, i, j)
//
//    def __setslice__(self, *args):
//        return _pythia8.VectorResonanceWidthsPtr___setslice__(self, *args)
//
//    def __delslice__(self, i, j):
//        return _pythia8.VectorResonanceWidthsPtr___delslice__(self, i, j)
//
//    def __delitem__(self, *args):
//        return _pythia8.VectorResonanceWidthsPtr___delitem__(self, *args)
//
//    def __getitem__(self, *args):
//        return _pythia8.VectorResonanceWidthsPtr___getitem__(self, *args)
//
//    def __setitem__(self, *args):
//        return _pythia8.VectorResonanceWidthsPtr___setitem__(self, *args)
//
//    def pop(self):
//        return _pythia8.VectorResonanceWidthsPtr_pop(self)
//
//    def append(self, x):
//        return _pythia8.VectorResonanceWidthsPtr_append(self, x)
//
//    def empty(self):
//        return _pythia8.VectorResonanceWidthsPtr_empty(self)
//
//    def size(self):
//        return _pythia8.VectorResonanceWidthsPtr_size(self)
//
//    def swap(self, v):
//        return _pythia8.VectorResonanceWidthsPtr_swap(self, v)
//
//    def begin(self):
//        return _pythia8.VectorResonanceWidthsPtr_begin(self)
//
//    def end(self):
//        return _pythia8.VectorResonanceWidthsPtr_end(self)
//
//    def rbegin(self):
//        return _pythia8.VectorResonanceWidthsPtr_rbegin(self)
//
//    def rend(self):
//        return _pythia8.VectorResonanceWidthsPtr_rend(self)
//
//    def clear(self):
//        return _pythia8.VectorResonanceWidthsPtr_clear(self)
//
//    def get_allocator(self):
//        return _pythia8.VectorResonanceWidthsPtr_get_allocator(self)
//
//    def pop_back(self):
//        return _pythia8.VectorResonanceWidthsPtr_pop_back(self)
//
//    def erase(self, *args):
//        return _pythia8.VectorResonanceWidthsPtr_erase(self, *args)
//
//    def __init__(self, *args):
//        this = _pythia8.new_VectorResonanceWidthsPtr(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def push_back(self, x):
//        return _pythia8.VectorResonanceWidthsPtr_push_back(self, x)
//
//    def front(self):
//        return _pythia8.VectorResonanceWidthsPtr_front(self)
//
//    def back(self):
//        return _pythia8.VectorResonanceWidthsPtr_back(self)
//
//    def assign(self, n, x):
//        return _pythia8.VectorResonanceWidthsPtr_assign(self, n, x)
//
//    def resize(self, *args):
//        return _pythia8.VectorResonanceWidthsPtr_resize(self, *args)
//
//    def insert(self, *args):
//        return _pythia8.VectorResonanceWidthsPtr_insert(self, *args)
//
//    def reserve(self, n):
//        return _pythia8.VectorResonanceWidthsPtr_reserve(self, n)
//
//    def capacity(self):
//        return _pythia8.VectorResonanceWidthsPtr_capacity(self)
//    __swig_destroy__ = _pythia8.delete_VectorResonanceWidthsPtr
//    __del__ = lambda self: None
//VectorResonanceWidthsPtr_swigregister = _pythia8.VectorResonanceWidthsPtr_swigregister
//VectorResonanceWidthsPtr_swigregister(VectorResonanceWidthsPtr)
//
//class VectorSigmaProcessPtr(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, VectorSigmaProcessPtr, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, VectorSigmaProcessPtr, name)
//    __repr__ = _swig_repr
//
//    def iterator(self):
//        return _pythia8.VectorSigmaProcessPtr_iterator(self)
//    def __iter__(self):
//        return self.iterator()
//
//    def __nonzero__(self):
//        return _pythia8.VectorSigmaProcessPtr___nonzero__(self)
//
//    def __bool__(self):
//        return _pythia8.VectorSigmaProcessPtr___bool__(self)
//
//    def __len__(self):
//        return _pythia8.VectorSigmaProcessPtr___len__(self)
//
//    def __getslice__(self, i, j):
//        return _pythia8.VectorSigmaProcessPtr___getslice__(self, i, j)
//
//    def __setslice__(self, *args):
//        return _pythia8.VectorSigmaProcessPtr___setslice__(self, *args)
//
//    def __delslice__(self, i, j):
//        return _pythia8.VectorSigmaProcessPtr___delslice__(self, i, j)
//
//    def __delitem__(self, *args):
//        return _pythia8.VectorSigmaProcessPtr___delitem__(self, *args)
//
//    def __getitem__(self, *args):
//        return _pythia8.VectorSigmaProcessPtr___getitem__(self, *args)
//
//    def __setitem__(self, *args):
//        return _pythia8.VectorSigmaProcessPtr___setitem__(self, *args)
//
//    def pop(self):
//        return _pythia8.VectorSigmaProcessPtr_pop(self)
//
//    def append(self, x):
//        return _pythia8.VectorSigmaProcessPtr_append(self, x)
//
//    def empty(self):
//        return _pythia8.VectorSigmaProcessPtr_empty(self)
//
//    def size(self):
//        return _pythia8.VectorSigmaProcessPtr_size(self)
//
//    def swap(self, v):
//        return _pythia8.VectorSigmaProcessPtr_swap(self, v)
//
//    def begin(self):
//        return _pythia8.VectorSigmaProcessPtr_begin(self)
//
//    def end(self):
//        return _pythia8.VectorSigmaProcessPtr_end(self)
//
//    def rbegin(self):
//        return _pythia8.VectorSigmaProcessPtr_rbegin(self)
//
//    def rend(self):
//        return _pythia8.VectorSigmaProcessPtr_rend(self)
//
//    def clear(self):
//        return _pythia8.VectorSigmaProcessPtr_clear(self)
//
//    def get_allocator(self):
//        return _pythia8.VectorSigmaProcessPtr_get_allocator(self)
//
//    def pop_back(self):
//        return _pythia8.VectorSigmaProcessPtr_pop_back(self)
//
//    def erase(self, *args):
//        return _pythia8.VectorSigmaProcessPtr_erase(self, *args)
//
//    def __init__(self, *args):
//        this = _pythia8.new_VectorSigmaProcessPtr(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def push_back(self, x):
//        return _pythia8.VectorSigmaProcessPtr_push_back(self, x)
//
//    def front(self):
//        return _pythia8.VectorSigmaProcessPtr_front(self)
//
//    def back(self):
//        return _pythia8.VectorSigmaProcessPtr_back(self)
//
//    def assign(self, n, x):
//        return _pythia8.VectorSigmaProcessPtr_assign(self, n, x)
//
//    def resize(self, *args):
//        return _pythia8.VectorSigmaProcessPtr_resize(self, *args)
//
//    def insert(self, *args):
//        return _pythia8.VectorSigmaProcessPtr_insert(self, *args)
//
//    def reserve(self, n):
//        return _pythia8.VectorSigmaProcessPtr_reserve(self, n)
//
//    def capacity(self):
//        return _pythia8.VectorSigmaProcessPtr_capacity(self)
//    __swig_destroy__ = _pythia8.delete_VectorSigmaProcessPtr
//    __del__ = lambda self: None
//VectorSigmaProcessPtr_swigregister = _pythia8.VectorSigmaProcessPtr_swigregister
//VectorSigmaProcessPtr_swigregister(VectorSigmaProcessPtr)
//
//class VectorVec4(_object):
//    __swig_setmethods__ = {}
//    __setattr__ = lambda self, name, value: _swig_setattr(self, VectorVec4, name, value)
//    __swig_getmethods__ = {}
//    __getattr__ = lambda self, name: _swig_getattr(self, VectorVec4, name)
//    __repr__ = _swig_repr
//
//    def iterator(self):
//        return _pythia8.VectorVec4_iterator(self)
//    def __iter__(self):
//        return self.iterator()
//
//    def __nonzero__(self):
//        return _pythia8.VectorVec4___nonzero__(self)
//
//    def __bool__(self):
//        return _pythia8.VectorVec4___bool__(self)
//
//    def __len__(self):
//        return _pythia8.VectorVec4___len__(self)
//
//    def __getslice__(self, i, j):
//        return _pythia8.VectorVec4___getslice__(self, i, j)
//
//    def __setslice__(self, *args):
//        return _pythia8.VectorVec4___setslice__(self, *args)
//
//    def __delslice__(self, i, j):
//        return _pythia8.VectorVec4___delslice__(self, i, j)
//
//    def __delitem__(self, *args):
//        return _pythia8.VectorVec4___delitem__(self, *args)
//
//    def __getitem__(self, *args):
//        return _pythia8.VectorVec4___getitem__(self, *args)
//
//    def __setitem__(self, *args):
//        return _pythia8.VectorVec4___setitem__(self, *args)
//
//    def pop(self):
//        return _pythia8.VectorVec4_pop(self)
//
//    def append(self, x):
//        return _pythia8.VectorVec4_append(self, x)
//
//    def empty(self):
//        return _pythia8.VectorVec4_empty(self)
//
//    def size(self):
//        return _pythia8.VectorVec4_size(self)
//
//    def swap(self, v):
//        return _pythia8.VectorVec4_swap(self, v)
//
//    def begin(self):
//        return _pythia8.VectorVec4_begin(self)
//
//    def end(self):
//        return _pythia8.VectorVec4_end(self)
//
//    def rbegin(self):
//        return _pythia8.VectorVec4_rbegin(self)
//
//    def rend(self):
//        return _pythia8.VectorVec4_rend(self)
//
//    def clear(self):
//        return _pythia8.VectorVec4_clear(self)
//
//    def get_allocator(self):
//        return _pythia8.VectorVec4_get_allocator(self)
//
//    def pop_back(self):
//        return _pythia8.VectorVec4_pop_back(self)
//
//    def erase(self, *args):
//        return _pythia8.VectorVec4_erase(self, *args)
//
//    def __init__(self, *args):
//        this = _pythia8.new_VectorVec4(*args)
//        try:
//            self.this.append(this)
//        except Exception:
//            self.this = this
//
//    def push_back(self, x):
//        return _pythia8.VectorVec4_push_back(self, x)
//
//    def front(self):
//        return _pythia8.VectorVec4_front(self)
//
//    def back(self):
//        return _pythia8.VectorVec4_back(self)
//
//    def assign(self, n, x):
//        return _pythia8.VectorVec4_assign(self, n, x)
//
//    def resize(self, *args):
//        return _pythia8.VectorVec4_resize(self, *args)
//
//    def insert(self, *args):
//        return _pythia8.VectorVec4_insert(self, *args)
//
//    def reserve(self, n):
//        return _pythia8.VectorVec4_reserve(self, n)
//
//    def capacity(self):
//        return _pythia8.VectorVec4_capacity(self)
//    __swig_destroy__ = _pythia8.delete_VectorVec4
//    __del__ = lambda self: None
//VectorVec4_swigregister = _pythia8.VectorVec4_swigregister
//VectorVec4_swigregister(VectorVec4)
//
//# This file is compatible with both classic and new-style classes.
//
//
